/**********
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 <http://www.gnu.org/copyleft/lesser.html>.)

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) {
}