819 lines
22 KiB
C++
819 lines
22 KiB
C++
/* SPDX-License-Identifier: MIT */
|
|
/**
|
|
@file ntv2tshelper.h
|
|
@brief Declares Transport Stream helper classes.
|
|
@copyright (C) 2008-2021 AJA Video Systems, Inc.
|
|
**/
|
|
|
|
#ifndef NTV2TSHELPER_H
|
|
#define NTV2TSHELPER_H
|
|
|
|
#include <stdint.h>
|
|
#include <map>
|
|
|
|
#define KIPDPRINT 0
|
|
|
|
#if defined(MSWindows)
|
|
|
|
#if (KIPDPRINT==0)
|
|
// no log
|
|
#define kipdprintf(...)
|
|
|
|
#elif (KIPDPRINT==1)
|
|
// printf
|
|
#include <stdio.h>
|
|
#define kipdprintf(...) printf(__VA_ARGS__)
|
|
|
|
#endif
|
|
|
|
#elif defined(AJALinux)
|
|
|
|
#if (KIPDPRINT==0)
|
|
// no log
|
|
#define kipdprintf(...)
|
|
|
|
#elif (KIPDPRINT==1)
|
|
// printf
|
|
#include <stdio.h>
|
|
#define kipdprintf(...) printf(__VA_ARGS__)
|
|
|
|
#endif
|
|
|
|
#elif defined(AJAMac)
|
|
|
|
#if (KIPDPRINT==0)
|
|
// no log
|
|
#define kipdprintf(_format_...)
|
|
|
|
#elif (KIPDPRINT==1)
|
|
// printf
|
|
#include <stdio.h>
|
|
#define kipdprintf(_format_...) printf(_format_)
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
typedef enum
|
|
{
|
|
kJ2KStreamTypeStandard,
|
|
kJ2KStreamTypeNonElsm
|
|
} J2KStreamType;
|
|
|
|
typedef enum
|
|
{
|
|
kJ2KChromaSubSamp_444,
|
|
kJ2KChromaSubSamp_422_444,
|
|
kJ2KChromaSubSamp_422_Standard
|
|
} J2KChromaSubSampling;
|
|
|
|
typedef enum
|
|
{
|
|
kJ2KCodeBlocksize_32x32,
|
|
kJ2KCodeBlocksize_32x64,
|
|
kJ2KCodeBlocksize_64x32 = 4,
|
|
kJ2KCodeBlocksize_64x64,
|
|
kJ2KCodeBlocksize_128x32 = 12
|
|
} J2KCodeBlocksize;
|
|
|
|
typedef enum
|
|
{
|
|
kTsEncapTypeJ2k,
|
|
kTsEncapTypePcr,
|
|
kTsEncapTypeAes
|
|
} TsEncapType;
|
|
|
|
typedef struct TsEncapStreamData
|
|
{
|
|
J2KStreamType j2kStreamType;
|
|
uint32_t width;
|
|
uint32_t height;
|
|
uint32_t denFrameRate;
|
|
uint32_t numFrameRate;
|
|
uint32_t numAudioChannels;
|
|
uint32_t programPid;
|
|
uint32_t videoPid;
|
|
uint32_t pcrPid;
|
|
uint32_t audio1Pid;
|
|
bool interlaced;
|
|
} TsEncapStreamData;
|
|
|
|
|
|
typedef struct TsVideoStreamData
|
|
{
|
|
J2KStreamType j2kStreamType;
|
|
uint32_t width;
|
|
uint32_t height;
|
|
uint32_t denFrameRate;
|
|
uint32_t numFrameRate;
|
|
uint32_t numAudioChannels;
|
|
bool interlaced;
|
|
} TsVideoStreamData;
|
|
|
|
class TSGenerator
|
|
{
|
|
public:
|
|
// Input
|
|
uint16_t _tsId;
|
|
uint8_t _version;
|
|
uint32_t _tableLength;
|
|
TsEncapType _tsEncapType;
|
|
|
|
// Generated packet
|
|
uint8_t _pkt8[188];
|
|
uint32_t _pkt32[188];
|
|
|
|
public:
|
|
TSGenerator()
|
|
{
|
|
init();
|
|
initPacket();
|
|
}
|
|
|
|
~TSGenerator()
|
|
{
|
|
}
|
|
|
|
void init()
|
|
{
|
|
_tsId = 1;
|
|
_version = 1;
|
|
_tableLength = 0;
|
|
_tsEncapType = kTsEncapTypeJ2k;
|
|
}
|
|
|
|
void initPacket()
|
|
{
|
|
for ( int i = 0; i < 188; i++ )
|
|
{
|
|
_pkt8[i] = 0xff;
|
|
_pkt32[i] = 0xffff;
|
|
}
|
|
}
|
|
|
|
uint32_t chksum_crc32(unsigned char *data, int len)
|
|
{
|
|
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
|
|
};
|
|
|
|
int32_t i;
|
|
uint32_t crc = 0xffffffff;
|
|
|
|
for (i=0; i<len; i++)
|
|
crc = (crc << 8) ^ crc_table[((crc >> 24) ^ *data++) & 0xff];
|
|
|
|
return crc;
|
|
}
|
|
|
|
void dump8()
|
|
{
|
|
for (uint32_t i=0; i<_tableLength; i++)
|
|
{
|
|
if (i % 16 == 15) {
|
|
kipdprintf("0x%02x\n", _pkt8[i]);
|
|
} else {
|
|
kipdprintf("0x%02x, ", _pkt8[i]);
|
|
}
|
|
}
|
|
kipdprintf("\n\n");
|
|
}
|
|
|
|
void dump32()
|
|
{
|
|
for (uint32_t i=0; i<_tableLength; i++)
|
|
{
|
|
if (i % 16 == 15) {
|
|
kipdprintf("0x%04x\n", _pkt32[i]);
|
|
} else {
|
|
kipdprintf("0x%04x ", _pkt32[i]);
|
|
}
|
|
}
|
|
kipdprintf("\n\n");
|
|
}
|
|
|
|
protected:
|
|
void put16( uint16_t val, int &pos )
|
|
{
|
|
_pkt8[pos++] = (uint8_t)(val>>8);
|
|
_pkt8[pos++] = (uint8_t)val;
|
|
}
|
|
|
|
void put32( uint32_t val, int &pos )
|
|
{
|
|
_pkt8[pos++] = (uint8_t)(val>>24);
|
|
_pkt8[pos++] = (uint8_t)(val>>16);
|
|
_pkt8[pos++] = (uint8_t)(val>>8);
|
|
_pkt8[pos++] = (uint8_t)val;
|
|
}
|
|
};
|
|
|
|
class PESGen : public TSGenerator
|
|
{
|
|
public:
|
|
TsVideoStreamData _videoStreamData;
|
|
std::map <uint16_t, uint16_t> _elemNumToPID;
|
|
uint64_t _pts; // these can be passed in and will be initialized to reaonsable values
|
|
int32_t _auf1;
|
|
int32_t _auf2;
|
|
uint32_t _bitRate;
|
|
int32_t _ptsOffset; // theses values are filled in by the generator
|
|
int32_t _j2kTsOffset;
|
|
int32_t _auf1Offset;
|
|
int32_t _auf2Offset;
|
|
int32_t _hh;
|
|
int32_t _mm;
|
|
int32_t _ss;
|
|
int32_t _ff;
|
|
|
|
|
|
public:
|
|
PESGen()
|
|
{
|
|
initLocal();
|
|
}
|
|
|
|
~PESGen()
|
|
{
|
|
}
|
|
|
|
void initLocal()
|
|
{
|
|
_elemNumToPID.clear();
|
|
_pts = 0;
|
|
_auf1 = 0;
|
|
_auf2 = 0;
|
|
_bitRate = 75000000;
|
|
_hh = 0;
|
|
_mm = 0;
|
|
_ss = 0;
|
|
_ff = 0;
|
|
}
|
|
|
|
int makePacket()
|
|
{
|
|
initPacket();
|
|
int pos = 0;
|
|
_ptsOffset = 0xff; // For non-elsm streams these are all 0xff
|
|
_j2kTsOffset = 0xff; // for standard streams they will be filled in accordingly
|
|
_auf1Offset = 0xff;
|
|
_auf2Offset = 0xff;
|
|
|
|
// Header
|
|
_pkt8[pos++] = 0x47; // sync byte
|
|
_pkt8[pos] = 1<<6; // payload unit start indicator
|
|
_pkt8[pos++] |= (uint8_t) ((_elemNumToPID[1] >> 8) & 0x1f); // PID for Video
|
|
_pkt8[pos++] = (uint8_t) (_elemNumToPID[1] & 0xff); // PID for Video
|
|
_pkt8[pos++] = 0x10; // Continuity Counter must increment when transmitted
|
|
|
|
// generate PES data for AES streams
|
|
if (_tsEncapType == kTsEncapTypeAes)
|
|
{
|
|
_pkt8[pos++] = 0; // packet_start_code_prefix
|
|
_pkt8[pos++] = 0;
|
|
_pkt8[pos++] = (uint8_t) (1 & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (0xbd);
|
|
|
|
_pkt8[pos++] = 0; // (packet_length >> 8) & 0xff
|
|
_pkt8[pos++] = 0; // packet_length & 0xff
|
|
_pkt8[pos++] = 0x80; // alignment
|
|
_pkt8[pos++] = 0x80; // 11
|
|
_pkt8[pos++] = 5; // 12
|
|
|
|
_ptsOffset = pos;
|
|
|
|
_pkt8[pos] = 0x21; // 13
|
|
_pkt8[pos++] |= (uint8_t) ((_pts >> 29) & 0xe);
|
|
_pkt8[pos] = 0x0; // 14
|
|
_pkt8[pos++] |= (uint8_t) ((_pts >> 22) & 0xff);
|
|
_pkt8[pos] = 0x1; // 15
|
|
_pkt8[pos++] |= (uint8_t) ((_pts >> 14) & 0xfe);
|
|
_pkt8[pos] = 0x0; // 16
|
|
_pkt8[pos++] |= (uint8_t) ((_pts >> 7) & 0xff);
|
|
_pkt8[pos] = 0x1; // 17
|
|
_pkt8[pos++] |= (uint8_t) ((_pts << 1) & 0xfe);
|
|
|
|
_pkt8[pos++] = 0x0; // 18
|
|
_pkt8[pos++] = 0x0;
|
|
|
|
// These two bytes are defined in Table 1 of ST302 spec starting with num channels
|
|
if (_videoStreamData.j2kStreamType == kJ2KStreamTypeStandard)
|
|
{
|
|
_pkt8[pos++] = 0x0; // 2 channels, 6 bits of channel ID
|
|
_pkt8[pos++] = 0x10; // two bits of channel ID, 20 bits per sample, alignment 0 reserved
|
|
}
|
|
else
|
|
{
|
|
_pkt8[pos++] = 0x0; // 2 channels, 6 bits of channel ID
|
|
_pkt8[pos++] = 0x20; // two bits of channel ID, 24 bits per sample, alignment 0 reserved
|
|
}
|
|
|
|
_auf1Offset = 0x1000012;
|
|
_auf2Offset = 0x1000c08;
|
|
|
|
}
|
|
else
|
|
{
|
|
// generate PES data for standard streams, for non-elsm just do the header
|
|
if (_videoStreamData.j2kStreamType == kJ2KStreamTypeStandard)
|
|
{
|
|
_pkt8[pos++] = 0; // packet_start_code_prefix
|
|
_pkt8[pos++] = 0;
|
|
_pkt8[pos++] = (uint8_t) (1 & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (0xbd);
|
|
|
|
_pkt8[pos++] = 0; // (packet_length >> 8) & 0xff
|
|
_pkt8[pos++] = 0; // packet_length & 0xff
|
|
_pkt8[pos++] = 0x84; // alignment
|
|
_pkt8[pos++] = 0x80; // 11
|
|
_pkt8[pos++] = 5; // 12
|
|
|
|
_ptsOffset = pos;
|
|
|
|
_pkt8[pos] = 0x21; // 13
|
|
_pkt8[pos++] |= (uint8_t) ((_pts >> 29) & 0xe);
|
|
_pkt8[pos] = 0x0; // 14
|
|
_pkt8[pos++] |= (uint8_t) ((_pts >> 22) & 0xff);
|
|
_pkt8[pos] = 0x1; // 15
|
|
_pkt8[pos++] |= (uint8_t) ((_pts >> 14) & 0xfe);
|
|
_pkt8[pos] = 0x0; // 16
|
|
_pkt8[pos++] |= (uint8_t) ((_pts >> 7) & 0xff);
|
|
_pkt8[pos] = 0x1; // 17
|
|
_pkt8[pos++] |= (uint8_t) ((_pts << 1) & 0xfe);
|
|
|
|
_pkt8[pos++] = 0x65; // "e"
|
|
_pkt8[pos++] = 0x6c; // "l"
|
|
_pkt8[pos++] = 0x73; // "s"
|
|
_pkt8[pos++] = 0x6D; // "m"
|
|
|
|
_pkt8[pos++] = 0x66; // "f"
|
|
_pkt8[pos++] = 0x72; // "r"
|
|
_pkt8[pos++] = 0x61; // "a"
|
|
_pkt8[pos++] = 0x74; // "t"
|
|
|
|
_pkt8[pos++] = (uint8_t) ((_videoStreamData.denFrameRate >> 8) & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (_videoStreamData.denFrameRate & 0xff);
|
|
_pkt8[pos++] = (uint8_t) ((_videoStreamData.numFrameRate >> 8) & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (_videoStreamData.numFrameRate & 0xff);
|
|
|
|
_pkt8[pos++] = 0x62; // "b"
|
|
_pkt8[pos++] = 0x72; // "r"
|
|
_pkt8[pos++] = 0x61; // "a"
|
|
_pkt8[pos++] = 0x74; // "t"
|
|
|
|
_pkt8[pos++] = (uint8_t) (_bitRate >> 24); // 34
|
|
_pkt8[pos++] = (uint8_t) ((_bitRate >> 16) & 0xff);
|
|
_pkt8[pos++] = (uint8_t) ((_bitRate >> 8) & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (_bitRate & 0xff);
|
|
|
|
_auf1Offset = pos;
|
|
|
|
_pkt8[pos++] = (uint8_t) (_auf1 >> 24); // 38
|
|
_pkt8[pos++] = (uint8_t) ((_auf1 >> 16) & 0xff);
|
|
_pkt8[pos++] = (uint8_t) ((_auf1 >> 8) & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (_auf1 & 0xff);
|
|
|
|
if (_videoStreamData.interlaced)
|
|
{
|
|
_auf2Offset = pos;
|
|
|
|
_pkt8[pos++] = (uint8_t) (_auf2 >> 24); // 42
|
|
_pkt8[pos++] = (uint8_t) ((_auf2 >> 16) & 0xff);
|
|
_pkt8[pos++] = (uint8_t) ((_auf2 >> 8) & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (_auf2 & 0xff);
|
|
|
|
_pkt8[pos++] = 0x66; // "f"
|
|
_pkt8[pos++] = 0x69; // "i"
|
|
_pkt8[pos++] = 0x65; // "e"
|
|
_pkt8[pos++] = 0x6c; // "l"
|
|
|
|
_pkt8[pos++] = (uint8_t) (2 & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (1 & 0xff);
|
|
|
|
_pkt8[pos++] = 0x74; // "t"
|
|
_pkt8[pos++] = 0x63; // "c"
|
|
_pkt8[pos++] = 0x6f; // "o"
|
|
_pkt8[pos++] = 0x64; // "d"
|
|
|
|
_j2kTsOffset = pos;
|
|
_pkt8[pos++] = (uint8_t) (_hh & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (_mm & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (_ss & 0xff);
|
|
_pkt8[pos++] = (uint8_t) (_ff & 0xff);
|
|
|
|
_pkt8[pos++] = 0x62; // "b"
|
|
_pkt8[pos++] = 0x63; // "c"
|
|
_pkt8[pos++] = 0x6f; // "o"
|
|
_pkt8[pos++] = 0x6c; // "l"
|
|
|
|
_pkt8[pos++] = 3;
|
|
_pkt8[pos++] = 0x0;
|
|
}
|
|
else
|
|
{
|
|
_pkt8[pos++] = 0x74; // "t"
|
|
_pkt8[pos++] = 0x63; // "c"
|
|
_pkt8[pos++] = 0x6f; // "o"
|
|
_pkt8[pos++] = 0x64; // "d"
|
|
|
|
_j2kTsOffset = pos;
|
|
_pkt8[pos++] = (uint8_t) (0 & 0xff); // hh
|
|
_pkt8[pos++] = (uint8_t) (0 & 0xff); // mm
|
|
_pkt8[pos++] = (uint8_t) (0 & 0xff); // ss
|
|
_pkt8[pos++] = (uint8_t) (0 & 0xff); // ff
|
|
|
|
_pkt8[pos++] = 0x62; // "b"
|
|
_pkt8[pos++] = 0x63; // "c"
|
|
_pkt8[pos++] = 0x6f; // "o"
|
|
_pkt8[pos++] = 0x6c; // "l"
|
|
|
|
_pkt8[pos++] = 3;
|
|
_pkt8[pos++] = 0xff;
|
|
}
|
|
}
|
|
}
|
|
|
|
_tableLength = pos;
|
|
return pos;
|
|
}
|
|
|
|
int32_t calcPatPmtPeriod()
|
|
{
|
|
double d1, d2;
|
|
|
|
// Next PAT / PMT Transmission Rate
|
|
d2 = 1.0 / 125000000; // Clock Period
|
|
d1 = 90e-3 / d2 - 1.0;
|
|
return (int32_t) d1;
|
|
}
|
|
};
|
|
|
|
class PATGen : public TSGenerator
|
|
{
|
|
public:
|
|
// Input
|
|
std::map <uint16_t, uint16_t> _progNumToPID;
|
|
|
|
public:
|
|
PATGen()
|
|
{
|
|
initLocal();
|
|
}
|
|
|
|
~PATGen()
|
|
{
|
|
}
|
|
|
|
void initLocal()
|
|
{
|
|
_progNumToPID.clear();
|
|
}
|
|
|
|
int makePacket()
|
|
{
|
|
initPacket();
|
|
int pos = 0;
|
|
|
|
// Header
|
|
_pkt8[pos++] = 0x47; // sync byte
|
|
_pkt8[pos++] = 1<<6; // payload unit start indicator
|
|
_pkt8[pos++] = 0; // PID for PAT = 0
|
|
_pkt8[pos++] = 0x10; // Continuity Counter must increment when transmitted
|
|
_pkt8[pos++] = 0; // pointer
|
|
|
|
int crcStart = pos;
|
|
|
|
_pkt8[pos++] = 0; // table id = 0
|
|
|
|
int length = 9 + (4 * (int)_progNumToPID.size());
|
|
put16( (uint16_t)0xb000 + (length & 0x3ff), pos); // syntax indicator, reserved, length
|
|
put16( _tsId, pos );
|
|
|
|
_pkt8[pos++] = 0xc1 + ((_version & 0x1f)<< 1); // version, current/next
|
|
put16( 0, pos ); // section number = last section number = 0
|
|
|
|
std::map <uint16_t, uint16_t>::const_iterator it = _progNumToPID.begin();
|
|
while (it != _progNumToPID.end())
|
|
{
|
|
put16( it->first, pos );
|
|
put16( (uint16_t)0xe000 + (it->second & 0x1fff), pos );
|
|
it++;
|
|
}
|
|
int crcEnd = pos - 1;
|
|
|
|
int crc = chksum_crc32(_pkt8 + crcStart, crcEnd - crcStart + 1 );
|
|
put32( crc, pos );
|
|
|
|
_tableLength = pos;
|
|
return pos;
|
|
}
|
|
};
|
|
|
|
class PMTGen : public TSGenerator
|
|
{
|
|
public:
|
|
TsVideoStreamData _videoStreamData;
|
|
std::map <uint16_t, uint16_t> _progNumToPID;
|
|
std::map <uint16_t, uint16_t> _pcrNumToPID;
|
|
std::map <uint16_t, uint16_t> _videoNumToPID;
|
|
std::map <uint16_t, uint16_t> _audioNumToPID;
|
|
|
|
public:
|
|
PMTGen()
|
|
{
|
|
initLocal();
|
|
}
|
|
|
|
~PMTGen()
|
|
{
|
|
}
|
|
|
|
void initLocal()
|
|
{
|
|
_progNumToPID.clear();
|
|
_pcrNumToPID.clear();
|
|
_videoNumToPID.clear();
|
|
_audioNumToPID.clear();
|
|
}
|
|
|
|
int makePacket()
|
|
{
|
|
initPacket();
|
|
int pos = 0;
|
|
int len, lengthPos, j2kLengthPos, audioLengthPos;
|
|
|
|
// Header
|
|
_pkt8[pos++] = 0x47; // sync byte
|
|
_pkt8[pos] = 1<<6; // payload unit start indicator
|
|
_pkt8[pos++] |= (uint8_t) ((_progNumToPID[1] >> 8) & 0x1f); // PID for PMT
|
|
_pkt8[pos++] = (uint8_t) (_progNumToPID[1] & 0xff); // PID for PMT
|
|
_pkt8[pos++] = 0x10; // Continuity Counter must increment when transmitted
|
|
_pkt8[pos++] = 0; // pointer
|
|
|
|
int crcStart = pos;
|
|
|
|
_pkt8[pos++] = 2; // table id = 0
|
|
lengthPos = pos; // need to come back and fill in length so save position (assume < 256)
|
|
_pkt8[pos++] = 0xb0;
|
|
pos++;
|
|
|
|
put16(0x01, pos); // program number
|
|
|
|
_pkt8[pos++] = 0xc1 + ((_version & 0x1f)<< 1); // version, current/next
|
|
put16( 0, pos ); // section number = last section number = 0
|
|
|
|
_pkt8[pos] = 0xe0; // PCR pid and reserved bits
|
|
_pkt8[pos++] |= (uint8_t) ((_pcrNumToPID[1] >> 8) & 0x1f);
|
|
_pkt8[pos++] = (uint8_t) (_pcrNumToPID[1] & 0xff);
|
|
|
|
_pkt8[pos++] = 0xf0; // reserved bits and program info length
|
|
_pkt8[pos++] = 0x00; // reserved bits and program info length
|
|
|
|
// Do the streams
|
|
|
|
if (_videoNumToPID[1] != 0)
|
|
{
|
|
// J2K
|
|
_pkt8[pos++] = 0x21; // J2K Type
|
|
_pkt8[pos] = 0xe0; // elementary pid and reserved bits
|
|
_pkt8[pos++] |= (uint8_t) ((_videoNumToPID[1] >> 8) & 0x1f);
|
|
_pkt8[pos++] = (uint8_t) (_videoNumToPID[1] & 0xff);
|
|
|
|
j2kLengthPos = pos; // need to come back and fill in descriptor length so save position
|
|
pos+=2;
|
|
|
|
len = makeJ2kDescriptor(pos); // generate the J2K descriptor
|
|
|
|
_pkt8[j2kLengthPos] = 0xf0; // fill in the length and reserved bits now
|
|
_pkt8[j2kLengthPos++] |= (uint8_t) ((len >> 8) & 0x1f);
|
|
_pkt8[j2kLengthPos] = (uint8_t) (len & 0xff);
|
|
}
|
|
|
|
if ((_audioNumToPID[1] != 0) && (_videoStreamData.numAudioChannels != 0))
|
|
{
|
|
// Audio
|
|
_pkt8[pos++] = 0x06; // Audio Type
|
|
_pkt8[pos] = 0xe0; // audio pid and reserved bits
|
|
_pkt8[pos++] |= (uint8_t) ((_audioNumToPID[1] >> 8) & 0x1f);
|
|
_pkt8[pos++] = (uint8_t) (_audioNumToPID[1] & 0xff);
|
|
|
|
audioLengthPos = pos; // need to come back and fill in descriptor length so save position
|
|
pos+=2;
|
|
|
|
len = makeAudioDescriptor(pos); // generate the audio descriptor
|
|
|
|
_pkt8[audioLengthPos] = 0xf0; // fill in the length and reserved bits now
|
|
_pkt8[audioLengthPos++] |= (uint8_t) ((len >> 8) & 0x1f);
|
|
_pkt8[audioLengthPos] = (uint8_t) (len & 0xff);
|
|
}
|
|
|
|
// now we know the length so fill that in
|
|
_pkt8[lengthPos] = 0xb0;
|
|
_pkt8[lengthPos++] |= (uint8_t) (((pos-crcStart+1) >> 8) & 0x1f);
|
|
_pkt8[lengthPos] = (uint8_t) ((pos-crcStart+1) & 0xff);
|
|
|
|
int crcEnd = pos - 1;
|
|
|
|
int crc = chksum_crc32(_pkt8 + crcStart, crcEnd - crcStart + 1 );
|
|
put32( crc, pos );
|
|
|
|
_tableLength = pos;
|
|
return pos;
|
|
}
|
|
|
|
int makeJ2kDescriptor(int &pos)
|
|
{
|
|
int startPos = pos;
|
|
uint32_t profileLevel;
|
|
uint32_t maxBitRate;
|
|
uint32_t height;
|
|
|
|
if (_videoStreamData.j2kStreamType == kJ2KStreamTypeStandard)
|
|
{
|
|
profileLevel = 0x102;
|
|
maxBitRate = 160000000;
|
|
}
|
|
else
|
|
{
|
|
profileLevel = 0x101;
|
|
maxBitRate = 213000000;
|
|
}
|
|
|
|
if (_videoStreamData.interlaced) height = _videoStreamData.height/2;
|
|
else height = _videoStreamData.height;
|
|
|
|
// Header
|
|
_pkt8[pos++] = 0x32; // descriptor tag
|
|
_pkt8[pos++] = 24; // descriptor length
|
|
put16( profileLevel, pos ); // profile level
|
|
|
|
if (_videoStreamData.j2kStreamType == kJ2KStreamTypeStandard)
|
|
{
|
|
// Standard stream
|
|
put32( _videoStreamData.width, pos ); // width
|
|
put32( height, pos ); // height
|
|
put32( maxBitRate, pos ); // max bit rate
|
|
put32( 1250000, pos ); // max buffer size (constant for now)
|
|
put16( _videoStreamData.denFrameRate, pos ); // frame rate
|
|
put16( _videoStreamData.numFrameRate, pos );
|
|
_pkt8[pos++] = 3; // color spec
|
|
_pkt8[pos] = _videoStreamData.interlaced <<6; // interlaced and still mode
|
|
_pkt8[pos++] |= 0x3F; // reserved bits all 1's for standard streams
|
|
}
|
|
else
|
|
{
|
|
// Non-elsm stream
|
|
put16( 0x0100, pos );
|
|
put16( _videoStreamData.width, pos ); // width
|
|
put16( height, pos ); // height
|
|
if (_videoStreamData.interlaced)
|
|
put16( height, pos ); // height again for interlaced
|
|
else
|
|
put16( 0, pos ); // otherwise nothing
|
|
put32( maxBitRate, pos ); // max bit rate (constant for now)
|
|
_pkt8[pos++] = 0;
|
|
_pkt8[pos++] = 0;
|
|
_pkt8[pos++] = 0x05;
|
|
_pkt8[pos++] = 0x33;
|
|
put16( _videoStreamData.denFrameRate, pos ); // frame rate
|
|
put16( _videoStreamData.numFrameRate, pos );
|
|
_pkt8[pos++] = 0;
|
|
_pkt8[pos++] = 0;
|
|
}
|
|
|
|
return pos-startPos;
|
|
}
|
|
|
|
int makeAudioDescriptor(int &pos)
|
|
{
|
|
int startPos = pos;
|
|
// Header
|
|
_pkt8[pos++] = 0x0a; // descriptor tag
|
|
_pkt8[pos++] = 4; // descriptor length
|
|
_pkt8[pos++] = 0x45; // "E"
|
|
_pkt8[pos++] = 0x4e; // "N"
|
|
_pkt8[pos++] = 0x47; // "G"
|
|
_pkt8[pos++] = 0;
|
|
|
|
_pkt8[pos++] = 0x05; // descriptor tag
|
|
if (_videoStreamData.j2kStreamType == kJ2KStreamTypeNonElsm)
|
|
_pkt8[pos++] = 6; // length non-elsm
|
|
else
|
|
_pkt8[pos++] = 4; // length standard stream (omitted ST302 channel spec)
|
|
|
|
_pkt8[pos++] = 0x42; // "B"
|
|
_pkt8[pos++] = 0x53; // "S"
|
|
_pkt8[pos++] = 0x53; // "S"
|
|
_pkt8[pos++] = 0x44; // "D"
|
|
|
|
// These two bytes are defined in Table 1 of ST302 spec starting with num channels, we dont add these for standard streams
|
|
if (_videoStreamData.j2kStreamType == kJ2KStreamTypeNonElsm)
|
|
{
|
|
_pkt8[pos++] = (_videoStreamData.numAudioChannels/2) - 1; // number of audio pairs (0 is 1 pair of audio), 6 bits of channel ID
|
|
_pkt8[pos++] = 0x20; // two bits of channel ID, 24 bits per sample, alignment 0 reserved
|
|
}
|
|
|
|
return pos-startPos;
|
|
}
|
|
};
|
|
|
|
class ADPGen : public TSGenerator
|
|
{
|
|
public:
|
|
std::map <uint16_t, uint16_t> _elemNumToPID;
|
|
|
|
public:
|
|
ADPGen()
|
|
{
|
|
initLocal();
|
|
}
|
|
|
|
~ADPGen()
|
|
{
|
|
}
|
|
|
|
void initLocal()
|
|
{
|
|
_elemNumToPID.clear();
|
|
}
|
|
|
|
int makePacket()
|
|
{
|
|
initPacket();
|
|
int pos = 0;
|
|
|
|
// Header
|
|
_pkt32[pos++] = 0x47; // sync byte
|
|
_pkt32[pos++] = ((_elemNumToPID[1] >> 8) & 0x1f); // PID for stream
|
|
_pkt32[pos++] = (_elemNumToPID[1] & 0xff);
|
|
|
|
if (_tsEncapType == kTsEncapTypePcr)
|
|
{
|
|
_pkt32[pos++] = (2 << 4); // Continuity Counter must increment when transmitted
|
|
_pkt32[pos++] = 0; // pointer
|
|
_pkt32[pos++] = 0x10; // pointer
|
|
|
|
_pkt32[pos++] = 0x800; // PCR
|
|
_pkt32[pos++] = 0x900;
|
|
_pkt32[pos++] = 0xa00;
|
|
_pkt32[pos++] = 0xb00;
|
|
_pkt32[pos++] = 0xc00;
|
|
_pkt32[pos++] = 0xd00;
|
|
}
|
|
else
|
|
{
|
|
_pkt32[pos++] = (3 << 4); // Continuity Counter must increment when transmitted
|
|
_pkt32[pos++] = 0; // pointer
|
|
_pkt32[pos++] = 0; // pointer
|
|
}
|
|
|
|
_tableLength = pos;
|
|
return pos;
|
|
}
|
|
};
|
|
|
|
#endif
|