LibFlute::AlcPacket Class Reference

A class for parsing and creating ALC packets. More...

#include <AlcPacket.h>

Public Member Functions
	AlcPacket (char *data, size_t len)
	Create an ALC packet from payload data. More...
	AlcPacket (uint16_t tsi, uint16_t toi, FecOti fec_oti, const std::vector< EncodingSymbol > &symbols, size_t max_size, uint32_t fdt_instance_id)
	Create an ALC packet from encoding symbols. More...
	~AlcPacket ()
	Default destructor. More...
uint64_t	tsi () const
	Get the TSI. More...
uint64_t	toi () const
	Get the TOI. More...
const FecOti &	fec_oti () const
	Get the FEC OTI values. More...
size_t	header_length () const
	Get the LCT header length. More...
uint32_t	fdt_instance_id () const
	Get the FDT instance ID. More...
FecScheme	fec_scheme () const
	Get the FEC scheme. More...
ContentEncoding	content_encoding () const
	Get the content encoding. More...
char *	data () const
	Get a pointer to the payload data of the constructed packet. More...
size_t	size () const
	Get the payload size. More...

Detailed Description

A class for parsing and creating ALC packets.

Definition at line 27 of file AlcPacket.h.

Constructor & Destructor Documentation

AlcPacket() [1/2]

LibFlute::AlcPacket::AlcPacket	(	char *	data,
		size_t	len
	)

Create an ALC packet from payload data.

Parameters

data	Received data to be parsed
len	Length of the buffer

Definition at line 22 of file AlcPacket.cpp.

{
  if (len < 4) {
    throw std::runtime_error("Packet too short");
  }
 
  std::memcpy(&_lct_header, data, 4);
  if (_lct_header.version != 1) {
    throw std::runtime_error("Unsupported LCT version");
  }
 
  char* hdr_ptr = data + 4;
  if (_lct_header.congestion_control_flag != 0) {
    throw std::runtime_error("Unsupported CCI field length");
  }
  // [TODO] read CCI
  hdr_ptr += 4;
 
  if (_lct_header.half_word_flag == 0 && _lct_header.tsi_flag == 0) {
    throw std::runtime_error("TSI field not present");
  }
  auto tsi_shift = 0;
  if(_lct_header.half_word_flag == 1) {
    _tsi = ntohs(*(uint16_t*)hdr_ptr);
    tsi_shift = 16;
    hdr_ptr += 2;
  } 
  if(_lct_header.tsi_flag == 1) {
    _tsi |= ntohl(*(uint32_t*)hdr_ptr) << tsi_shift;
    hdr_ptr += 4;
  } 
 
  if ( _lct_header.close_session_flag == 0 && _lct_header.half_word_flag == 0 && _lct_header.toi_flag == 0) {
    throw std::runtime_error("TOI field not present");
  }
  auto toi_shift = 0;
  if(_lct_header.half_word_flag == 1) {
    _toi = ntohs(*(uint16_t*)hdr_ptr);
    toi_shift = 16;
    hdr_ptr += 2;
  } 
  switch(_lct_header.toi_flag) {
      case 0: break;
      case 1: 
        _toi |= ntohl(*(uint32_t*)hdr_ptr) << toi_shift;
        hdr_ptr += 4;
        break;
      case 2:
        if (toi_shift > 0) {
          throw std::runtime_error("TOI fields over 64 bits in length are not supported");
        } else {
          _toi = ntohl(*(uint32_t*)hdr_ptr);
          hdr_ptr += 4;
          _toi |= (uint64_t)(ntohl(*(uint32_t*)hdr_ptr)) << 32;
          hdr_ptr += 4;
        }
        break;
      default:
        throw std::runtime_error("TOI fields over 64 bits in length are not supported");
  } 
 
  if (_lct_header.codepoint == 0) {
    _fec_oti.encoding_id = FecScheme::CompactNoCode;
  } else {
    throw std::runtime_error("Only Compact No-Code FEC is supported");
  }
 
  auto expected_header_len = 2 +
   _lct_header.congestion_control_flag +
   _lct_header.half_word_flag +
   _lct_header.tsi_flag +
   _lct_header.toi_flag;
 
  size_t ext_header_len = (_lct_header.lct_header_len - expected_header_len) * 4;
  while (ext_header_len > 0) {
    auto ext_ptr = hdr_ptr;
    uint8_t het = *ext_ptr;
    ext_ptr += 1; // Skip HET
    uint8_t hel = 0;
    size_t ext_len = 4;
    if (het <= 127) {
      hel = *ext_ptr;
      ext_len = hel * 4;
      ext_ptr += 1; // Skip HEL
    }
 
    if (ext_len > ext_header_len) {
      throw std::runtime_error("Header extension length exceeds remaining header length");
    }
 
    switch ((AlcPacket::HeaderExtension)het) {
      case EXT_NOP:
      case EXT_AUTH:
      case EXT_TIME:  {
                        break; // ignored
                      }
      case EXT_FTI: {
                      if (_fec_oti.encoding_id == FecScheme::CompactNoCode) {
                        if (hel != 4) {
                          throw std::runtime_error("Invalid length for EXT_FTI header extension");
                        }
                        _fec_oti.transfer_length = (uint64_t)(ntohs(*(uint16_t*)ext_ptr)) << 32;
                        ext_ptr += 2;
                        _fec_oti.transfer_length |= (uint64_t)(ntohl(*(uint32_t*)ext_ptr));
                        ext_ptr += 4;
                        ext_ptr += 2; // reserved
                        _fec_oti.encoding_symbol_length = ntohs(*(uint16_t*)ext_ptr);
                        ext_ptr += 2;
                        _fec_oti.max_source_block_length = ntohl(*(uint32_t*)ext_ptr);
                      }
                      break;
                    }
      case EXT_FDT: {
                      uint8_t flute_version = (*ext_ptr & 0xF0) >> 4;
                      if (flute_version > 2) {
                        throw std::runtime_error("Unsupported FLUTE version");
                      }
                      _fdt_instance_id =  (*ext_ptr & 0x0F) << 16;
                      ext_ptr++;
                      _fdt_instance_id |= ntohs(*(uint16_t*)ext_ptr);
                      break;
                    }
      case EXT_CENC: {
                       uint8_t encoding = *ext_ptr;
                       switch (encoding) {
                         case 0: _content_encoding = ContentEncoding::NONE; break;
                         case 1: _content_encoding = ContentEncoding::ZLIB; break;
                         case 2: _content_encoding = ContentEncoding::DEFLATE; break;
                         case 3: _content_encoding = ContentEncoding::GZIP; break;
                       }
                       break;
                     }
    }
 
    ext_header_len -= ext_len;
    hdr_ptr += ext_len;
  }
}

AlcPacket() [2/2]

LibFlute::AlcPacket::AlcPacket	(	uint16_t	tsi,
		uint16_t	toi,
		FecOti	fec_oti,
		const std::vector< EncodingSymbol > &	symbols,
		size_t	max_size,
		uint32_t	fdt_instance_id
	)

Create an ALC packet from encoding symbols.

Parameters

tsi	Transport Stream Identifier
toi	Transport Object Identifier
fec_oti	OTI values
symbols	Vector of encoding symbols
max_size	Maximum payload size
fdt_instance_id	FDT instance ID (only relevant for FDT with TOI=0)

~AlcPacket()

LibFlute::AlcPacket::~AlcPacket

(

)

Default destructor.

Definition at line 224 of file AlcPacket.cpp.

{
  if (_buffer) free(_buffer);
}

Member Function Documentation

content_encoding()

ContentEncoding LibFlute::AlcPacket::content_encoding ( ) const

inline

Get the content encoding.

Definition at line 87 of file AlcPacket.h.

{ return _content_encoding; };

data()

char* LibFlute::AlcPacket::data ( ) const

inline

Get a pointer to the payload data of the constructed packet.

Definition at line 92 of file AlcPacket.h.

{ return _buffer; };

fdt_instance_id()

uint32_t LibFlute::AlcPacket::fdt_instance_id ( ) const

inline

Get the FDT instance ID.

Definition at line 77 of file AlcPacket.h.

{ return _fdt_instance_id; };

fec_oti()

const FecOti& LibFlute::AlcPacket::fec_oti ( ) const

inline

Get the FEC OTI values.

Definition at line 67 of file AlcPacket.h.

{ return _fec_oti; };

fec_scheme()

FecScheme LibFlute::AlcPacket::fec_scheme ( ) const

inline

Get the FEC scheme.

Definition at line 82 of file AlcPacket.h.

{ return _fec_oti.encoding_id; };

header_length()

size_t LibFlute::AlcPacket::header_length ( ) const

inline

Get the LCT header length.

Definition at line 72 of file AlcPacket.h.

{ return _lct_header.lct_header_len * 4; };

size()

size_t LibFlute::AlcPacket::size ( ) const

inline

Get the payload size.

Definition at line 97 of file AlcPacket.h.

{ return _len; };

toi()

uint64_t LibFlute::AlcPacket::toi ( ) const

inline

Get the TOI.

Definition at line 62 of file AlcPacket.h.

{ return _toi; };

tsi()

uint64_t LibFlute::AlcPacket::tsi ( ) const

inline

Get the TSI.

Definition at line 57 of file AlcPacket.h.

{ return _tsi; };

---

The documentation for this class was generated from the following files:

• include/AlcPacket.h
• src/AlcPacket.cpp