#include <stdio.h> 
#include <stdint.h> 
#include <stdlib.h> 
#include <string.h>   

#define MAX_BUFFER 102400 
#define PKT_SIZE 188   /* pids */ 
#define PAT_PID                 0x0000 
#define CAT_PID                 0x0001 
#define TSDT_PID                0x0002 
#define NIT_PID                 0x0010 
#define SDT_PID                 0x0011   
#define STREAM_TYPE_VIDEO_MPEG1     0x01 
#define STREAM_TYPE_VIDEO_MPEG2     0x02 
#define STREAM_TYPE_AUDIO_MPEG1     0x03 
#define STREAM_TYPE_AUDIO_MPEG2     0x04 
#define STREAM_TYPE_PRIVATE_SECTION 0x05 
#define STREAM_TYPE_PRIVATE_DATA    0x06 
#define STREAM_TYPE_AUDIO_AAC       0x0f 
#define STREAM_TYPE_AUDIO_AAC_LATM  0x11 
#define STREAM_TYPE_VIDEO_MPEG4     0x10 
#define STREAM_TYPE_VIDEO_H264      0x1b 
#define STREAM_TYPE_VIDEO_VC1       0xea 
#define STREAM_TYPE_VIDEO_DIRAC     0xd1   
#define STREAM_TYPE_AUDIO_AC3       0x81 
#define STREAM_TYPE_AUDIO_DTS       0x8a   
# define get_bit(val,bit) ((val & (1 << (bit))) >> (bit))   
# define dump_flag(flag,text) 

if ( (flag) ) 
printf(" %s", (text))   

static int _verbose = 1;   
inline uint8_t get_8(uint8_t *buf, int *pos) 
{   
	uint8_t tmp8;   
	tmp8 = buf[*pos];   
	*pos+=1;   return tmp8; 
}   

inline uint16_t get_16(uint8_t *buf, int *pos) 
{   
	uint16_t tmp16;   
	tmp16 = buf[*pos+1] + (buf[*pos] << 8);   
	*pos+=2;   
	return tmp16;   
	}   

inline uint32_t get_32(uint8_t *buf, int *pos) 
{   
	uint32_t tmp32;   
	tmp32 = buf[*pos+3] + (buf[*pos+2] << 8) + (buf[*pos+1] << 16) + (buf[*pos] << 24);   
	*pos+=4;   return tmp32;   
}   
inline char *get_str8(uint8_t *buf, int *pos) 
{   
	int len;   
	uint8_t tmp8;   
	char *str;     
	len = get_8(buf, pos);   
	if (len < 0) 
	return NULL; 
 
	str = malloc(len + 1);   
	
	if (!str) return NULL;   
	memcpy(str, &buf[*pos], len);   
	str[len] = '\0';   
	*pos+=len;   
	return str; 
}   

void dump_bits16(uint16_t n) 
{   
	int i;   //printf("%u=",n);   
	for (i=15; i>=0; i--) 
	{     
	printf("%u", ((n & (1 << i)) >> i));     
	if ((i % 4) == 0) printf(" ");   
	} 
}   
typedef struct 
{   
	int pid;   
	uint64_t last_pts;   
	uint64_t last_dts; 
} 

MpegTsPid;   

// MPEG-TS transport packet 

typedef struct 
{   
	int len;            // 8 Number of bytes in the adaptation field immediately following this byte   
	int discont;        // 1 Set to 1 if current TS packet is in a discontinuity state   
	int random_access;  // 1 Set to 1 if the PES packet in this TS packet starts a video/audio sequence   
	int es_prior;       // 1 higher priority)   
	int pcr_flag;       // 1 adaptation field does contain a PCR field   
	int opcr_flag;      // 1 adaptation field does contain an OPCR field   
	int splice_flag;    // 1 splice countdown field in adaptation field   
	int priv_flag;      // 1 private data bytes in adaptation field   
	int ext_flag;       // 1 adaptation field extension   
	uint64_t pcr;       // 33+6+9 Program clock reference (90 kHz base)   
	int pcr_ext;        // PCR extension (27 MHz)   
	uint64_t opcr;      // 33+6+9 Original Program clock reference. Helps when one TS is copied into another   
	int opcr_ext;       // OPCR extension (27 MHz)   
	int splice;         // 8 Indicates how many TS packets from this one a splicing point occurs (may be negative) } MpegTsAdaptField;   
	
typedef struct 
{   	int error_flag;     // 1  Transport Error Indicator   
	int payload_flag;   // 1  Payload Unit Start Indicator   
	int priority_flag;  // 1  Transport Priority   
	int pid;            // 13 Packet ID   
	int scramble;       // 2  Transport scrambling control (0,1,2,3)   
	int adapt_field;    // 2  Adaptation field control (1,2,3)   
	int cc;             // 4  Continuity counter   
	MpegTsAdaptField af; 
} 

MpegTsPacket;   

// PSI (Program Specific Information) structures /* SI (system information) section */ 

typedef struct 
{   	int skip_bytes;   // 8 skip bytes to payload   
	int table_id;     // 8 table ID   
	int syntax_flag;  // 1 section syntax indicator   
	int pvt_flag;     // 1 private indicator                     
			// 2 reserved   
	int len;          // 12 section length   
	int len_pos;      // .. section length counts from this point                     
			// 	if (syntax_flag == 0), next private data .len-4 bytes                     
			// if syntax_flag == 1 then use next fields:   
	int ext_id;       // 16 table ID extension                     // 2 reserved   
	int version;      // 5 version number   
	int next_flag;    // 1 current next indicator   int num;          // 8 section number   
	int last_num;     // 8 last section number                     // .. 
	private data .len-9 bytes 
} 
MpegTsSiHeader;   

typedef struct 
{   
	int tag;          // 8 descriptor tag   
	int len;          // 8 descriptor data length in bytes   
	uint8_t *data;    // raw data 
} 
MpegTsDescriptor;   

/* PAT (program association table */ 

typedef struct 
{   
int num;          // 16 program num                     // 3 reserved, '111'   
int pid;          // 13 packets with this PID are assumed to be PMT tables   
} 
MpegTsPatRecord;   


typedef struct 
{   
MpegTsSiHeader *h;                       
	// .h.table_id = 0x00                       
	// .h.section_syntax = 1                       
	// .h.ext_id = transport stream id     
int record_count;   //   MpegTsPatRecord records[32]; 
} 

MpegTsPat;   

/* PMT (program map table) */ 

typedef struct 
{   
int es_type;        // 08                       // 03 reserved '111'   
int es_pid;         // 13                       // 04 reserved   
int desc_len;    // 12 First two bits must be zero. Entire value may be zero   
int desc_count;     //    MpegTsDescriptor desc[8]; 
} 
MpegTsPmtRecord;   

typedef struct 
{   
MpegTsSiHeader *h;                       
// .h.table_id = 0x02                       
// .h.section_syntax = 1                       
// .h.ext_id = program num                       
// ..                       
// 03 reserved   
int pcr_pid;        
// 13 PID of general timecode stream, or 0x1FFF                       
// 4 reserved   int info_len;       
// 12 Sum size of following program descriptors.     
int record_count;   
//   MpegTsPmtRecord records[32];   
} 
MpegTsPmt;   

/* SDT (Service Description Table) */ 

typedef struct 
{   
int service_id;   
// 16 service ID                     
// 6 reserved   
int schedule;     // 1 EIT schedule flag   
int follow;       // 1 EIT present following flag   

int running_status; // 3 running status (1-stop, 2-starts, 3-pause, 4-running, 5-off-air)   
int free_ca_mode; // 1 free CA mode (0-not scrambled)   
int descr_len;    // 12 descriptor loop length   
int descr_count;  // descriptors count   
MpegTsDescriptor desc[8]; // descriptors    
} 

MpegTsSdtRecord;   
#define MAX_SDT_SERVICES 16 
typedef struct {   MpegTsSiHeader *h;                   
// .table_id = 0x42                   
// .h.ext_id = transport stream id   

int orig_nw_id; 

// 16 original network id                   
// 8 reserved                   
// .. services   

int services_nb; // number of services   

MpegTsSdtRecord services[MAX_SDT_SERVICES]; 

} 

MpegTsSdt;   

/* PES (Packetized Elementary Stream */ 
typedef struct 
{   
int stream_id;   
int len;            // Can be zero. If the PES packet length is set to zero, the PES packet can be of any length. A value of zero for the PES packet length can be used only when the PES packet payload is a video elementary stream.   
int scrambl;        // 00 implies not scrambled   
int prior_flag;   
int align_flag;     // 1 indicates that the PES packet header is immediately followed by the video start code or audio syncword   
int copyryght_flag; // 1 implies copyrighted   
int orig_flag;      // 1 implies original   
int pts_dts;        // 2 (11 = both present, 10 = only PTS   
int escr_flag;      // 1 ESCR flag   
int es_rate_flag;   // 1 ES rate flag   
int dsm_trick_mode_flag; // 1 DSM trick mode flag   
int add_copy_inf_flag;  // 1 Additional copy info flag   
int crc_flag;       // 1 CRC flag   
int ext_flag;       // 1 extension flag   
int data_len;       // 8 PES header data length                       
// ..optional fields                       
// Presentation Time Stamp / Decode Time Stamp   

uint64_t pts;       // 5b 001? 32..30 1 / 29..15 1 / 14..00 1   
uint64_t dts;       // 5b 00?1 32..30 1 / 29..15 1 / 14..00 1                       
// Elementary Stream Clock Reference, used if the stream and system levels are not synchronized   
long int escr_base; // 6b 00 32..30 1 29..15 1 14..00 1 ext 1   
int escr_ext;                              
// The rate at which data is delivered for this stream, in units of 50 bytes/second   
int es_rate;        // 16 1 es_rate 1   
int dsm_trick_mode;   
int add_copy_info;   
int prev_crc;       // 16 The polynomial used is X^16 + X^12 + X^5 + 1 
} 
MpegTsPes;  
 
typedef struct 
{   
uint8_t buf[MAX_BUFFER];   
int pos;   
int pids_count;   
MpegTsPid pids[32];       // stream pids from PAT/PMT   
MpegTsPid *cur_pid;       // current pid   uint64_t last_pcr;   
MpegTsPacket *cur_pkt;    // current transport packet 
} 
MpegTS;       
static MpegTS ts;   
char* get_pid_description(int pid) 
{   
switch (pid) 
{     
case PAT_PID: return "Program Association Table (PAT)";     
case CAT_PID: return "Conditional Access Table (CAT)";     
case TSDT_PID: return "Transport Stream Description (TSDT)";     
case NIT_PID: return "Network Information Table (NIT)";     
case SDT_PID: return "Service Description Table (SDT)";   
}   
return ""; 
}   

char* get_pid_name(int pid) 
{   
switch (pid) 
{     
case 0x0000: return "PAT";     
case 0x0001: return "CAT";     
case 0x0010: return "NIT,ST";     
case 0x0011: return "SDT,BAT,ST";     
case 0x0012: return "EIT,ST_CIT";     
case 0x0013: return "RST,ST";     
case 0x0014: return "TDT,TOT,ST";     
case 0x0015: return "network synchronization";     
case 0x0016: return "RNT";     
case 0x001c: return "inband signaling";     
case 0x001d: return "measurement";     
case 0x001e: return "DIT";     
case 0x001f: return "SIT";   
}  
return ""; 
}   
char* get_table_id_name(int pid) 
{   
switch (pid) 
{     
case 0x00: return "program association";     
case 0x01: return "conditional access";     
case 0x02: return "program map";     
case 0x03: return "transport stream description";     // 0x04 - 0x3f "reserved"     
case 0x40: return "actual network info";     
case 0x41: return "other network info";     
case 0x42: return "actual service description";     
case 0x46: return "other service description";     
case 0x4a: return "bouquet association";     
case 0x4e: return "actual event info now";     
case 0x4f: return "other event info now";     

// 0x50 - 0x5f "event info actual schedule"     
// 0x60 - 0x6f "event info other schedule"   
  
case 0x70: return "time data";     
case 0x71: return "running status";     
case 0x72: return "stuffing";     
case 0x73: return "time offset";     
case 0x74: return "application information";     
case 0x75: return "container";     
case 0x76: return "related content";     
case 0x77: return "content id";     
case 0x78: return "MPE-FEC";     
case 0x79: return "resolution notification";     
case 0x7a: return "MPE-IFEC";   
  
// 0x7b - 0x7d "reserved"   
  
case 0x7e: return "discontinuity info";     
case 0x7f: return "selection info";  
   
// 0x80 - 0xfe "user defined"  
   
case 0xff: return "reserved";   
}   
return "reserved"; 
}   
char* get_stream_id_name(int stream_id) 
{   
switch (stream_id) 
{    
case 0x0000: return "reserved";     
case 0x0001: return "ISO/IEC 11172-2 (MPEG-1 Video)";     
case 0x0002: return "ISO/IEC 13818-2 (MPEG-2 Video)";     
case 0x0003: return "ISO/IEC 11172-3 (MPEG-1 Audio)";     
case 0x0004: return "ISO/IEC 13818-3 (MPEG-2 Audio)";     
case 0x0005: return "ISO/IEC 13818-1 (private section)";     
case 0x0006: return "ISO/IEC 13818-1 PES";     
case 0x0007: return "ISO/IEC 13522 MHEG";     
case 0x0008: return "ITU-T H.222.0 annex A DSM-CC";     
case 0x0009: return "ITU-T H.222.1";     
case 0x000a: return "ISO/IEC 13818-6 DSM-CC type A";     
case 0x000b: return "ISO/IEC 13818-6 DSM-CC type B";     
case 0x000c: return "ISO/IEC 13818-6 DSM-CC type C";     
case 0x000d: return "ISO/IEC 13818-6 DSM-CC type D";     
case 0x000e: return "ISO/IEC 13818-1 (auxiliary)";     
case 0x000f: return "ISO/IEC 13818-7 (AAC Audio)";     
case 0x0010: return "ISO/IEC 14496-2 (MPEG-4 Video)";     
case 0x0011: return "ISO/IEC 14496-3 (AAC LATM Audio)";     
case 0x001b: return "ITU-T H.264 (h264 Video)";     
case 0x00ea: return "(VC-1 Video)";     
case 0x00d1: return "(DIRAC Video)";     
case 0x0081: return "(AC3 Audio)";     
case 0x008a: return "(DTS Audio)";     
case 0x00bd: return "(non-MPEG Audio, subpictures)";     
case 0x00be: return "(padding stream)";     
case 0x00bf: return "(navigation data)";   
  
//case 0x001e: return "";     
//case 0x001f: return ""; 
    
default: 
{       
if ((stream_id >= 0xc0) && (stream_id <= 0xdf)) 
return "(AUDIO stream)";      
 
else if ((stream_id >= 0xe0) && (stream_id <= 0xef)) 
return "(VIDEO stream)";       
}   
}   
return ""; 
}   
int parse_descriptor(uint8_t *buf, int *pos, MpegTsDescriptor *desc) 
{  
 char *tmp_str;   
uint8_t tmp8;   
  
desc->tag = get_8(buf, pos);   
desc->len = get_8(buf, pos);
    
if (desc->tag == 0x48) 
{ 
// service descriptor     
tmp8 = get_8(buf, pos);     
printf("    service type=0x%02x", tmp8);     
tmp_str = get_str8(buf, pos);     
printf(" author=\"%s\"", tmp_str);     
free(tmp_str);       
tmp_str = get_str8(buf, pos);     
printf(" info=\"%s\"\n", tmp_str);     
free(tmp_str);     
return 0;   
} 
else
{     
printf("    descriptor tag=0x%02x length=%u \n", desc->tag, desc->len);  
 }   
//desc->data = malloc(desc->len+1);   
//memcpy(desc->data, &buf[*pos], desc->len);   
*pos+=desc->len;     
return 0; 
}     
int parse_si_header(uint8_t *buf, int *pos, MpegTsSiHeader *h) 
{   
uint8_t tmp8;   
uint16_t tmp16;   
h->skip_bytes = get_8(buf, pos);   
h->table_id = get_8(buf, pos); 

// must be 0x42   

tmp16 = get_16(buf, pos);   
h->syntax_flag = get_bit(tmp16, 15);   
h->len = tmp16 & 0x0fff; // 000 1111   
h->len_pos = *pos;   
if (h->syntax_flag) 
{     
h->ext_id = get_16(buf, pos);     
tmp8 = get_8(buf, pos);     
h->next_flag = get_bit(tmp8, 0);     
h->version = tmp8 & 0x3e >> 1; // 0011 1110     
h->num = get_8(buf, pos);     
h->last_num = get_8(buf, pos);   
}     
// dump SI header   
if (_verbose) 
{     
// dump header     
printf("  SI header: skip_bytes=%u table_id=%#02x length=%u", 
h->skip_bytes, h->table_id, h->len);     
dump_flag(h->syntax_flag, "syntax");     
if (h->syntax_flag) {       
printf(" ext_id=%u version=%u number=%u last_number=%u", 
h->ext_id, h->version, h->num, h->last_num);       
dump_flag(h->next_flag, "next");     
}      
printf("\n");   
}     
return 0; 
}   

int parse_pat(uint8_t *buf, int *pos, MpegTsSiHeader *h) 
{   
int i, i2, end_pos, sect_end;   

MpegTsPat pat_data;   
MpegTsPat *pat = &pat_data;   
uint16_t tmp16;   
MpegTsPatRecord *r;     

// non-verbose output   

if (!_verbose)
 {     
printf("pid=0x%04x [PAT]\n", ts.cur_pkt->pid);   
}   
pat->h = h;  
pat->record_count = 0;   
sect_end = pat->h->len_pos + pat->h->len - 4; 

// section length - CRC32   

while ((*pos < PKT_SIZE) && (*pos < sect_end)) 
{     
r = &pat->records[pat->record_count];     
pat->record_count++;       
r->num = get_16(buf, pos);     
tmp16 = get_16(buf, pos);     
r->pid = (tmp16 & 0x1fff); // 0001 1111      
 
// dump record info     

printf("  PAT program num=%u pmt_pid=0x%04x \n", r->num, r->pid);   
}   
}   
int parse_pmt(uint8_t *buf, int *pos, MpegTsSiHeader *h) 
{   

int start_pos = *pos;   
int i, i2, end_pos, sect_end;  
 
MpegTsPmtRecord *r;   // single table record   
MpegTsPmt t_data;           // table pointer   
MpegTsPmt *t = &t_data;   // table data   

uint8_t tmp8;   
uint16_t tmp16;     
t->record_count = 0;   
t->h = h;   
t->pcr_pid = get_16(buf, pos) & 0x1fff; // 0001 1111   
t->info_len = get_16(buf, pos) & 0x0fff; // 0000 1111     
// non-verbose output   
if (!_verbose) 
{     
printf("pid=0x%04x [PMT]\n", ts.cur_pkt->pid);   
}   
// dump header  
 
printf("  PMT pcr_pid=0x%04x", t->pcr_pid);   
if (t->info_len > 0) 
printf(" info_len=%u", t->info_len);   
printf("\n");    
 
sect_end = t->h->len_pos + t->h->len - 4; // section length - CRC32   

while ((*pos < PKT_SIZE) && (*pos < sect_end)) 
{     // parse table record     
r = &t->records[t->record_count];     
t->record_count+=1;       
r->desc_count = 0;     
r->es_type = get_8(buf, pos);     
r->es_pid = get_16(buf, pos) & 0x1fff; // 0001 1111     
r->desc_len = get_16(buf, pos) & 0x0fff; // 0000 1111  
     
// add program PID to list     

i2=0;     
for (i=0; i < ts.pids_count; i++) 
{       
if (ts.pids[i].pid == r->es_pid) i2=1; 
break;     
}     
if (i2 == 0) 
{       
ts.pids[ts.pids_count].pid = r->es_pid;       
ts.pids_count++;     
}       // dump table record info  
  
printf("  PMT elementary stream type=0x%02x pid=0x%04x", r->es_type, r->es_pid);     
if (r->desc_len > 0) printf(" desc_len=%u", r->desc_len);     
printf("\n");     
printf("    %s\n", get_stream_id_name(r->es_type));       
if (r->desc_len <= (PKT_SIZE - *pos)) 
{         
// parse descriptors       
r->desc_count = 0;       
end_pos = *pos+r->desc_len;       

while (*pos < end_pos) 
{        
parse_descriptor(buf, pos, &r->desc[r->desc_count]);         
r->desc_count+=1;       
}     
}     
}   
return 0; 
}   

int parse_sdt(uint8_t *buf, int *pos, MpegTsSiHeader *h) 
{   
int start_pos = *pos;   
int i, i2, end_pos, sect_end;   

MpegTsSdtRecord *sv;   
MpegTsSdt sdt_data;   
MpegTsSdt *sdt = &sdt_data;   
uint8_t tmp8;   
uint16_t tmp16;     
sdt->h = h;   
sdt->orig_nw_id = get_16(buf, pos);   
tmp8 = get_8(buf, pos); // reserved field   
sdt->services_nb = 0;     // non-verbose output   

if (!_verbose) 
{     
printf("pid=0x%04x [SDT]\n", ts.cur_pkt->pid);   
}   // dump header   

printf("  SDT orig_network_id=0x%04x ", sdt->orig_nw_id);   
printf("\n");     
sect_end = sdt->h->len_pos + sdt->h->len - 4; // section length - CRC32   

while ((*pos < PKT_SIZE) && (*pos < sect_end)) 
{     // parse service     
sdt->services_nb++;     
sv = &sdt->services[sdt->services_nb-1];     
sv->service_id = get_16(buf, pos);     
tmp8 = get_8(buf, pos);     
sv->schedule = get_bit(tmp8, 1);     
sv->follow = get_bit(tmp8, 0);       
tmp16 = get_16(buf, pos);     
sv->running_status = (tmp16 & 0x7000) >> 13; // 1110 0000     
sv->free_ca_mode = get_bit(tmp16, 12);     
sv->descr_len = tmp16 & 0x0fff; // 0000 1111    
   
// dump service info     
printf("  SDT service_id=0x%04x running=%u descr_len=%u", sv->service_id, sv->running_status, sv->descr_len);  
   
dump_flag(sv->schedule, "schedule");     
dump_flag(sv->follow, "follow");     
dump_flag(sv->free_ca_mode, "free_ca_mode");     

printf("\n");       

if (sv->descr_len <= (PKT_SIZE - *pos)) 
{         // parse descriptors       
sv->descr_count = 0;       
end_pos = *pos+sv->descr_len;       

while (*pos < end_pos) 
{         
parse_descriptor(buf, pos, &sv->desc[sv->descr_count]);         
sv->descr_count++;       
}     
}     
}   
return 0; 
}   

uint64_t parse_pes_pts(uint8_t *buf, int *pos) 
{   
uint64_t tmp64;   
uint16_t tmp16;   
uint8_t tmp8;     
tmp8 = get_8(buf, pos);   
tmp64 =  ((int64_t)tmp8  >> 1) &0x07  << 30;   
tmp16 = get_16(buf, pos);   
tmp64 |= ((int64_t)tmp16 >> 1) << 15;   
tmp16 = get_16(buf, pos);   
tmp64 |= ((int64_t)tmp16  >> 1);     
return tmp64; }     
int parse_pes(uint8_t *buf, int *pos) 
{   // PES   
uint16_t tmp16;   
uint8_t tmp8;   
MpegTsPes pes_data;  
MpegTsPes *pes = &pes_data;   
MpegTsPid *pid;   
int ii, payload_pos;    

// check for PES header   
// Packet start code prefix 3 bytes 0x000001   

tmp16 = get_16(buf, pos);   
tmp8 = get_8(buf, pos);   

if ((tmp16 == 0 && tmp8 == 1) != 1) 
{     // it's not PES, rewind pos backward     
*pos-=3;     
return -1;   
}   // PES detected   

tmp8 = get_8(buf, pos);   
pes->stream_id = tmp8;     
pes->len = get_16(buf, pos);;     

// dump PES header   

if (_verbose) 
{     
printf("  PES stream_id=%#x length=%u  ", pes->stream_id, pes->len);     
printf("  %s", get_stream_id_name(pes->stream_id));     printf("\n");   
}   // non-verbose output   
if (!_verbose) 
{     
printf("pid=0x%04x [PES] %s\n", ts.cur_pkt->pid, get_stream_id_name(pes->stream_id));     
// PCR     
if (ts.cur_pkt->adapt_field) 
{       
if (ts.cur_pkt->af.pcr_flag) 
{         
printf("  PCR=%llu (%+lli)", ts.cur_pkt->af.pcr, (ts.cur_pkt->af.pcr - ts.last_pcr));         
if (ts.cur_pkt->af.pcr_ext != 0) printf(" pcr_ext=%u", ts.cur_pkt->af.pcr_ext);         
printf("\n");       
}     
}   
}     // optional header   
tmp8 = get_8(buf, pos);   
ii = (tmp8 & 0xc0) >> 6; //1100 0000;   
if (ii == 2) {  // bin '10'     

pes->scrambl = (tmp8 & 0x30) >> 4; // 0011 0000     
pes->prior_flag = get_bit(tmp8, 3);     
pes->align_flag = get_bit(tmp8, 2);     
pes->copyryght_flag = get_bit(tmp8, 1);     
pes->orig_flag = get_bit(tmp8, 0);       
tmp8 = get_8(buf, pos);     
pes->pts_dts = (tmp8 & 0xc0) >> 6; //1100 0000     
pes->escr_flag = get_bit(tmp8, 5);     
pes->es_rate_flag = get_bit(tmp8, 4);     
pes->dsm_trick_mode_flag = get_bit(tmp8, 3);     
pes->add_copy_inf_flag = get_bit(tmp8, 2);     
pes->crc_flag = get_bit(tmp8, 1);     
pes->ext_flag = get_bit(tmp8, 0);     
pes->data_len = get_8(buf, pos);     
payload_pos = *pos + pes->data_len;       // dump optional header
     
if (_verbose) 
{       
printf("  PES flags:");       
dump_flag((pes->scrambl), "scramble");       
dump_flag((pes->pts_dts >> 1), "pts");       
dump_flag((pes->pts_dts & 0x01), "dts");       
dump_flag(pes->prior_flag, "priority");       
dump_flag(pes->align_flag, "align");       
dump_flag(pes->copyryght_flag, "(c)");       
dump_flag(pes->orig_flag, "original");       
dump_flag(pes->escr_flag, "ESCR");       
dump_flag(pes->es_rate_flag, "ES_rate");       
dump_flag(pes->dsm_trick_mode_flag, "DSM_trick_mode");       
dump_flag(pes->add_copy_inf_flag, "add_copy_inf");       
dump_flag(pes->crc_flag, "CRC");       
dump_flag(pes->ext_flag, "ext");       

printf("\n");     
}       
pes->pts = pes->dts = 0;       
if (pes->pts_dts > 1) 
{ // PTS       
pes->pts = parse_pes_pts(buf, pos);       

if (_verbose) 
printf("  PES PTS=%llu", pes->pts);   
    
if (!_verbose) 
printf("  PTS=%llu", pes->pts);     
    
if (ts.cur_pid != NULL) 
{         
printf(" (%+lli)", (pes->pts - ts.cur_pid->last_pts));         
ts.cur_pid->last_pts = pes->pts;       
}       
if (!_verbose) printf("\n");         
if (pes->pts_dts == 3) 
{ // DTS         
pes->dts = parse_pes_pts(buf, pos);    
     
if (_verbose) 
printf(" DTS=%llu", pes->dts);  
       
if (!_verbose) printf("  DTS=%llu", pes->dts);         
if (ts.cur_pid != NULL) 
{           
printf(" (%+lli)", (pes->dts - ts.cur_pid->last_dts));           
ts.cur_pid->last_dts = pes->dts;         
}         

if (!_verbose) printf("\n");       
}     
  
if (_verbose) 
printf("\n");     
}       

// other PES header data     
//...       
// skip to payload     

*pos = payload_pos;   
}     
// PES payload   

if (*pos+4 <= PKT_SIZE) 
{     // dump payload header 4cc     
if (_verbose) 
{       
printf("  PES payload 0x%08x", get_32(buf, pos));       
if (*pos+4 <= PKT_SIZE) {         // dump second 4cc          
printf(" 0x%08x", get_32(buf, pos));       
}       
printf("\n");     
}   
}       
return 0; 
}   
// PCR field value 

uint64_t parse_pcr(uint8_t *buf, int *pos, int *ext) 
{   
// 33 base   
// 06 reserved   
// 09 extension   

uint64_t tmp64 = 0;   
uint8_t tmp8 = 0;     

int i;   
for (i=0; i<4; i++) 
{     
tmp64 |= get_8(buf, pos) << (8*(3-i));   
}   
tmp8 = get_8(buf, pos);   
tmp64 = (tmp64 << 1) | get_bit(tmp8, 7);     
*ext = (get_bit(tmp8, 0) << 8) | get_8(buf, pos);   
return tmp64; 
}   
int parse_pkt(uint8_t *buf, MpegTsPacket *pkt) 
{   
int pos_value = 0;   
int *pos = &pos_value;   
int i, ii;   
uint16_t tmp16;   
uint8_t tmp8;   
MpegTsAdaptField *af = &pkt->af;   
MpegTsSiHeader sih;     
if (buf[*pos] != 0x47) 
return -1;   

ts.cur_pkt = pkt;   
*pos+=1;   
tmp16 = get_16(buf, pos);   
// dump_16(tmp16); 

printf(" \n");   
pkt->error_flag = get_bit(tmp16, 15);   
pkt->payload_flag = get_bit(tmp16, 14);   
pkt->priority_flag = get_bit(tmp16, 13);   
pkt->pid = tmp16 & 0x1fff; // 0x1f = 0001 1111   
tmp8 = get_8(buf, pos);   
pkt->scramble = (tmp8 & 0xc0) >> 6; // 0xc0 = 1100 0000   
pkt->adapt_field = (tmp8 & 0x30) >> 4; // 0x30 = 0011 0000   
pkt->cc = tmp8 & 0x0f; // 0000 1111     // dump packet   

if (_verbose) 
{     
printf("pid=0x%04x cc=%u", pkt->pid, pkt->cc);     
dump_flag(pkt->error_flag, "error");     
dump_flag(pkt->payload_flag, "PES/SI");     
dump_flag(pkt->priority_flag, "priority");     
dump_flag(pkt->scramble, "scramble");     
dump_flag(pkt->adapt_field > 1, "adapt");     
dump_flag(pkt->adapt_field & 1, "payload");     
printf("    %s", get_pid_description(pkt->pid));     
printf("\n");   }     // adaptation field (optional) 
  
if (pkt->adapt_field > 1) 
{     
af->len = get_8(buf, pos);       
tmp8 = get_8(buf, pos);     
af->discont =     (tmp8 & ( 1 << 7 )) >> 7;     
af->random_access = (tmp8 & ( 1 << 6 )) >> 6;     
af->es_prior =    (tmp8 & ( 1 << 5 )) >> 5;     
af->pcr_flag =    (tmp8 & ( 1 << 4 )) >> 4;     
af->opcr_flag =   (tmp8 & ( 1 << 3 )) >> 3;     
af->splice_flag = (tmp8 & ( 1 << 2 )) >> 2;     
af->priv_flag =   (tmp8 & ( 1 << 1 )) >> 1;     
af->ext_flag =    (tmp8 & ( 1 << 0 )) >> 0;       
// dump adaptation field     

if (_verbose) 
{     
printf("  adapt_field length=%u", af->len);       
dump_flag(af->discont, "discontinuity");       
dump_flag(af->random_access, "random_access");       
dump_flag(af->es_prior, "es_priority");   
    
//dump_flag(af->pcr_flag, "PCR");       
//dump_flag(af->opcr_flag, "OPCR");       
//dump_flag(af->splice_flag, "splice");       

dump_flag(af->priv_flag, "private");       
dump_flag(af->ext_flag, "extension");     
}       

// optional header data     
if (af->pcr_flag) 
{       
ts.last_pcr = af->pcr;       
af->pcr = parse_pcr(buf, pos, &(af->pcr_ext));       
if (_verbose) 
{         
printf(" PCR=%llu (%+lli)", af->pcr, (af->pcr - ts.last_pcr));         
if (af->pcr_ext != 0) printf(" pcr_ext=%u", af->pcr_ext);       
}     
}     
if (af->opcr_flag) 
{       
af->opcr = parse_pcr(buf, pos, &(af->opcr_ext));      
 
if (_verbose) 
{         
printf(" OPCR=%llu", af->pcr);         
if (af->opcr_ext != 0) printf(" opcr_ext=%u", af->opcr_ext);       
}     
}     

if (af->splice_flag) 
{       
af->splice = get_8(buf, pos);  
     
if (_verbose) 
printf(" splice_count=%i", af->splice);     
}       

if (_verbose) printf("\n");       

*pos = 4 + 1 + af->len; // skip after adaptation field     
}     

ts.cur_pid = NULL;   

if (pkt->payload_flag) 
{     
// packet have payload section       
// look for PID in PAT table     

for (i=0; i<ts.pids_count; i++) 
{       
if (ts.pids[i].pid == pkt->pid) 
{         
ts.cur_pid = &ts.pids[i];         

// detect PES header         

if (parse_pes(buf, pos) == 0) return 0;       
}     
}     

if (pkt->pid > 0x20) 

{       

if (parse_pes(buf, pos) == 0) return 0;     
}       
tmp8 = buf[*pos+1]; // table_id     
if (_verbose) printf("  service table name: %s\n", get_table_id_name(tmp8));       
parse_si_header(buf, pos, &sih);       
switch (pkt->pid) 
{       
case 0x0000: parse_pat(buf, pos, &sih); 
break; 
// PAT table       
case 0x0011: parse_sdt(buf, pos, &sih); 
break; 

// SDT table       
default: 
{         
// other packets         
if (tmp8 == 0x02) 
{ 
// PMT table           
parse_pmt(buf, pos, &sih);           
return 0;         
}           
if (pkt->payload_flag) 
{           
// unknown payload 
          
tmp16 = get_16(buf, pos);  
         
if (_verbose) 
{             
printf("  payload header=0x%02x  ", tmp16);             
dump_bits16(tmp16);             printf("\n");           
}         
}       
}     
}   
}     
return 0; 
}   
int do_some() 
{   
int ir, i, pos47;   
MpegTsPacket pkt;   
uint8_t pkt_buf[PKT_SIZE];     
ts.last_pcr = 0;   
ts.pids_count = 0;   
ir = fread(ts.buf, 1, MAX_BUFFER, stdin);   

if (ir != MAX_BUFFER) 
return -1;   
for (i=0; i<ir; i++) 
{     
if (ts.buf[i] == 0x47) 
{       
pos47 = i;       
memcpy(&pkt_buf, &ts.buf[i], sizeof(pkt_buf));       
i+=sizeof(pkt_buf)-1;       
parse_pkt(&pkt_buf[0], &pkt);         
fflush(stdout);       
}   
}     
}     
int main(int argc, char**argv) 
{   

if (argc > 1)
 {     

if ((strcmp(argv[1], "--help") == 0) || (strcmp(argv[1], "-h") ==0)) 
{       
printf("  Usage: %s [-b] < input.ts > output.log\n", argv[0]);       
printf("Options:\n");       
printf("    -b - brief mode\n");       

return 0;     
}     
if (strcmp(argv[1], "-b") == 0) 
{       _verbose=0;     

}   

}   
do_some();   

return 0; 
}