MPEG_TS_encode.cpp

#include "MPEG_TS_encode.h"
 
#include "Foundation/Logging/Logger.h"
 
// See
// https://en.wikipedia.org/wiki/Program-specific_information
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("MPEG_TS_encode");
}// namespace ...
 
namespace Cogs::Core{
 
static constexpr uint32_t SYNC_BYTE = 0x47;
 
static constexpr uint32_t TS_PACKET_LENGTH = 188;
static constexpr uint32_t TS_HEADER_LENGTH = 4;
 
// CRC32 lookup table for polynomial 0x04c11db7
static uint32_t crc_table[256] = {
  0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
  0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
  0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
  0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
  0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
  0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
  0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
  0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
  0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
  0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
  0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
  0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
  0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
  0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
  0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
  0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
  0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
  0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
  0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
  0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
  0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
  0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
  0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
  0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
  0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
  0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
  0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
  0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
  0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
  0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
  0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
  0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};
 
static uint32_t calc_crc32(uint8_t *data, uint32_t len)
{
  uint32_t crc = 0xffffffff;
  for(uint32_t i=0; i<len; i++)
    crc = (crc<<8) ^ crc_table[((crc>>24) ^ *data++) & 0xff];
  return crc;
}
 
void write_b(uint32_t val, uint8_t *data, size_t &bit)
{
  if(val){
    size_t byte = bit>>0x3; //size_t byte = bit/8;
    size_t n = bit&0x7; // size_t n = bit%8;
    data[byte] = data[byte] | 1<<(7-n);
  }
  bit++;
}
void write_u(uint32_t val, uint8_t *data, size_t &bit, size_t n)
{
  for(uint32_t i=0; i<n; i++){
    write_b((val>>(n-1-i))&1, data, bit);
  }
}
 
void MPEGTransportStreamEncoder::SendNullPacket()
{
  uint8_t packet[TS_PACKET_LENGTH] = {};
  packet[0] = SYNC_BYTE;
 
  uint8_t *data = packet;
  size_t bit = 8; // Start after sync byte
 
  // Write header
  write_b(0, data, bit); // transport_error_indicator
  write_b(0, data, bit); // payload_unit_start_indicator
  write_b(0, data, bit); // transport_priority
  write_u(0x1FFF, data, bit, 13); // PID
  write_u(0, data, bit, 2); // transport_scrambling_control
  write_u(0x1, data, bit, 2); // adaptation_field_control
  write_u(0, data, bit, 4); // continuity_counter
 
  WriteBuffer(packet, sizeof(packet));
}
void MPEGTransportStreamEncoder::SendProgramAssociationTable()
{
  uint8_t packet[TS_PACKET_LENGTH] = {};
  packet[0] = SYNC_BYTE;
 
  uint8_t *data = packet;
  size_t bit = 8; // Start after sync byte
 
  // Write header
  write_b(0, data, bit); // transport_error_indicator
  bool start_indicator = true;
  write_b(start_indicator ? 1 : 0, data, bit); // payload_unit_start_indicator
  write_b(1, data, bit); // transport_priority
  write_u(0x0000, data, bit, 13); // PID
  write_u(0, data, bit, 2); // transport_scrambling_control
  write_u(0x1, data, bit, 2); // adaptation_field_control
  write_u(0, data, bit, 4); // continuity_counter
 
  // Pointer field
  if(start_indicator){
    write_u((188-16-1-4), data, bit, 8); // Pointer field
  }
 
  // Filler bytes (Indicated by Pointer field)
  while(bit < (188-16)*8){
    write_u(0xfe, data, bit, 8);
  }
 
  uint32_t N = 1;
 
  // Write Program Association Table
  write_u(0, data, bit, 8); // Table ID
  write_b(1, data, bit); // section_syntax_indicator
  write_b(0, data, bit); // Zero
  write_u(0x3, data, bit, 2); // Reserved
  uint32_t bytes = 5 + N*4 + 4; // Header (After section_length) + N * entries + CRC
  write_u(bytes, data, bit, 12); // section_length
  write_u(1, data, bit, 16); // transport_stream
  write_u(0x3, data, bit, 2); // Reserved
  write_u(0, data, bit, 5); // Version Number
  write_b(1, data, bit); // current_next_indicator
  write_u(0, data, bit, 8); // section_number
  write_u(0, data, bit, 8); // last_section_number
 
  for(uint32_t i=0; i<N; i++){
    write_u(1, data, bit, 16); // program_number
    write_u(0x7, data, bit, 3); // reserved
    write_u(0x1000, data, bit, 13); // PID
  }
  uint32_t crc_bytes = 8+4*N;
  uint32_t crc = calc_crc32(&packet[bit/8-crc_bytes], crc_bytes);
  write_u(crc, data, bit, 32); // CRC32
 
  WriteBuffer(packet, sizeof(packet));
 
  // OBS
  // MPEGTransportStreamHeader
  // transport_error_indicator 0
  // payload_unit_start_indicator 1
  // transport_priority 0
  // PID 0x0000
  // transport_scrambling_control 0
  // adaptation_field_control 1
  // continuity_counter 0
 
  // MPEGProgramAssociationSection
  // table_id 0
  // section_syntax_indicator 1
  // section_length 13
  // transport_stream_id 1
  // version_number 0
  // current_next_indicator 1
  // section_number 0
  // last_section_number 0
  // program_number[0] 1
  // PID[0] 0x1000
  // CRC32 716244146
}
void MPEGTransportStreamEncoder::SendProgramMapTable(Codec codec)
{
  uint8_t packet[TS_PACKET_LENGTH] = {};
  packet[0] = SYNC_BYTE;
 
  uint8_t *data = packet;
  size_t bit = 8; // Start after sync byte
 
  // Write header
  write_b(0, data, bit); // transport_error_indicator
  write_b(1, data, bit); // payload_unit_start_indicator
  write_b(1, data, bit); // transport_priority
  write_u(0x1000, data, bit, 13); // PID
  write_u(0, data, bit, 2); // transport_scrambling_control
  write_u(0x1, data, bit, 2); // adaptation_field_control
  write_u(0, data, bit, 4); // continuity_counter
 
  // Pointer field
  write_u(0, data, bit, 8); // Pointer field
 
  uint32_t N1 = 1;
 
  // Write Program Map Table
  write_u(2, data, bit, 8); // table_id
  write_b(1, data, bit); // section_syntax_indicator
  write_b(0, data, bit); // 0
  write_u(0x3, data, bit, 2); // reserved
  write_u(9+N1*5+4, data, bit, 12); // section_length
 
  write_u(1, data, bit, 16); // program_number
  write_u(0x3, data, bit, 2); // reserved
  write_u(0, data, bit, 5); // version_number
  write_b(1, data, bit); // current_next_indicator
  write_u(0x00, data, bit, 8); // section_number
  write_u(0x00, data, bit, 8); // last_section_number
 
  write_u(0x7, data, bit, 3); // reserved
  write_u(0x100, data, bit, 13); // PCR_PID
  write_u(0xf, data, bit, 4); // reserved
  write_u(0, data, bit, 12); // program_info_length
  // for(uint32_t i=0; i<N; i++){
  //   write_descriptor();
  // }
  for(uint32_t i=0; i<N1; i++){
    uint32_t stream_type = 0;
    if(codec == Codec::H264) stream_type = 0x1B;
    else if(codec == Codec::HEVC) stream_type = 0x24;
    else assert(false);
    write_u(stream_type, data, bit, 8); // stream_type
    write_u(0x7, data, bit, 3); // reserved
    write_u(0x100, data, bit, 13); // elementary_PID
    write_u(0xf, data, bit, 4); // reserved
    write_u(0, data, bit, 12); // ES_info_length
    // for(uint32_t j=0; j<N2; j++){
    //   write_descriptor();
    // }
  }
  uint32_t crc = calc_crc32(&packet[5], 12+N1*5);
  write_u(crc, data, bit, 32); // CRC32
 
  WriteBuffer(packet, sizeof(packet));
 
  // OBS
  // MPEGTransportStreamHeader
  // transport_error_indicator 0
  // payload_unit_start_indicator 1
  // transport_priority 0
  // PID 0x1000
  // transport_scrambling_control 0
  // adaptation_field_control 1
  // continuity_counter 0
 
  // MPEGProgramMapTable
  // table_id 2
  // section_syntax_indicator 1
  // section_length 23
  // program_number 1
  // version_number 0
  // current_next_indicator 1
  // section_number 0
  // last_section_number 7
  // PCR_PID 0x100
  // program_info_length 0
  // stream_type 27
  // elementary_PID 0x100
  // ES_info_length 0x0
  // stream_type 15
  // elementary_PID 0x101
  // ES_info_length 0x0
  // CRC32 793033115
}
void MPEGTransportStreamEncoder::SendPES(const uint8_t* dat, size_t size, size_t &written, uint64_t timestamp, bool use_timestamp, bool is_idr)
{
  uint8_t packet[TS_PACKET_LENGTH] = {};
  packet[0] = SYNC_BYTE;
 
  uint8_t *data = packet;
  size_t bit = 8; // Start after sync byte
 
  uint32_t filler_bytes = 0;
  if(size < TS_PACKET_LENGTH-TS_HEADER_LENGTH-9){
    filler_bytes = (TS_PACKET_LENGTH-TS_HEADER_LENGTH-9)-(uint32_t)size;
  }
 
  // Write header
  write_b(0, data, bit); // transport_error_indicator
  write_b(1, data, bit); // payload_unit_start_indicator
  write_b(is_idr ? 1 :0, data, bit); // transport_priority
  write_u(0x0100, data, bit, 13); // PID
  write_u(0, data, bit, 2); // transport_scrambling_control
  uint32_t adaptation_field_control = 0x1;
  if(filler_bytes)
    adaptation_field_control |= 0x2;
  write_u(adaptation_field_control, data, bit, 2); // adaptation_field_control
  write_u(continuity_counter, data, bit, 4); // continuity_counter
  continuity_counter = (continuity_counter+1)%16;
 
  // Adaptation Field
  if(filler_bytes){
    uint32_t adaptation_field_length = filler_bytes-1;
    write_u(adaptation_field_length, data, bit, 8); // adaptation_field_length 8 uimsbf
    if(adaptation_field_length){
      uint32_t N = adaptation_field_length-1;
      write_b(0, data, bit); // discontinuity_indicator 1 bslbf
      write_b(0, data, bit); // random_access_indicator 1 bslbf
      write_b(is_idr ? 1 :0, data, bit); // elementary_stream_priority_indicator 1 bslbf
      write_b(0, data, bit); // PCR_flag 1 bslbf
      write_b(0, data, bit); // OPCR_flag 1 bslbf
      write_b(0, data, bit); // splicing_point_flag 1 bslbf
      write_b(0, data, bit); // transport_private_data_flag 1 bslbf
      write_b(0, data, bit); // adaptation_field_extension_flag 1 bslbf
 
      for(uint32_t i=0; i<N; i++){
        write_u(0xff, data, bit, 8); // stuffing byte
      }
    }
  }
 
  // Data Bytes
  write_u(0, data, bit, 8); // packet_start_code_prefix
  write_u(0, data, bit, 8); // packet_start_code_prefix
  write_u(1, data, bit, 8); // packet_start_code_prefix
 
  uint32_t video_stream_number = 0;
  constexpr uint32_t video_stream_mask = 0xe0;
  uint32_t stream_id = video_stream_mask | video_stream_number;
  write_u(stream_id, data, bit, 8); // stream_id
 
  uint32_t packet_length = 0;
  // A value of 0 indicates that the PES packet length is neither specified nor bounded and is allowed
  // only in PES packets whose payload consists of bytes from a video elementary stream contained in
  // transport stream packets
  write_u(packet_length, data, bit, 16); // PES_packet_length
 
  {
    write_u(0x2, data, bit, 2); // magic
    write_u(0x0, data, bit, 2); // PES_scrambling_control 2 bslbf
    write_b(0, data, bit); // PES_priority 1 bslbf
    write_b(0, data, bit); // data_alignment_indicator 1 bslbf
    write_b(0, data, bit); // copyright 1 bslbf
    write_b(0, data, bit); // original_or_copy 1 bslbf
    uint32_t PTS_DTS_flags = 0;
    if(use_timestamp) PTS_DTS_flags |= 0x2; // Use PTS
    if(false) PTS_DTS_flags |= 0x3; // Use DTS
    write_u(PTS_DTS_flags, data, bit, 2); // PTS_DTS_flags 2 bslbf
    write_b(0, data, bit); // ESCR_flag 1 bslbf
    write_b(0, data, bit); // ES_rate_flag 1 bslbf
    write_b(0, data, bit); // DSM_trick_mode_flag 1 bslbf
    write_b(0, data, bit); // additional_copy_info_flag 1 bslbf
    write_b(0, data, bit); // PES_CRC_flag 1 bslbf
    write_b(0, data, bit); // PES_extension_flag 1 bslbf
 
    // Calculate header data
    uint32_t header_data_length = 0;
    if(PTS_DTS_flags == 0x2){
      header_data_length += 5;
    }
    else if(PTS_DTS_flags == 0x3){
      header_data_length += 10;
    }
    uint32_t N1 = 0;
    header_data_length += N1;
    write_u(header_data_length, data, bit, 8); // PES_header_data_length 8 uimsbf
 
    if(PTS_DTS_flags == 0x2){
      uint64_t PTS = (timestamp*90000)/1000000;
      uint64_t PTS_32_30 = (PTS>>30)&0x7;
      uint64_t PTS_29_15 = (PTS>>15)&0x7fff;
      uint64_t PTS_14_0 = (PTS>>0)&0x7fff;
      write_u(0x2, data, bit, 4); // magic
      write_u((uint32_t)PTS_32_30, data, bit, 3); // 3 bslbf
      write_b(1, data, bit); // marker bit
      write_u((uint32_t)PTS_29_15, data, bit, 15); // 15 bslbf
      write_b(1, data, bit); // marker bit
      write_u((uint32_t)PTS_14_0, data, bit, 15); // 15 bslbf
      write_b(1, data, bit); // marker bit
    }
    else if(PTS_DTS_flags == 0x3){
      uint64_t PTS = (timestamp*90000)/1000000;
      uint64_t PTS_32_30 = (PTS>>30)&0x7;
      uint64_t PTS_29_15 = (PTS>>15)&0x7fff;
      uint64_t PTS_14_0 = (PTS>>0)&0x7fff;
      write_u(0x3, data, bit, 4); // magic
      write_u((uint32_t)PTS_32_30, data, bit, 3); // 3 bslbf
      write_b(1, data, bit); // marker bit
      write_u((uint32_t)PTS_29_15, data, bit, 15); // 15 bslbf
      write_b(1, data, bit); // marker bit
      write_u((uint32_t)PTS_14_0, data, bit, 15); // 15 bslbf
      write_b(1, data, bit); // marker bit
      uint64_t DTS = (timestamp*90000)/1000000; // TODO Handle B frames???
      uint64_t DTS_32_30 = (DTS>>30)&0x7;
      uint64_t DTS_29_15 = (DTS>>15)&0x7fff;
      uint64_t DTS_14_0 = (DTS>>0)&0x7fff;
      write_u(0x1, data, bit, 4); // magic
      write_u((uint32_t)DTS_32_30, data, bit, 3); // 3 bslbf
      write_b(1, data, bit); // marker bit
      write_u((uint32_t)DTS_29_15, data, bit, 15); // 15 bslbf
      write_b(1, data, bit); // marker bit
      write_u((uint32_t)DTS_14_0, data, bit, 15); // 15 bslbf
      write_b(1, data, bit); // marker bit
    }
 
    assert(N1 <= 32);
    for(uint32_t i=0; i<N1; i++){
      write_u(0xff, data, bit, 8); // stuffing byte
    }
 
    size_t bytes = (TS_PACKET_LENGTH-TS_HEADER_LENGTH-9-header_data_length)-filler_bytes;
    assert(size >= bytes);
    memcpy(&packet[bit/8], dat, bytes);
    written += bytes;
  }
 
  WriteBuffer(packet, sizeof(packet));
}
void MPEGTransportStreamEncoder::Write(const void* buffer, size_t size, uint64_t timestamp, bool is_idr)
{
  const uint8_t*  dat = static_cast<const uint8_t*>(buffer);
  size_t          written = 0;
 
  while(written < size){
    if(written == 0){
      SendPES(dat, size, written, timestamp, true, is_idr);
    }
    else{
      uint8_t packet[TS_PACKET_LENGTH] = {};
      packet[0] = SYNC_BYTE;
 
      uint8_t *data = packet;
      size_t bit = 8; // Start after sync byte
 
      // Filler byttes
      uint32_t filler_bytes = 0;
      size_t rest = size-written;
      if(rest < TS_PACKET_LENGTH-TS_HEADER_LENGTH){
        filler_bytes = (TS_PACKET_LENGTH-TS_HEADER_LENGTH)-(uint32_t)rest;
      }
 
      // Write header
      write_b(0, data, bit); // transport_error_indicator
      write_b(0, data, bit); // payload_unit_start_indicator
      write_b(is_idr ? 1 :0, data, bit); // transport_priority
      write_u(0x0100, data, bit, 13); // PID
      write_u(0, data, bit, 2); // transport_scrambling_control
      uint32_t adaptation_field_control = 0x1;
      if(filler_bytes) adaptation_field_control |= 0x2;
      write_u(adaptation_field_control, data, bit, 2); // adaptation_field_control
      write_u(continuity_counter, data, bit, 4); // continuity_counter
      continuity_counter = (continuity_counter+1)%16;
 
      // Adaptation Field
      if(filler_bytes){
        uint32_t adaptation_field_length = filler_bytes-1;
        write_u(adaptation_field_length, data, bit, 8); // adaptation_field_length 8 uimsbf
        if(adaptation_field_length){
          uint32_t N = adaptation_field_length-1;
          write_b(0, data, bit); // discontinuity_indicator 1 bslbf
          write_b(0, data, bit); // random_access_indicator 1 bslbf
          write_b(is_idr ? 1 :0, data, bit); // elementary_stream_priority_indicator 1 bslbf
          write_b(0, data, bit); // PCR_flag 1 bslbf
          write_b(0, data, bit); // OPCR_flag 1 bslbf
          write_b(0, data, bit); // splicing_point_flag 1 bslbf
          write_b(0, data, bit); // transport_private_data_flag 1 bslbf
          write_b(0, data, bit); // adaptation_field_extension_flag 1 bslbf
          for(uint32_t i=0; i<N; i++){
            write_u(0xff, data, bit, 8); // stuffing byte
          }
        }
      }
 
      // Data Bytes
      size_t bytes = (TS_PACKET_LENGTH-TS_HEADER_LENGTH)-filler_bytes;
      assert(rest >= (TS_PACKET_LENGTH-TS_HEADER_LENGTH) || rest == bytes);
      memcpy(&packet[bit/8], &dat[written], bytes);
      written += bytes;
 
      WriteBuffer(packet, sizeof(packet));
    }
  }
  FlushBuffer();
}
void MPEGTransportStreamEncoder::WriteBuffer(uint8_t *data, uint32_t size)
{
  if(used+size > buffer_size){
    FlushBuffer();
  }
  assert(size <= buffer_size);
  assert(used+size <= buffer_size);
  memcpy(&buffer[used], data, size);
  used += size;
  if(used == buffer_size){
    FlushBuffer();
  }
}
void MPEGTransportStreamEncoder::FlushBuffer()
{
  callback(buffer, used);
  used = 0;
}
 
}// namespace ...