/********** This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. (See .) This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA **********/ // "liveMedia" // Copyright (c) 1996-2020 Live Networks, Inc. All rights reserved. // A parser for a MPEG Transport Stream // Implementation #include "MPEG2TransportStreamParser.hh" #define NUM_PIDS 0x10000 StreamType StreamTypes[0x100]; MPEG2TransportStreamParser ::MPEG2TransportStreamParser(FramedSource* inputSource, FramedSource::onCloseFunc* onEndFunc, void* onEndClientData) : StreamParser(inputSource, onEndFunc, onEndClientData, continueParsing, this), fInputSource(inputSource), fAmCurrentlyParsing(False), fOnEndFunc(onEndFunc), fOnEndClientData(onEndClientData), fLastSeenPCR(0.0) { if (StreamTypes[0x01].dataType == StreamType::UNKNOWN) { // initialize array with known values StreamTypes[0x01] = StreamType("MPEG-1 video", StreamType::VIDEO, ".mpv"); StreamTypes[0x02] = StreamType("MPEG-2 video", StreamType::VIDEO, ".mpv"); StreamTypes[0x03] = StreamType("MPEG-1 audio", StreamType::AUDIO, ".mpa"); StreamTypes[0x04] = StreamType("MPEG-2 audio", StreamType::AUDIO, ".mpa"); StreamTypes[0x05] = StreamType("privately-defined data", StreamType::DATA); StreamTypes[0x06] = StreamType("privately-defined data", StreamType::DATA); StreamTypes[0x0F] = StreamType("AAC audio", StreamType::AUDIO, ".aac"); StreamTypes[0x10] = StreamType("MPEG-4 H.263 based video", StreamType::VIDEO, ".mpv"); StreamTypes[0x1B] = StreamType("H.264 video", StreamType::VIDEO, ".h264"); StreamTypes[0x1C] = StreamType("MPEG-4 raw audio", StreamType::AUDIO, ".mpa"); StreamTypes[0x1D] = StreamType("MPEG-4 text", StreamType::TEXT, ".txt"); StreamTypes[0x21] = StreamType("JPEG 2000 video", StreamType::VIDEO, ".mjpg"); StreamTypes[0x24] = StreamType("H.265 video", StreamType::VIDEO, ".h265"); StreamTypes[0x81] = StreamType("AC-3 audio", StreamType::AUDIO, ".ac3"); } // Create our 'PID state' array: fPIDState = new PIDState*[NUM_PIDS]; for (unsigned i = 0; i < NUM_PIDS; ++i) fPIDState[i] = NULL; // Initially, the only PID we know is 0x0000: a Program Association Table: fPIDState[0x0000] = new PIDState_PAT(*this, 0x0000); // Begin parsing: continueParsing(); } MPEG2TransportStreamParser::~MPEG2TransportStreamParser() { for (unsigned i = 0; i < NUM_PIDS; ++i) delete fPIDState[i]; delete[] fPIDState; } UsageEnvironment& MPEG2TransportStreamParser::envir() { return fInputSource->envir(); } void MPEG2TransportStreamParser ::continueParsing(void* clientData, unsigned char* ptr, unsigned size, struct timeval presentationTime) { ((MPEG2TransportStreamParser*)clientData)->continueParsing(); } void MPEG2TransportStreamParser::continueParsing() { if (fAmCurrentlyParsing) return; // don't allow recursive calls to parse() if (fInputSource != NULL) { fAmCurrentlyParsing = True; Boolean parseSucceeded = parse(); fAmCurrentlyParsing = False; if (!parseSucceeded) { // We didn't complete the parsing, because we had to read more data from the source, // or because we're waiting for another read from downstream. // Once that happens, we'll get called again. return; } } // We successfully parsed the file. Call our 'done' function now: if (fOnEndFunc != NULL) (*fOnEndFunc)(fOnEndClientData); } #define TRANSPORT_SYNC_BYTE 0x47 #define TRANSPORT_PACKET_SIZE 188 Boolean MPEG2TransportStreamParser::parse() { if (fInputSource->isCurrentlyAwaitingData()) return False; // Our input source is currently being read. Wait until that read completes try { while (1) { // Make sure we start with a 'sync byte': do { saveParserState(); } while (get1Byte() != TRANSPORT_SYNC_BYTE); // Parse and process each (remaining 187 bytes of a) 'Transport Stream Packet' at a time. // (Because these are a lot smaller than the "StreamParser" BANK_SIZE, we don't save // parser state in the middle of processing each such 'Transport Stream Packet'. // Therefore, processing of each 'Transport Stream Packet' needs to be idempotent.) u_int16_t flagsPlusPID = get2Bytes(); // Check the "transport_error_indicator" flag; reject the packet if it's set: if ((flagsPlusPID&0x8000) != 0) { #ifdef DEBUG_ERRORS fprintf(stderr, "MPEG2TransportStreamParser::parse() Rejected packet with \"transport_error_indicator\" flag set!\n"); #endif continue; } Boolean pusi = (flagsPlusPID&0x4000) != 0; // payload_unit_start_indicator // Ignore "transport_priority" u_int16_t PID = flagsPlusPID&0x1FFF; #ifdef DEBUG_CONTENTS fprintf(stderr, "\nTransport Packet: payload_unit_start_indicator: %d; PID: 0x%04x\n", pusi, PID); #endif u_int8_t controlPlusContinuity_counter = get1Byte(); // Reject any packets where the "transport_scrambling_control" field is not zero: if ((controlPlusContinuity_counter&0xC0) != 0) { #ifdef DEBUG_ERRORS fprintf(stderr, "MPEG2TransportStreamParser::parse() Rejected packet with \"transport_scrambling_control\" set to non-zero value %d!\n", (controlPlusContinuity_counter&0xC0)>>6); #endif continue; } u_int8_t adaptation_field_control = (controlPlusContinuity_counter&0x30)>>4; // 2 bits #ifdef DEBUG_CONTENTS u_int8_t continuity_counter = (controlPlusContinuity_counter&0x0F); // 4 bits fprintf(stderr, "adaptation_field_control: %d; continuity_counter: 0x%X\n", adaptation_field_control, continuity_counter); #endif u_int8_t totalAdaptationFieldSize = adaptation_field_control < 2 ? 0 : parseAdaptationField(); #ifdef DEBUG_ERRORS if (adaptation_field_control == 2 && totalAdaptationFieldSize != 1+183) { fprintf(stderr, "MPEG2TransportStreamParser::parse() Warning: Got an inconsistent \"totalAdaptationFieldSize\" %d for adaptation_field_control == 2\n", totalAdaptationFieldSize); } #endif int numDataBytes = TRANSPORT_PACKET_SIZE-4-totalAdaptationFieldSize; if (numDataBytes > 0) { #ifdef DEBUG_CONTENTS fprintf(stderr, "+%d data bytes:\n", numDataBytes); #endif if (!processDataBytes(PID, pusi, numDataBytes)) { // The parsing got deferred (to be resumed later when a pending read happens) restoreSavedParserState(); // so that we later resume parsing at the start of the packet return False; } } } } catch (int /*e*/) { #ifdef DEBUG_CONTENTS fprintf(stderr, "MPEG2TransportStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n"); #endif return False; // the parsing got interrupted } } u_int8_t MPEG2TransportStreamParser::parseAdaptationField() { unsigned startPos = curOffset(); #ifdef DEBUG_CONTENTS fprintf(stderr, "\tAdaptation Field:\n"); #endif u_int8_t adaptation_field_length = get1Byte(); #ifdef DEBUG_CONTENTS fprintf(stderr, "\t\tadaptation_field_length: %d\n", adaptation_field_length); #endif if (adaptation_field_length > 0) { u_int8_t flags = get1Byte(); #ifdef DEBUG_CONTENTS fprintf(stderr, "\t\tadaptation field flags: 0x%02x\n", flags); #endif if ((flags&0x10) != 0) { // PCR_flag u_int32_t first32PCRBits = get4Bytes(); u_int16_t last16PCRBits = get2Bytes(); // program_clock_reference_base = "first32PCRBits" and high bit of "last16PCRBits" (33 bits) // program_clock_reference_extension = last 9 bits of "last16PCRBits" (9 bits) double PCR = first32PCRBits/45000.0; if ((last16PCRBits&0x8000) != 0) PCR += 1/90000.0; // add in low-bit (if set) PCR += (last16PCRBits&0x01FF)/27000000.0; // add in extension #ifdef DEBUG_CONTENTS fprintf(stderr, "\t\tPCR: %.10f\n", PCR); #endif } if ((flags&0x08) != 0) { // OPCR_flag u_int32_t first32OPCRBits = get4Bytes(); u_int16_t last16OPCRBits = get2Bytes(); // original_program_clock_reference_base = "first32OPCRBits" and high bit of "last16OPCRBits" (33 bits) // original_program_clock_reference_extension = last 9 bits of "last16OPCRBits" (9 bits) double OPCR = first32OPCRBits/45000.0; if ((last16OPCRBits&0x8000) != 0) OPCR += 1/90000.0; // add in low-bit (if set) OPCR += (last16OPCRBits&0x01FF)/27000000.0; // add in extension #ifdef DEBUG_CONTENTS fprintf(stderr, "\t\tOPCR: %.10f\n", OPCR); #endif } if ((flags&0x04) != 0) { // splicing_point_flag skipBytes(1); // splice_countdown } if ((flags&0x02) != 0) { // transport_private_data_flag u_int8_t transport_private_data_length = get1Byte(); #ifdef DEBUG_CONTENTS fprintf(stderr, "\t\ttransport_private_data_length: %d\n", transport_private_data_length); #endif skipBytes(transport_private_data_length); // "private_data_byte"s } if ((flags&0x01) != 0) { // adaptation_field_extension_flag #ifdef DEBUG_CONTENTS u_int8_t adaptation_field_extension_length = get1Byte(); fprintf(stderr, "\t\tadaptation_field_extension_length: %d\n", adaptation_field_extension_length); #else skipBytes(1); // adaptation_field_extension_length #endif u_int8_t flagsPlusReserved = get1Byte(); #ifdef DEBUG_CONTENTS fprintf(stderr, "\t\t\tflagsPlusReserved: 0x%02x\n", flagsPlusReserved); #endif if ((flagsPlusReserved&0x80) != 0) { // ltw_flag skipBytes(2); // "ltw_valid_flag" + "ltw_offset" } if ((flagsPlusReserved&0x40) != 0) { // piecewise_rate_flag skipBytes(3); // reserved + "piecewise_rate" } if ((flagsPlusReserved&0x20) != 0) { // seamless_splice_flag skipBytes(5); // DTS_next_... } // Skip reserved bytes to the end of the adaptation_field: int numBytesLeft = (1 + adaptation_field_length) - (curOffset() - startPos); if (numBytesLeft > 0) { #ifdef DEBUG_CONTENTS fprintf(stderr, "\t\t+%d reserved bytes\n", numBytesLeft); #endif skipBytes(numBytesLeft); } } // Skip "stuffing_byte"s to the end of the adaptation_field: int numBytesLeft = (1 + adaptation_field_length) - (curOffset() - startPos); if (numBytesLeft > 0) { #ifdef DEBUG_CONTENTS fprintf(stderr, "\t\t+%d stuffing bytes\n", numBytesLeft); #endif #ifdef DEBUG_ERRORS for (int i = 0; i < numBytesLeft; ++i) { if (get1Byte() != 0xFF) { fprintf(stderr, "WARNING: non-stuffing byte in adaptation_field\n"); } } #else skipBytes(numBytesLeft); #endif } } // Finally, figure out how many bytes we parsed, and compare it to what we expected: unsigned totalAdaptationFieldSize = curOffset() - startPos; #ifdef DEBUG_ERRORS if (totalAdaptationFieldSize != 1 + adaptation_field_length) { fprintf(stderr, "MPEG2TransportStreamParser::parseAdaptationField() Warning: Got an inconsistent \"totalAdaptationFieldSize\" %d; expected %d\n", totalAdaptationFieldSize, 1 + adaptation_field_length); } #endif return totalAdaptationFieldSize; } Boolean MPEG2TransportStreamParser ::processDataBytes(u_int16_t PID, Boolean pusi, unsigned numDataBytes) { PIDState* pidState = fPIDState[PID]; if (pidState == NULL) { // unknown PID #ifdef DEBUG_CONTENTS fprintf(stderr, "\tUnknown PID\n"); #endif skipBytes(numDataBytes); return True; } switch (pidState->type) { case PAT: { parsePAT(pusi, numDataBytes); return True; } case PMT: { parsePMT((PIDState_PMT*)pidState, pusi, numDataBytes); return True; } case STREAM: { return processStreamPacket((PIDState_STREAM*)pidState, pusi, numDataBytes); } default: { // Never reached, but eliminates a possible error with dumb compilers return False; } } } void MPEG2TransportStreamParser::restoreSavedParserState() { StreamParser::restoreSavedParserState(); fAmCurrentlyParsing = False; } //########## PIDState implementation ########## PIDState::PIDState(MPEG2TransportStreamParser& parser, u_int16_t pid, PIDType pidType) : ourParser(parser), PID(pid), type(pidType) { } PIDState::~PIDState() { } //######### StreamType implementation ######## StreamType ::StreamType(char const* description, enum dataType dataType, char const* filenameSuffix) : description(description), dataType(dataType), filenameSuffix(filenameSuffix) { }