Parsing Transport stream PAT and PMT

//TSStructs.h

#ifndef __TSSTRUCTS_H_LUCKYLIU_H__
#define __TSSTRUCTS_H_LUCKYLIU_H__

#include <list>

#define WW_PATPID  (0x0000)
#define WW_PATTABLEID (0x00)
#define WW_PMTTABLEID (0x02)
#define WW_TSPACKET_LEN (188)
#define WW_TSSYNCBYTE (0x47)

//TSPACKET
//One ts packet is contained by TSPacketHeader, adaption field, payload data.
//If there is adaption filed, adaption field length is specified by the first byte after TSPacketHeader.
//Payload bytes length is the remained bytes.

typedef struct WW_TSPACKETHEAD_ //4 BYTES
{
 unsigned char ucSyncByte;       // First byte
 unsigned char PID_hibits : 5;      // Second byte - Notice the reverse declaration
 unsigned char  transport_priority : 1;
 unsigned char  payload_unit_start_indicator : 1;
 unsigned char transport_error_indicator : 1;
 unsigned char PID_lobits;       // Third byte
 unsigned char continuity_counter : 4;    // Fourth byte
 unsigned char _payload_present_flag : 1;
 unsigned char _adaptation_field_present_flag : 1;
 unsigned char transport_scrambling_control : 2;
} WW_TSPACKETHEAD, *PWW_TSPACKETHEAD;

//PAT
typedef struct WW_PATSECTIONHEAD_ //8 BYTES
{
 unsigned char table_id;
 unsigned char section_length_highbits : 4;
 unsigned char reserved_twobits : 2;
 unsigned char must_be_zero : 1;
 unsigned char section_syntax_indicator : 1;
 unsigned char section_length_lowbits;
 unsigned char transport_stream_id_hi;
 unsigned char transport_stream_id_lo;
 unsigned char current_next_indicator : 1;
 unsigned char version_number : 5;
 unsigned char reserved_twobits_2 : 2;
 unsigned char section_number;
 unsigned char last_section_number;
} WW_PATSECTIONHEAD, *PWW_PATSECTIONHEAD;

typedef struct WW_PATSECTIONPROTRAMMAP_// 4 BYTES
{
 unsigned char program_number_hi;
 unsigned char program_number_lo;
 unsigned char program_map_PID_highbits : 5;
 unsigned char reserved : 3;
 unsigned char program_map_PID_lo;
} WW_PATSECTIONPROTRAMMAP, *PWW_PATSECTIONPROTRAMMAP;
typedef std::list<WW_PATSECTIONPROTRAMMAP> WW_PATSECTIONPROTRAMMAPLIST;

//PMT
typedef struct WW_PMTSECTIONHEAD_ //12 BYTES
{
 unsigned char table_id;
 unsigned char section_length_highbits : 4;
 unsigned char reserved_twobits : 2;
 unsigned char must_be_zero : 1;
 unsigned char section_syntax_indicator : 1;
 unsigned char section_length_lowbits;
 unsigned char program_number_hi;
 unsigned char program_number_lo;
 unsigned char current_next_indicator : 1;
 unsigned char version_number : 5;
 unsigned char reserved_twobits_2 : 2;
 unsigned char section_number;
 unsigned char last_section_number;
 unsigned char PCR_PID_highbits : 5;
 unsigned char reserved_threebits : 3;
 unsigned char PCR_PID_lo;
 unsigned char program_info_length_highbits : 4;
 unsigned char reserved_fourbits : 4;
 unsigned char program_info_length_lo;
}WW_PMTSECTIONHEAD, *PWW_PMTSECTIONHEAD;

typedef struct WW_PMTSECTIONSTREAMMAP_ //5 BYTES
{
 unsigned char stream_type; //0x01 mpeg1 video; 0x02 mpeg2 video; 0x03 mpeg1 audio; 0x04 mpeg2 audio;
 unsigned char elementary_PID_highbits : 5;
 unsigned char reserved : 3;
 unsigned char elementary_PID_lo;
 unsigned char ES_info_length_hibits : 4;
 unsigned char reserved2 : 4;
 unsigned char ES_info_length_lo;
}WW_PMTSECTIONSTREAMMAP, *PWW_PMTSECTIONSTREAMMAP;
typedef std::list<WW_PMTSECTIONSTREAMMAP> WW_PMTSECTIONSTREAMMAPLIST;

typedef struct WW_TSPROGRAMSTREAMMAP_
{
 WORD wProgramNumber;
 WW_PMTSECTIONSTREAMMAPLIST lstStreamMap;
}WW_TSPROGRAMSTREAMMAP, *PWW_TSPROGRAMSTREAMMAP;
typedef std::list<WW_TSPROGRAMSTREAMMAP> WW_TSPROGRAMSTREAMMAPLIST;

typedef struct struWWTSVIDEO_
{
 WORD    wPID;
 WORD    wStreamID;
 //FORMAT_MPEG2Video videoFmt;
 char    szFmt[32];
}WWTSVIDEO, *PWWTSVIDEO;
typedef std::list<WWTSVIDEO> WWTSVIDEOLIST;

typedef struct struWWTSAUDIO_
{
 WORD    wPID;
 WORD    wStreamID;
 //FORMAT_WaveFormatEx audioFmt;
 char    szFmt[32];
}WWTSAUDIO, *PWWTSAUDIO;
typedef std::list<WWTSAUDIO> WWTSAUDIOLIST;

typedef struct WWTSPROGRAM_
{
 WORD wProgramNumber;
 WWTSVIDEOLIST lstVideo;
 WWTSAUDIOLIST lstAudio;
}WWTSPROGRAM, *PWWTSPROGRAM;
typedef std::list<WWTSPROGRAM> WWTSPROGRAMLIST;

#endif

#ifndef __WWTSPACKET_H_LUCKYLIU_H__
#define __WWTSPACKET_H_LUCKYLIU_H__

#include "TSStructs.h"

class WWTSPacket
{
public:
 WWTSPacket(void);
 virtual ~WWTSPacket(void);

public:
 BOOL  Load(BYTE* pBuffer, int nLen);
 virtual void Dump();
 WORD  GetPID();
 BYTE  GetTransportPriority();
 BYTE  GetPayloadUnitStartIndicator();
 BYTE  GetTransportErrorIndicator();
 BYTE  GetContinuityCounter();
 BOOL  HasPayload();
 BOOL  HasAdaptationField();
 BYTE  GetTransportScramblingControl();
 PBYTE GetPayload(WORD *pwLen);
 PBYTE GetAdaptationField(WORD *pwLen);

protected:
 PBYTE m_pTSPacket;

};

#endif

#include "StdAfx.h"
#include "./wwtspacket.h"

WWTSPacket::WWTSPacket(void)
{
 m_pTSPacket = new BYTE[WW_TSPACKET_LEN];
}

WWTSPacket::~WWTSPacket(void)
{
 delete[] m_pTSPacket;
}

BOOL  WWTSPacket::Load(BYTE* pBuffer, int nLen)
{
 if( nLen<WW_TSPACKET_LEN )
 {
  return FALSE;
 }

 if( *pBuffer!=WW_TSSYNCBYTE )
 {
  return FALSE;
 }

 memcpy(m_pTSPacket, pBuffer, WW_TSPACKET_LEN);
 return TRUE;
}

WORD WWTSPacket::GetPID()
{
 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;

 return MAKEWORD( pTsHeader->PID_lobits, pTsHeader->PID_hibits );
}

BYTE  WWTSPacket::GetTransportPriority()
{
 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;

 return pTsHeader->transport_priority;
}

BYTE  WWTSPacket::GetPayloadUnitStartIndicator()
{
 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;

 return pTsHeader->payload_unit_start_indicator;
}

BYTE  WWTSPacket::GetTransportErrorIndicator()
{
 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;

 return pTsHeader->transport_error_indicator;
}

BYTE  WWTSPacket::GetContinuityCounter()
{
 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;

 return pTsHeader->continuity_counter;
}

BOOL  WWTSPacket::HasPayload()
{
 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;

 return pTsHeader->_payload_present_flag;
}

BOOL  WWTSPacket::HasAdaptationField()
{
 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;

 return pTsHeader->_adaptation_field_present_flag;
}

BYTE  WWTSPacket::GetTransportScramblingControl()
{
 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;

 return pTsHeader->transport_scrambling_control;
}

PBYTE WWTSPacket::GetPayload(WORD *pwLen)
{
 PBYTE pBuffer = 0;
 *pwLen = 0;
 PBYTE pAdaptation = 0;
 WORD wLenAdaptation = 0;

 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;
 if( pTsHeader->_payload_present_flag )
 {
  pAdaptation = GetAdaptationField(&wLenAdaptation);
  if( pAdaptation )
  {
   *pwLen = WW_TSPACKET_LEN - sizeof(WW_TSPACKETHEAD) - 1 - wLenAdaptation;
   pBuffer = m_pTSPacket + sizeof(WW_TSPACKETHEAD) + 1 + wLenAdaptation;
   if( *pwLen==0 )
   {
    pBuffer = 0;
   }
  }
  else
  {
   pBuffer = m_pTSPacket + sizeof(WW_TSPACKETHEAD);
   *pwLen = WW_TSPACKET_LEN - sizeof(WW_TSPACKETHEAD);
  }
 }

 return pBuffer;
}

PBYTE WWTSPacket::GetAdaptationField(WORD *pwLen)
{
 PBYTE pBuffer = 0;
 *pwLen = 0;

 PWW_TSPACKETHEAD pTsHeader = (PWW_TSPACKETHEAD)m_pTSPacket;
 if( pTsHeader->_adaptation_field_present_flag )
 {
  *pwLen = ( WORD )(* (m_pTSPacket + sizeof(WW_TSPACKETHEAD)) );
  pBuffer = m_pTSPacket + 1;

  if( *pwLen> WW_TSPACKET_LEN-sizeof(WW_TSPACKETHEAD)-1 )
  {
   *pwLen = WW_TSPACKET_LEN-sizeof(WW_TSPACKETHEAD)-1;
  }
 }

 return pBuffer;
}

void WWTSPacket::Dump()
{
}

#ifndef __WWPATPACKET_H_LUCKYLIU__
#define __WWPATPACKET_H_LUCKYLIU__

#include "wwtspacket.h"

class WWPatPacket :
 public WWTSPacket
{
public:
 WWPatPacket(void);
 virtual ~WWPatPacket(void);

public:
 BOOL Load(BYTE* pBuffer, int nLen);
 void GetProgramMapList(WW_PATSECTIONPROTRAMMAPLIST* pLstProgramMap);
 virtual void Dump();

protected:
 WW_PATSECTIONPROTRAMMAPLIST m_lstProgramMap;
 PWW_PATSECTIONHEAD   m_pSectionHeader;
};

#endif
#include "StdAfx.h"
#include "./wwpatpacket.h"

WWPatPacket::WWPatPacket(void):
m_pSectionHeader(0),
WWTSPacket()
{
}

WWPatPacket::~WWPatPacket(void)
{
}

BOOL WWPatPacket::Load(BYTE* pBuffer, int nLen)
{
 //load tspacket.
 if( !WWTSPacket::Load(pBuffer, nLen) )
 {
  return FALSE;
 }

 //check if this pid is pat id.
 if( WWTSPacket::GetPID()!=WW_PATPID )
 {
  return FALSE;
 }

 PBYTE pPayload = 0;
 PBYTE pPatPayload = 0;
 WORD  wPayload = 0;
 WORD  wPatPayload = 0;
 WORD  wDiff = 0;

 //get pat payload buffer pointer and pat payload bytes number.
 if( !WWTSPacket::HasPayload() )
 {
  return FALSE;
 }
 pPayload = WWTSPacket::GetPayload(&wPayload);
 if( pPayload==0 || wPayload==0 )
 {
  return FALSE;
 }
 wDiff = (WORD)(*pPayload) + 1;//pointer_field
 if( wDiff>=wPayload )
 {
  return FALSE;
 }
 pPatPayload = pPayload + wDiff;
 wPatPayload = wPayload - wDiff;
 int nPatPayload = wPatPayload;

 //parse every pat section.
 m_lstProgramMap.clear();
 m_pSectionHeader = (PWW_PATSECTIONHEAD)(pPatPayload);
 while( nPatPayload>=sizeof(WW_PATSECTIONHEAD)+4 )
 {
  PWW_PATSECTIONHEAD pPatHead = (PWW_PATSECTIONHEAD)(pPatPayload);
  if( pPatHead->table_id!=0x00 ||
   pPatHead->section_syntax_indicator!=0x01 ||
   pPatHead->must_be_zero!=0x00 ||
   //pPatHead->reserved_twobits!=0x00 ||
   //pPatHead->reserved_twobits_2!=0x00 ||
   pPatHead->current_next_indicator!=0x01)
  {
   break;
  }
  WORD wSecLen = MAKEWORD(pPatHead->section_length_lowbits, pPatHead->section_length_highbits);
  if( wSecLen+3 > nPatPayload )
  {
   break;
  }
  WORD wPMapCount = (wSecLen - 5 - 4)/sizeof(WW_PATSECTIONPROTRAMMAP);
  for( WORD wIndex = 0; wIndex<wPMapCount; wIndex++ )
  {
   PWW_PATSECTIONPROTRAMMAP pPMap = (PWW_PATSECTIONPROTRAMMAP)(pPatPayload+sizeof(WW_PATSECTIONHEAD)+wIndex*sizeof(WW_PATSECTIONPROTRAMMAP));
   m_lstProgramMap.push_back(*pPMap);
  }

  pPatPayload += (wSecLen + 3);
  nPatPayload -= (wSecLen + 3);
 }

 for( WW_PATSECTIONPROTRAMMAPLIST::iterator it = m_lstProgramMap.begin(); it!=m_lstProgramMap.end(); )
 {
  if( MAKEWORD(it->program_number_lo, it->program_number_hi)==0 )
  {
   WW_PATSECTIONPROTRAMMAPLIST::iterator itDel = it;
   it++;
   m_lstProgramMap.erase(itDel);
  }
  else
  {
   it++;
  }
 }

 return TRUE;
}

void WWPatPacket::GetProgramMapList(WW_PATSECTIONPROTRAMMAPLIST* pLstProgramMap)
{
 pLstProgramMap->clear();
 *pLstProgramMap = m_lstProgramMap;
}

void WWPatPacket::Dump()
{
 printf("PAT packet(PID=0x%.4x)/n", WWTSPacket::GetPID());
 for( WW_PATSECTIONPROTRAMMAPLIST::iterator it = m_lstProgramMap.begin(); it!=m_lstProgramMap.end(); it++ )
 {
  printf("    Program Number: 0x%.4x, PMT PID: 0x%.4x/n", MAKEWORD(it->program_number_lo, it->program_number_hi),
   MAKEWORD(it->program_map_PID_lo, it->program_map_PID_highbits) );
 }
}

#ifndef __WWPMTPACKET_H_LUCKYLIU__
#define __WWPMTPACKET_H_LUCKYLIU__

#include "wwtspacket.h"

class WWPmtPacket :
 public WWTSPacket
{
public:
 WWPmtPacket(void);
 virtual ~WWPmtPacket(void);

public:
 BOOL Load(BYTE* pBuffer, int nLen);
 void GetProgramStreamMap(WW_TSPROGRAMSTREAMMAPLIST* pProgramStreamMapList);
 virtual void Dump();

protected:
 WW_TSPROGRAMSTREAMMAPLIST m_lstProgramStreamMap;

};

#endif
#include "StdAfx.h"
#include "./wwpmtpacket.h"

WWPmtPacket::WWPmtPacket(void):
WWTSPacket()
{
}

WWPmtPacket::~WWPmtPacket(void)
{
}

BOOL WWPmtPacket::Load(BYTE* pBuffer, int nLen)
{
 m_lstProgramStreamMap.clear();
 if( !WWTSPacket::Load(pBuffer, nLen) )
 {
  return FALSE;
 }

 if( !WWTSPacket::HasPayload() )
 {
  return FALSE;
 }

 PBYTE pPayload = 0, pPmtPayload = 0;
 WORD  wPayload = 0, wPmtPayload = 0, wDiff = 0;

 pPayload = WWTSPacket::GetPayload(&wPayload);
 if( pPayload==NULL || wPayload==0 )
 {
  return FALSE;
 }
 wDiff = (WORD)(*pPayload) + 1;
 if( wDiff>=wPayload )
 {
  return FALSE;
 }

 pPmtPayload = pPayload + wDiff;
 wPmtPayload = wPayload - wDiff;
 int nPmtPayload = wPmtPayload;
 BOOL bSuccessful = TRUE;

 while( nPmtPayload >= 12+4 && bSuccessful)//sizeof(WW_PMTSECTIONHEAD)
 {
  PWW_PMTSECTIONHEAD pHeader = (PWW_PMTSECTIONHEAD)pPmtPayload;
  if( pHeader->table_id!=0x02 ||
   pHeader->section_syntax_indicator!=0x01 ||
   pHeader->must_be_zero!=0x00 ||
   pHeader->current_next_indicator!=0x01 )
  {
   break;
  }

  WORD wSecLen = MAKEWORD( pHeader->section_length_lowbits, pHeader->section_length_highbits);
  WORD wProLen = MAKEWORD( pHeader->program_info_length_lo, pHeader->program_info_length_highbits);
  if( wSecLen+3>nPmtPayload )
  {
   break;
  }
  if( wProLen+9+4>wSecLen )
  {
   break;
  }

  WW_TSPROGRAMSTREAMMAP mapProStrm;
  mapProStrm.wProgramNumber = MAKEWORD( pHeader->program_number_lo, pHeader->program_number_hi);
  WORD wStreamMapLen = wSecLen - 9 -4 - wProLen;
  PBYTE pMap = pPmtPayload + 12 + wProLen;//sizeof(PWW_PMTSECTIONHEAD)
  while( wStreamMapLen>=5 )
  {
   PWW_PMTSECTIONSTREAMMAP pStreamMap = (PWW_PMTSECTIONSTREAMMAP)pMap;
   WORD wInfoLen = MAKEWORD( pStreamMap->ES_info_length_lo, pStreamMap->ES_info_length_hibits);
   if( wInfoLen+5>wStreamMapLen )
   {
    bSuccessful = FALSE;
    break;
   }
   mapProStrm.lstStreamMap.push_back( *pStreamMap );
   wStreamMapLen = wStreamMapLen - 5 - wInfoLen;
   pMap = pMap + 5 + wInfoLen;
  }

  if( bSuccessful )
  {
   m_lstProgramStreamMap.push_back( mapProStrm );
   pPmtPayload = pPmtPayload + 3 + wSecLen;
   nPmtPayload = nPmtPayload - (3 + wSecLen);
  }
  else
  {
   break;
  }
 }

 return TRUE;

}

void WWPmtPacket::GetProgramStreamMap(WW_TSPROGRAMSTREAMMAPLIST* pProgramStreamMapList)
{
 pProgramStreamMapList->clear();
 *pProgramStreamMapList = m_lstProgramStreamMap;
}

void WWPmtPacket::Dump()
{
 printf("PMT packet(PID=0x%.4x)/n", WWTSPacket::GetPID());
 for( WW_TSPROGRAMSTREAMMAPLIST::iterator it = m_lstProgramStreamMap.begin(); it!=m_lstProgramStreamMap.end(); it++ )
 { 
  printf("    Program number: 0x%.4x/n", it->wProgramNumber);
  for( WW_PMTSECTIONSTREAMMAPLIST::iterator itt = it->lstStreamMap.begin(); itt!=it->lstStreamMap.end(); itt++ )
  {
   printf("    PID: 0x%.4x, Stream Type: 0x%.4x/n", MAKEWORD(itt->elementary_PID_lo, itt->elementary_PID_highbits),
                itt->stream_type);
  }
 }
}