puzzled_frame.cc File Reference

#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>

Go to the source code of this file.

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

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;
}

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);
}

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);
}

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);
}

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

Definition at line 234 of file puzzled_frame.cc.

{
  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);

  InfoWord const& iw = *static_cast<const InfoWord*>(
      static_cast<const void*>(c.begin()->second->getPayload()));

  unsigned int const audio_word_size = iw.audioWordSize();

  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 = acou_boundaries(
        dg,
        max_size,
        audio_word_size);

    if (dg.getCLBCommonHeader()->udpSequenceNumber() != current_seq_number) {
      LOG_DEBUG << "Datagram "
                << current_seq_number
                << " not present in acoustic frame "
                << frame_idx
                << ". Packet loss(?)";

      Log::Counter::get().add("missing adgram");

      size -= previous_chunk;
      break;
    } else {
      char* const dest = &frame.front() + size;

      std::size_t const write_size = dg.getPayloadSize();

      memcpy(dest, dg.getPayload(), write_size);

      size += write_size;
    }

    ++current_seq_number;
    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 acoustic frame "
              << frame_idx
              << ". Packet loss (?).";

    Log::Counter::get().add("missing adgram");
    size -= previous_chunk;
  }

  frame.resize(size);
}