diff options
Diffstat (limited to 'mpeglib/lib/mpegplay/pesSystemStream.cpp')
| -rw-r--r-- | mpeglib/lib/mpegplay/pesSystemStream.cpp | 498 |
1 files changed, 498 insertions, 0 deletions
diff --git a/mpeglib/lib/mpegplay/pesSystemStream.cpp b/mpeglib/lib/mpegplay/pesSystemStream.cpp new file mode 100644 index 00000000..10787f21 --- /dev/null +++ b/mpeglib/lib/mpegplay/pesSystemStream.cpp @@ -0,0 +1,498 @@ +/* + demux pes mpeg stream + Copyright (C) 2001 Martin Vogt + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Library General Public License as published by + the Free Software Foundation. + + For more information look at the file COPYRIGHT in this package + + */ + + + +#include "pesSystemStream.h" + +#include <iostream> + +using namespace std; + +PESSystemStream::PESSystemStream(InputStream* input) { + this->input=input; +} + + +PESSystemStream::~PESSystemStream() { +} + + + +int PESSystemStream::getByteDirect() { + unsigned char byte; + if (input->read((char*)&byte,1) != 1) { + return -1; + } + bytes_read++; + return (int)byte; +} + +int PESSystemStream::read(char* pointer,int bytes) { + if (input->read(pointer,bytes) != bytes) { + return false; + } + bytes_read+=bytes; + + return true; +} + +int PESSystemStream::processStartCode(unsigned int startCode, + MpegSystemHeader* mpegHeader) { + int lok=true; + bytes_read=4; // startcode + mpegHeader->setPacketLen(0); + mpegHeader->setPacketID(_PAKET_ID_NUKE); + + // handle default + bytes_read=processPacket(startCode,mpegHeader); + return bytes_read; +} + + +/* Returns: + 0 - no error, but not video packet we want + -1 - error + >0 - length of packet +*/ +int PESSystemStream::processPacket(unsigned int startCode, + MpegSystemHeader* mpegHeader) { + + int ioBytes; + unsigned short packetLength; + int packetDataLength; + + /* Leftovers from previous video packets */ + + int packetID=startCode & 0xff; + mpegHeader->setPacketID(packetID); + int lPacket=startCode & _PACKET_START_CODE_MASK &_PACKET_START_CODE_PREFIX; + if ((lPacket == false) || (packetID < 0xbc)) { + //printf("unknown startcode,packet or packetID:%8x\n",startCode); + return false; + } + + if (packetID == _NOT_PACKET_ID) { + cout << "(vid_stream->mpegVideoStream)->makeEnd()"<<endl; + } else if (packetID==_KILL_BUFFER) { + printf("packetID==_KILL_BUFFER\n"); + } + + if (read((char*)&packetLength, 2) == false) return false; + packetLength = htons(packetLength); + + mpegHeader->setPTSFlag(false); + mpegHeader->setPacketID(packetID); + mpegHeader->setPESPacketLen(packetLength); + switch (packetID>>4) { + case _PAKET_ID_AUDIO_1>>4: + case _PAKET_ID_AUDIO_2>>4: + case _PAKET_ID_VIDEO>>4: + break; + default: + switch(packetID) { + case _PRIVATE_STREAM_1_ID: + break; + default: + switch (packetID) { + case _PRIVATE_STREAM_2_ID: + case _PADDING_STREAM_ID: + case _RESERVED_STREAM_ID: + case _ECM_STREAM_ID: + case _EMM_STREAM_ID: + case _PROGRAM_STREAM_DIRECTORY_ID: + case _DSMCC_STREAM_ID: + case _ITUTRECH222TYPEE_STREAM_ID: + return bytes_read; + } + printf("\nUnknown packet type. (%x) at %ld\n", + packetID,input->getBytePosition()); + return bytes_read; + } + } + // this is only processed if audio or video found + + if (mpegHeader->getMPEG2()==false) { + packetDataLength = packetLength-processPacketHeader(mpegHeader); + } else { + int len=processMPEG2PacketHeader(mpegHeader); + + if (len < 0) { + return false; + } + packetDataLength = packetLength-len; + + // now check in private stream for AC3 + if ( packetID == _PRIVATE_STREAM_1_ID ) { + packetDataLength = packetDataLength-processPrivateHeader(mpegHeader); + } + } + + if (packetDataLength <= 0) { + if (mpegHeader->hasPSHeader()) return false; + // -> buggy TS stream + packetDataLength=0; + } + mpegHeader->setPESPacketLen(packetDataLength); + + return bytes_read; + +} + + +int PESSystemStream::processPrivateHeader(MpegSystemHeader* mpegHeader) { + char nukeBuffer[30]; + int pos=0; + int one=getByteDirect(); + pos++; + mpegHeader->setSubStreamID(one); + switch(one>>4) { + case _SUBSTREAM_AC3_ID>>4: + if (read(nukeBuffer,3) == false) return false; + mpegHeader->addAvailableLayer(one); + cout << "addAvailableLayer:"<<one<<endl; + pos+=3; + break; + case _SUBSTREAM_LPCM_ID>>4: + if (read(nukeBuffer,6) == false) return false; + pos+=6; + break; + case _SUBSTREAM_SUBPIC_ID>>4: + if (read(nukeBuffer,3) == false) return false; + pos+=3; + break; + default: + printf("unknown sub id :%8x\n",one); + } + return pos; + +} + + +int PESSystemStream::processMPEG2PacketHeader(MpegSystemHeader* mpegHeader){ + + int stdCnt=0; + int pos=0; + + // 1. Byte + /* + FROM FLASK: + int getbits(2); + encrypted = getbits(2); // PES_scrambling_control + getbits(4); + //LIVID + u_char original_or_copy : 1; + u_char copyright : 1; + u_char data_alignment_indicator : 1; + u_char pes_priority : 1; + u_char pes_scrambling_control : 2; + u_char start_code_prefix : 2; // 0x02 + + */ + int first=getByteDirect(); + stdCnt++; + mpegHeader->setOriginalOrCopy(first&(128)>>7); + mpegHeader->setCopyRight(first&(64)>>6); + mpegHeader->setDataAlignmentIndicator(first&(32)>>5); + mpegHeader->setPesPriority(first&(16)>>4); + mpegHeader->setEncrypted((first&(8+4))>>2); + mpegHeader->setStartCodePrefix(first&(1+2)); + + + // 2. Byte + /* + PTS_DTS_flags = getbits(2); + ESCR_flag = get1bit(); + ES_rate_flag = get1bit(); + DSM_trick_mode_flag = get1bit(); + additional_copy_info_flag = get1bit(); + PES_CRC_flag = get1bit(); + PES_extension_flag = get1bit(); + */ + int second=getByteDirect(); + stdCnt++; + + mpegHeader->setPTSDTSFlag((second&(128+64))>>6); + mpegHeader->setESCRFlag((second&(32))>>5); + mpegHeader->setES_RATE_Flag((second%(16))>>4); + mpegHeader->setDMSTRICKFLAG((second&(8))>>3); + mpegHeader->setADDITIONAL_COPY_FLAG((second&(4))>>2); + mpegHeader->setPES_CRC_FLAG((second&(2))>>1); + mpegHeader->setPES_EXT_FLAG(second&(1)); + + + // 3. Byte + /* + PES_header_data_length = getbits(8); + */ + int third=getByteDirect(); + stdCnt++; + mpegHeader->setPES_HEADER_DATA_LENGTH(third); + + + // + // PARSING MPEG 2 HEADER FLAGS [START] + // + unsigned char nukeBuffer[300]; + + int PTS_DTS_flags=mpegHeader->getPTSDTSFlag(); + if (PTS_DTS_flags == 0) { + mpegHeader->setPTSFlag(false); + } else { + mpegHeader->setPTSFlag(true); + } + + if (PTS_DTS_flags > 0x1) { + if (read((char*)nukeBuffer,5) == false) return false; + double pts=GET_MPEG2_PTS(nukeBuffer); + pts=(pts*300.0)/(double)MPEG2_CLK_REF; + mpegHeader->setPTSTimeStamp(pts); + pos+=5; + } + if (PTS_DTS_flags > 0x2) { + if (read((char*)nukeBuffer,5) == false) return false; + double dts=GET_MPEG2_PTS(nukeBuffer); + mpegHeader->setDTSTimeStamp((dts*300.0)/(double)MPEG2_CLK_REF); + pos+=5; + } + + int ESCRFlag=mpegHeader->getESCRFlag(); + if (ESCRFlag == 1){ + cout << "ESCRFlag == 1"<<endl; + if (read((char*)nukeBuffer,6) == false) return false; + pos+=6; + } + + int ES_rate_flag=mpegHeader->getES_RATE_Flag(); + if (ES_rate_flag == 1){ + cout << "ES_rate_flag == 1"<<endl; + if (read((char*)nukeBuffer,3) == false) return false; + pos+=3; + } + + int DSM_trick_mode_flag=mpegHeader->getDMSTRICKFLAG(); + if (DSM_trick_mode_flag == 1){ + cout << "DSM_trick_mode_flag == 1"<<endl; + if (read((char*)nukeBuffer,1) == false) return false; + pos++; + } + + int additional_copy_info_flag=mpegHeader->getADDITIONAL_COPY_FLAG(); + if (additional_copy_info_flag == 1) { + cout << "additional_copy_info_flag == 1"<<endl; + if (read((char*)nukeBuffer,1) == false) return false; + pos++; + } + + int PES_CRC_flag=mpegHeader->getPES_CRC_FLAG(); + if (PES_CRC_flag == 1) { + cout << "PES_CRC_flag == 1"<<endl; + if (read((char*)nukeBuffer,2) == false) return false; + pos+=2; + } + + // + // PES Extension [START] + // + + int PES_extension_flag=mpegHeader->getPES_EXT_FLAG(); + if (PES_extension_flag == 1) { + /* + FLASK: + PES_private_data_flag = get1bit(); + pack_header_field_flag = get1bit(); + program_packet_sequence_counter_flag = get1bit(); + PSTD_buffer_flag = get1bit(); + getbits(3); + PES_extension_flag_2 = get1bit(); + */ + int extensionByte=getByteDirect(); + + pos++; + mpegHeader->setPrivateDataFlag((extensionByte&(128))>>7); + mpegHeader->setPackHeaderFieldFlag((extensionByte&(64))>>6); + mpegHeader->setSequenceCounterFlag((extensionByte&(32))>>5); + mpegHeader->setSTDBufferFlag((extensionByte&(16))>>4); + mpegHeader->setPES_EXT_FLAG_2(extensionByte&(1)); + + int PES_private_data_flag=mpegHeader->getPrivateDataFlag(); + if (PES_private_data_flag == 1) { + if (read((char*)nukeBuffer,128) == false) return false; + pos+=128; + } + + int pack_header_field_flag=mpegHeader->getPackHeaderFieldFlag(); + if (pack_header_field_flag == 1) { + printf("pack header field flag value not allowed in program streams\n"); + return false; + } + + int sequence_counter_flag=mpegHeader->getSequenceCounterFlag(); + if (sequence_counter_flag==1) { + cout<<"sequence_counter_flag ==1"<<endl; + if (read((char*)nukeBuffer,2) == false) return false; + pos+=2; + } + + int PSTD_buffer_flag=mpegHeader->getSTDBufferFlag(); + if (PSTD_buffer_flag==1) { + if (read((char*)nukeBuffer,2) == false) return false; + pos+=2; + } + + int PES_extension_flag_2=mpegHeader->getPES_EXT_FLAG_2(); + if (PES_extension_flag_2 == 1) { + int extension2_byte=getByteDirect(); + pos++; + mpegHeader->setPES_EXT_FIELD_LENGTH(extension2_byte&(254)); + + + int PES_field_length=mpegHeader->getPES_EXT_FIELD_LENGTH(); + int j; + for (j=0;j<PES_field_length ; j++) { + cout << "PES_field_length (nuke)"<<endl; + getByteDirect(); + pos++; + } + } + } + // + // PES Extension [END] + // + + // now nuke remaining bytes from PES DATA Length + int PES_HEADER_DATA_LENGTH=mpegHeader->getPES_HEADER_DATA_LENGTH(); + int tmp=PES_HEADER_DATA_LENGTH-pos; + if (tmp>0) { + if (read((char*)nukeBuffer,tmp) == false) return false; + pos+=tmp; + } + + + + + + // + // PARSING MPEG 2 HEADER FLAGS [START] + // + + int parsed=stdCnt+pos; + return parsed; + +} + + +int PESSystemStream::processPacketHeader(MpegSystemHeader* mpegHeader) { + unsigned char nextByte; + int pos; + int val; + unsigned char scratch[10]; + + + nextByte=getByteDirect(); + + mpegHeader->setPTSFlag(false); + + pos = 1; + while (nextByte & 0x80) { + ++pos; + val=getByteDirect(); + if (val == -1) return false; + scratch[0]=val; + + nextByte=scratch[0]; + } + if ((nextByte >> 6) == 0x01) { + pos += 2; + scratch[1]=getByteDirect(); + scratch[2]=getByteDirect(); + nextByte=scratch[2]; + } + if ((nextByte >> 4) == 0x02) { + scratch[0] = nextByte; + if (read((char*)&scratch[1],4) == false) return false; + /* presentation time stamps */ + unsigned char hiBit; + unsigned long low4Bytes; + double ptsTimeStamp; + double dtsTimeStamp=0.0; + readTimeStamp((unsigned char*)scratch,&hiBit,&low4Bytes); + makeClockTime(hiBit,low4Bytes,&ptsTimeStamp); + mpegHeader->setPTSFlag(true); + mpegHeader->setPTSTimeStamp(ptsTimeStamp); + mpegHeader->setDTSTimeStamp(dtsTimeStamp); + + pos += 4; + } + else if ((nextByte >> 4) == 0x03) { + scratch[0] = nextByte; + if (read((char*)&scratch[1],9) == false) return false; + /* presentation and decoding time stamps */ + unsigned char hiBit; + unsigned long low4Bytes; + double ptsTimeStamp; + double dtsTimeStamp; + readTimeStamp((unsigned char*)scratch,&hiBit,&low4Bytes); + makeClockTime(hiBit,low4Bytes,&ptsTimeStamp); + + readTimeStamp((unsigned char*)&(scratch[5]),&hiBit,&low4Bytes); + makeClockTime(hiBit,low4Bytes,&dtsTimeStamp); + mpegHeader->setPTSFlag(true); + mpegHeader->setPTSTimeStamp(ptsTimeStamp); + mpegHeader->setDTSTimeStamp(dtsTimeStamp); + + pos += 9; + } + return pos; +} + + + +void PESSystemStream::readTimeStamp(unsigned char* inputBuffer, + unsigned char* hiBit, + unsigned long* low4Bytes) { + *hiBit = ((unsigned long)inputBuffer[0] >> 3) & 0x01; + *low4Bytes = (((unsigned long)inputBuffer[0] >> 1) & 0x03) << 30; + *low4Bytes |= (unsigned long)inputBuffer[1] << 22; + *low4Bytes |= ((unsigned long)inputBuffer[2] >> 1) << 15; + *low4Bytes |= (unsigned long)inputBuffer[3] << 7; + *low4Bytes |= ((unsigned long)inputBuffer[4]) >> 1; +} + + +void PESSystemStream::readSTD(unsigned char* inputBuffer, + MpegSystemHeader* mpegHeader) { + int stdBufferScale; + unsigned long stdBufferSize; + stdBufferScale = ((int)(inputBuffer[0] & 0x20) >> 5); + stdBufferSize = ((unsigned long)inputBuffer[0] & 0x1f) << 8; + stdBufferSize |= (unsigned long)inputBuffer[1]; + mpegHeader->setStdBufferScale(stdBufferScale); + mpegHeader->setStdBufferSize(stdBufferSize); +} + + +int PESSystemStream::makeClockTime(unsigned char hiBit, + unsigned long low4Bytes, + double * clockTime) { + if (hiBit != 0 && hiBit != 1) { + *clockTime = 0.0; + return 1; + } + *clockTime = (double)hiBit*FLOAT_0x10000*FLOAT_0x10000 + (double)low4Bytes; + *clockTime /= (double)_STD_SYSTEM_CLOCK_FREQ; + return 0; +} + + + + |