mudpiCreatorParallel.hpp

Go to the documentation of this file.

 
// This class was copied from the MELT CS repository.
 
 
#ifndef FGF_COM_MUDPI_CREATOR_PARALLEL_HPP_H_
#define FGF_COM_MUDPI_CREATOR_PARALLEL_HPP_H_
 
#define BOOST_BIND_NO_PLACEHOLDERS
 
#include <cstdint>
#include <vector>
 
#include <mudpiif/MudpiPacket.hpp>
#include <hrtcpif/HrtcpCommonPacket.hpp>
#include <hrtcpif/HrtcpLeaderPacket.hpp>
#include <hrtcpif/HrtcpTrailerPacket.hpp>
#include <hrtcpif/HrtcpPayloadPacket.hpp>
 
namespace ifw::fgf::common {
 
    class MudpiCreatorParallel {
      public:
 
        static const size_t NUM_THREADS = 8; // Number of worker threads
        
        
        MudpiCreatorParallel(uint32_t mudpi_topic_id,
                    uint16_t mudpi_component_id,
                    uint32_t starting_mudpi_sample_id,
                    hrtcpif::SimSource hrtcp_sim_source,
                    hrtcpif::Endianness hrtcp_endianness);
 
        MudpiCreatorParallel(MudpiCreatorParallel&) = delete;
        MudpiCreatorParallel(MudpiCreatorParallel&&) = delete;
        MudpiCreatorParallel& operator=(MudpiCreatorParallel&) = delete;
 
        void createInitialPackets(size_t raw_image_size, int bytes_per_pixel);
        std::vector<mudpiif::mudpiPacketJumbo>&
        assemblePackets(std::vector<unsigned char>& raw_image_data,
                                      int bytes_per_pixel,
                                      double timestamp);
        void increaseSampleId();
 
      private:
        uint32_t getSampleId() { return m_mudpi_sample_identity; }
 
        std::vector<mudpiif::mudpiPacketJumbo> m_mudpi_packets;
 
        uint32_t m_mudpi_sample_identity;
        uint32_t m_mudpi_topic_identity;
        uint16_t m_mudpi_component_identity;
        hrtcpif::SimSource m_hrtcp_sim_source;
        hrtcpif::Endianness m_hrtcp_endianness;
        size_t m_image_size{0};
 
        void assembleInitialLeadingPacket(size_t raw_image_size, int bytes_per_pixel);
        void assembleInitialTrailingPacket(size_t raw_image_size);
        void assembleInitialPayloadPackets(size_t raw_image_size,
                                         int bytes_per_pixel);
        void updatePayloadPackets(const std::vector<unsigned char>& raw_image_data,
                                  size_t start,
                                  size_t end,
                                  size_t packet_start_index,
                                  size_t num_packets,
                                  double timestamp);
 
    };
 
}
 
#endif /* FGF_COM_MUDPI_CREATOR_PARALLEL_HPP_H_ */