packetCombiner.hpp

Go to the documentation of this file.

 
#include <map>
#include <vector>
 
#include "fitsConverterIf.hpp"
 
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() = default;
};
 
struct SampleIdentifier {
    StreamIdentifier stream_id;
    uint32_t sample_id;
    bool operator <(const SampleIdentifier& rhs) const
    {
        if(stream_id != rhs.stream_id) {
            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() = default;
};
 
struct FrameIdentifier {
    SampleIdentifier sample_id;
    uint16_t frame_id;
 
    bool operator <(const FrameIdentifier& rhs) const
    {
        if(sample_id != rhs.sample_id) {
            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() = default;
};
 
enum RTMSFrameType {
    RTMS_LEADER,
    RTMS_PAYLOAD,
    RTMS_TRAILER
};
 
struct FrameMetadata {
    // MUDPI frame_id value
    uint16_t frame_id;
    // MUDPI frame_count value
    uint16_t frame_count;
    // Frame type
    enum RTMSFrameType frame_type;
    // rtms simulated flag
    bool simulated;
    // rtms little_endian flag
    bool little_endian;
    // rtms status field
    uint32_t status;
    // mudpi timestamp
    double mudpi_timestamp;
    // timestamp from the pcap capture
    double pcap_timestamp;
 
    explicit FrameMetadata(uint16_t new_frame_id,
                  uint16_t new_frame_count,
                  enum RTMSFrameType new_frame_type,
                  bool new_simulated,
                  bool new_little_endian,
                  uint32_t new_status,
                  double new_mudpi_timestamp,
                  double new_pcap_timestamp)
        : frame_id{new_frame_id}
        , frame_count{new_frame_count}
        , frame_type{new_frame_type}
        , simulated{new_simulated}
        , little_endian{new_little_endian}
        , status{new_status}
        , mudpi_timestamp{new_mudpi_timestamp}
        , pcap_timestamp{new_pcap_timestamp} {  }
    FrameMetadata() = default;
};
 
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);
        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;
 
};