#include "puzzled_frame.hh"
#include <DataFormats/clb_common_header.hh>
#include <DataFormats/infoword.hh>
#include "input_buffer_collector.hh"
#include <string.h>
#include <log.hh>
#include <utility>
#include <stdexcept>

Functions
uint32_t	calculate_number_of_items (Frame const &frame)

std::pair< unsigned int, unsigned int >	opt_boundaries (CLBDataGram const &dg, std::size_t max_size)

void	buildOpto (PuzzledFrame::container_t const &c, frame_idx_t frame_idx, Frame &frame)

std::pair< unsigned int, unsigned int >	acou_boundaries (CLBDataGram const &dg, std::size_t max_size, std::size_t item_size)

void	buildAcou (PuzzledFrame::container_t const &c, frame_idx_t frame_idx, Frame &frame)

Function Documentation

◆ calculate_number_of_items()

uint32_t calculate_number_of_items ( Frame const & frame )

Definition at line 35 of file puzzled_frame.cc.

{
  uint32_t nitems = 0;
  uint32_t const frame_length = frame.size();
 
  uint32_t const data_type = frame.getHeader()->DataType;
 
  if (is_optical(data_type)) {
    nitems = (frame_length - sizeof(DAQCommonHeader)) / 6; // 6 is sizeof(hit)
  } else if (is_acoustic(data_type)) {
    InfoWord const*const iw = static_cast<const InfoWord*>(
        static_cast<const void*>(frame.getPayload()));
 
    const unsigned int audiowordsize = iw->audioWordSize();
 
    nitems = (frame_length
        - sizeof(DAQCommonHeader)
        - sizeof(InfoWord))
        / audiowordsize;
  } else {
    throw std::runtime_error("Unknown data type");
  }
 
  return nitems;
}

◆ opt_boundaries()

std::pair< unsigned int, unsigned int > opt_boundaries	(	CLBDataGram const &	dg,
		std::size_t	max_size )

Definition at line 89 of file puzzled_frame.cc.

{
  std::size_t const previous_packets_size =
      dg.getCLBCommonHeader()->udpSequenceNumber()
      * (max_size - sizeof(CLBCommonHeader));
 
  std::size_t const chunk_in_previous = previous_packets_size % 6;
 
  unsigned int const head =
      chunk_in_previous
        ? 6 - chunk_in_previous
        : 0;
 
  unsigned int const tail =
      (dg.size() - sizeof(CLBCommonHeader) - head) % 6;
 
  return std::make_pair(head, tail);
}

◆ buildOpto()

void buildOpto	(	PuzzledFrame::container_t const &	c,
		frame_idx_t	frame_idx,
		Frame &	frame )

Definition at line 116 of file puzzled_frame.cc.

{
  assert(
      (
          c.size() > 1
          || c.begin()->second->getCLBCommonHeader()->udpSequenceNumber() == 0
      )
      && "Precondition failed."
  );
 
  uint32_t current_seq_number = 0;
  unsigned int previous_chunk = 0;
 
  std::size_t const max_size = c.begin()->second->size();
 
  std::size_t size = sizeof(DAQCommonHeader);
 
  for (
      PuzzledFrame::container_t::const_iterator it = c.begin(), et = c.end();
      it != et;
      ++it
  ) {
 
    CLBDataGram const& dg = *it->second;
    std::pair<unsigned int, unsigned int> const bounds = opt_boundaries(
        dg,
        max_size
    );
 
    if (dg.getCLBCommonHeader()->udpSequenceNumber() != current_seq_number) {
      LOG_DEBUG << "Datagram "
                << current_seq_number
                << " not present in optical frame "
                << frame_idx
                << ". Packet loss(?)";
 
      Log::Counter::get().add("missing odgram");
 
      char* const dest = &frame.front() + size - previous_chunk;
 
      std::size_t const write_size = dg.getPayloadSize() - bounds.first;
 
      std::memcpy(dest, dg.getPayload() + bounds.first, write_size);
 
      size += write_size - previous_chunk;
    } else {
      char* const dest = &frame.front() + size;
 
      std::size_t const write_size = dg.getPayloadSize();
 
      std::memcpy(dest, dg.getPayload(), write_size);
 
      size += write_size;
    }
 
    current_seq_number = dg.getCLBCommonHeader()->udpSequenceNumber() + 1;
    previous_chunk = bounds.second;
  }
 
  // check whether size is compatible an integer number of items
  // and if not strip away the boundary
 
  if (previous_chunk != 0) {
    LOG_DEBUG << "Missing last datagram(s) in optical frame "
              << frame_idx
              << ". Packet loss (?).";
 
    Log::Counter::get().add("missing odgram");
    size -= previous_chunk;
  }
 
  // check the presence of the trailer
 
  if (!isTrailer(*c.rbegin()->second->getCLBCommonHeader())) {
    LOG_DEBUG << "Missing trailer in optical frame "
              << frame_idx;
 
    Log::Counter::get().add("missing trailer");
  }
 
  frame.resize(size);
}

◆ acou_boundaries()

std::pair< unsigned int, unsigned int > acou_boundaries	(	CLBDataGram const &	dg,
		std::size_t	max_size,
		std::size_t	item_size )

Definition at line 202 of file puzzled_frame.cc.

{
  unsigned int head = 0;
  unsigned int tail = 0;
 
  if (dg.getCLBCommonHeader()->udpSequenceNumber() != 0) {
    std::size_t const previous_audio_size =
        dg.getCLBCommonHeader()->udpSequenceNumber()
        * (max_size - sizeof(CLBCommonHeader))
        - sizeof(InfoWord);
 
    std::size_t const chunk_in_previous = previous_audio_size % item_size;
 
    head = chunk_in_previous ? item_size - chunk_in_previous : 0;
 
    tail = (dg.size() - sizeof(CLBCommonHeader) - head) % item_size;
  } else {
    head = 0;
    tail = (dg.size() - sizeof(CLBCommonHeader) - sizeof(InfoWord)) % item_size;
  }
 
  return std::make_pair(head, tail);
}

◆ buildAcou()

void buildAcou	(	PuzzledFrame::container_t const &	c,
		frame_idx_t	frame_idx,
		Frame &	frame )

Definition at line 234 of file puzzled_frame.cc.