packetCombiner.hpp

Go to the documentation of this file.

 
#include "fitsConverterIf.hpp"
 
#include <llnetio/mudpi/mudpi.hpp>
#include <llnetio/rtms/rtms.hpp>
#include <taiclock/taiClock.hpp>
 
#include <map>
#include <vector>

struct StreamIdentifier {
    int32_t topic_id;
    uint16_t component_id;
    uint16_t application_tag;
 
    bool operator<(const StreamIdentifier& rhs) const {
        if (topic_id != rhs.topic_id) {
            return topic_id < rhs.topic_id;
        }
        if (component_id != rhs.component_id) {
            return component_id < rhs.component_id;
        }
 
        return application_tag < rhs.application_tag;
    }
    bool operator==(const StreamIdentifier& rhs) const {
        return topic_id == rhs.topic_id && component_id == rhs.component_id &&
               application_tag == rhs.application_tag;
    }
    bool operator!=(const StreamIdentifier& rhs) const {
        return not(*this == rhs);
    }
 
    explicit StreamIdentifier(int32_t new_topic_id,
                              uint16_t new_component_id,
                              uint16_t new_application_tag)
        : topic_id{new_topic_id}
        , component_id{new_component_id}
        , application_tag{new_application_tag} {
    }
    StreamIdentifier() : topic_id{}, component_id{}, application_tag{} {
    }
};

struct SampleIdentifier {
    StreamIdentifier stream_id;
    uint32_t sample_id;
    bool operator<(const SampleIdentifier& rhs) const {
        if (stream_id != rhs.stream_id) {
            return stream_id < rhs.stream_id;
        }
        return sample_id < rhs.sample_id;
    }
    bool operator==(const SampleIdentifier& rhs) const {
        return stream_id == rhs.stream_id && sample_id == rhs.sample_id;
    }
    bool operator!=(const SampleIdentifier& rhs) const {
        return not(*this == rhs);
    }
    explicit SampleIdentifier(StreamIdentifier new_stream_id, uint32_t new_sample_id)
        : stream_id{new_stream_id}, sample_id{new_sample_id} {
    }
    SampleIdentifier() : stream_id{}, sample_id{} {
    }
};

struct FrameIdentifier {
    SampleIdentifier sample_id;
    uint16_t frame_id;
 
    bool operator<(const FrameIdentifier& rhs) const {
        if (sample_id != rhs.sample_id) {
            return sample_id < rhs.sample_id;
        }
        return frame_id < rhs.frame_id;
    }
    bool operator==(const FrameIdentifier& rhs) const {
        return sample_id == rhs.sample_id && frame_id == rhs.frame_id;
    }
    bool operator!=(const FrameIdentifier& rhs) const {
        return not(*this == rhs);
    }
 
    explicit FrameIdentifier(SampleIdentifier new_sample_id, uint16_t new_frame_id)
        : sample_id{new_sample_id}, frame_id{new_frame_id} {
    }
    FrameIdentifier() : sample_id{}, frame_id{} {
    }
};

struct FrameMetadata {
    // MUDPI frame_id value
    llnetio::mudpi::FrameId frame_id;
    // MUDPI frame_count value
    llnetio::mudpi::NumFrames frame_count;
    // Frame type
    llnetio::rtms::PacketType frame_type;
    // rtms simulated flag
    llnetio::rtms::Source source;
    // rtms little_endian flag
    llnetio::rtms::Endianness endianness;
    // rtms status field
    llnetio::rtms::Status status;
    // mudpi timestamp
    taiclock::TaiClock::time_point mudpi_timestamp;
    // timestamp from the pcap capture
    taiclock::TaiClock::time_point pcap_timestamp;
 
    explicit FrameMetadata(uint16_t new_frame_id,
                           uint16_t new_frame_count,
                           enum llnetio::rtms::PacketType new_frame_type,
                           llnetio::rtms::Source new_source,
                           llnetio::rtms::Endianness new_endianness,
                           llnetio::rtms::Status new_status,
                           taiclock::TaiClock::time_point new_mudpi_timestamp,
                           taiclock::TaiClock::time_point new_pcap_timestamp)
        : frame_id{new_frame_id}
        , frame_count{new_frame_count}
        , frame_type{new_frame_type}
        , source{new_source}
        , endianness{new_endianness}
        , status{new_status}
        , mudpi_timestamp{new_mudpi_timestamp}
        , pcap_timestamp{new_pcap_timestamp} {
    }
    FrameMetadata()
        : frame_id{}
        , frame_count{}
        , frame_type{}
        , source{}
        , endianness{}
        , status{}
        , mudpi_timestamp{}
        , pcap_timestamp{} {
    }
};

struct CombinedFrames {
    SampleIdentifier identifier;
    std::vector<uint8_t> payload_data;
    std::map<uint16_t, FrameMetadata> metadata;
 
    explicit CombinedFrames(SampleIdentifier new_identifier,
                            std::vector<uint8_t> new_payload_data,
                            std::map<uint16_t, FrameMetadata> new_metadata)
        : identifier{new_identifier}
        , payload_data{std::move(new_payload_data)}
        , metadata{std::move(new_metadata)} {
    }
    CombinedFrames() = default;
};

class PacketCombiner {
public:
    explicit PacketCombiner(std::function<void(const CombinedFrames&)> callback);
    void AddSample(const PacketData& data);
 
private:
    void CombineFrames(const SampleIdentifier& sample_id);
 
    // cppcheck-suppress-begin unusedStructMember
 
    std::map<SampleIdentifier, std::map<uint16_t, FrameMetadata>> m_packet_meta_data;
    std::map<SampleIdentifier, std::map<uint16_t, std::vector<uint8_t>>> m_packet_payloads;
    std::map<SampleIdentifier, uint16_t> m_frame_count;
    std::function<void(const CombinedFrames&)> m_callback;
 
    // cppcheck-suppress-end unusedStructMember
};