serial::vita49::Vita49Serializer Class Reference

#include "vita49_serializer.h"

Static Public Member Functions
static std::vector< std::uint8_t >	serializeSignalData (const SignalDataPacket &packet)
static SignalDataSerializationResult	serializeSignalDataFixedFullscale (const FixedFullscaleSignalDataPacket &packet)
static std::vector< std::uint8_t >	serializeContext (const ContextPacket &packet)

Detailed Description

Definition at line 53 of file vita49_serializer.h.

Member Function Documentation

serializeContext()

std::vector< std::uint8_t > serial::vita49::Vita49Serializer::serializeContext ( const ContextPacket &  packet )

static

Definition at line 381 of file vita49_serializer.cpp.

    {
        if (packet.cif0 != kFersContextCif0)
        {
            throw std::invalid_argument(
                "Unsupported VITA 49.2 context CIF0: FERS serializer only supports kFersContextCif0");
        }
 
        ByteWriter payload;
        payload.writeU32(packet.cif0);
        payload.writeU32(packet.state_indicators);
        payload.writeU64(packet.payload_format);
        payload.writeF64(packet.sample_rate);
        payload.writeF64(packet.reference_frequency);
        payload.writeF64(packet.if_offset);
        payload.writeF64(packet.bandwidth);
        payload.writeF64(packet.adc_fullscale);
        payload.writeU64(packet.receiver_id);
        const auto metadata = makeContextMetadataJson(packet).dump(-1, ' ', true);
        payload.writeAsciiMetadata(metadata);
 
        const std::size_t byte_count = 4u + 4u + 8u + 4u + 8u + payload.bytes().size();
        const auto packet_size_words = checkedWordCount(byte_count);
 
        ByteWriter writer(byte_count);
        writer.writeU32(makeHeader(PacketType::Context, true, false, IntegerTimestampMode::Utc,
                                   FractionalTimestampMode::RealTimePicoseconds, packet.packet_count,
                                   packet_size_words));
        writer.writeU32(packet.stream_id);
        writer.writeU64(packet.class_id);
        writer.writeU32(packet.timestamp.integer_seconds);
        writer.writeU64(packet.timestamp.fractional_picoseconds);
        writer.writeBytes(payload.bytes());
        return writer.takeBytes();
    }

References serial::vita49::Context, serial::vita49::kFersContextCif0, serial::vita49::makeHeader(), max, serial::vita49::RealTimePicoseconds, and serial::vita49::Utc.

Referenced by serial::vita49::Vita49Packetizer::makeContextPacket().

Here is the call graph for this function:

Here is the caller graph for this function:

serializeSignalData()

std::vector< std::uint8_t > serial::vita49::Vita49Serializer::serializeSignalData ( const SignalDataPacket &  packet )

static

Definition at line 309 of file vita49_serializer.cpp.

    {
        if (packet.iq_interleaved.size() % 2u != 0u)
        {
            throw std::invalid_argument("VITA signal IQ payload must contain I/Q pairs");
        }
 
        const std::size_t byte_count = kSignalDataFixedBytes + packet.iq_interleaved.size() * sizeof(std::int16_t);
        const auto packet_size_words = checkedWordCount(byte_count);
 
        ByteWriter writer(byte_count);
        writer.writeU32(makeHeader(PacketType::SignalDataWithStreamId, true, true, IntegerTimestampMode::Utc,
                                   FractionalTimestampMode::RealTimePicoseconds, packet.packet_count,
                                   packet_size_words));
        writer.writeU32(packet.stream_id);
        writer.writeU64(packet.class_id);
        writer.writeU32(packet.timestamp.integer_seconds);
        writer.writeU64(packet.timestamp.fractional_picoseconds);
        for (const auto item : packet.iq_interleaved)
        {
            writer.writeI16(item);
        }
        writer.writeU32(packet.trailer);
 
        if (writer.bytes().size() != byte_count)
        {
            throw std::logic_error("VITA signal packet byte count mismatch");
        }
        return writer.takeBytes();
    }

References serial::vita49::kSignalDataFixedBytes, serial::vita49::makeHeader(), max, serial::vita49::RealTimePicoseconds, serial::vita49::SignalDataWithStreamId, and serial::vita49::Utc.

Here is the call graph for this function:

serializeSignalDataFixedFullscale()

SignalDataSerializationResult serial::vita49::Vita49Serializer::serializeSignalDataFixedFullscale ( const FixedFullscaleSignalDataPacket &  packet )

static

Definition at line 341 of file vita49_serializer.cpp.

    {
        if (!std::isfinite(packet.fullscale) || packet.fullscale <= 0.0)
        {
            throw std::invalid_argument("VITA signal full-scale must be positive and finite");
        }
 
        const std::size_t byte_count = kSignalDataFixedBytes + packet.samples.size() * sizeof(std::int16_t) * 2u;
        const auto packet_size_words = checkedWordCount(byte_count);
 
        ByteWriter writer(byte_count);
        writer.writeU32(makeHeader(PacketType::SignalDataWithStreamId, true, true, IntegerTimestampMode::Utc,
                                   FractionalTimestampMode::RealTimePicoseconds, packet.packet_count,
                                   packet_size_words));
        writer.writeU32(packet.stream_id);
        writer.writeU64(packet.class_id);
        writer.writeU32(packet.timestamp.integer_seconds);
        writer.writeU64(packet.timestamp.fractional_picoseconds);
 
        std::uint64_t clipped_sample_count = 0;
        for (const auto& sample : packet.samples)
        {
            bool clipped = false;
            writer.writeI16(scaleComponentToInt16(sample.real(), packet.fullscale, clipped));
            writer.writeI16(scaleComponentToInt16(sample.imag(), packet.fullscale, clipped));
            if (clipped)
            {
                ++clipped_sample_count;
            }
        }
        writer.writeU32(makeTrailer(packet.valid_data, packet.calibrated_time, packet.reference_lock,
                                    clipped_sample_count > 0, packet.sample_loss));
 
        if (writer.bytes().size() != byte_count)
        {
            throw std::logic_error("VITA direct signal packet byte count mismatch");
        }
        return SignalDataSerializationResult{.bytes = writer.takeBytes(), .clipped_sample_count = clipped_sample_count};
    }

References serial::vita49::SignalDataSerializationResult::bytes, serial::vita49::kSignalDataFixedBytes, serial::vita49::makeHeader(), serial::vita49::makeTrailer(), max, serial::vita49::RealTimePicoseconds, serial::vita49::SignalDataWithStreamId, and serial::vita49::Utc.

Referenced by serial::vita49::Vita49Packetizer::packetize().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• packages/libfers/src/serial/vita49/vita49_serializer.h
• packages/libfers/src/serial/vita49/vita49_serializer.cpp