liveMedia/H263plusVideoStreamParser.cpp

Go to the documentation of this file.

/**********
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 2.1 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-2012 Live Networks, Inc.  All rights reserved.
// Author Bernhard Feiten
// A filter that breaks up an H.263plus video stream into frames.
// Based on MPEG4IP/mp4creator/h263.c

#include "H263plusVideoStreamParser.hh"
#include "H263plusVideoStreamFramer.hh"
//#include <string.h>
//#include "GroupsockHelper.hh"


H263plusVideoStreamParser::H263plusVideoStreamParser(
                              H263plusVideoStreamFramer* usingSource,
                              FramedSource* inputSource)
                              : StreamParser(inputSource,
                                   FramedSource::handleClosure,
                                   usingSource,
                                   &H263plusVideoStreamFramer::continueReadProcessing,
                                   usingSource),
                                fUsingSource(usingSource),
                                fnextTR(0),
                                fcurrentPT(0)
{
   memset(fStates, 0, sizeof(fStates));
   memset(&fNextInfo, 0, sizeof(fNextInfo));
   memset(&fCurrentInfo, 0, sizeof(fCurrentInfo));
   memset(&fMaxBitrateCtx, 0, sizeof(fMaxBitrateCtx));
   memset(fNextHeader,0, H263_REQUIRE_HEADER_SIZE_BYTES);
}

H263plusVideoStreamParser::~H263plusVideoStreamParser()
{
}

void H263plusVideoStreamParser::restoreSavedParserState()
{
   StreamParser::restoreSavedParserState();
   fTo = fSavedTo;
   fNumTruncatedBytes = fSavedNumTruncatedBytes;
}

void H263plusVideoStreamParser::setParseState()
{
   fSavedTo = fTo;
   fSavedNumTruncatedBytes = fNumTruncatedBytes;
   saveParserState();  // Needed for the parsing process in StreamParser
}


void H263plusVideoStreamParser::registerReadInterest(
                                   unsigned char* to,
                                   unsigned maxSize)
{
   fStartOfFrame = fTo = fSavedTo = to;
   fLimit = to + maxSize;
   fMaxSize = maxSize;
   fNumTruncatedBytes = fSavedNumTruncatedBytes = 0;
}

// parse() ,  derived from H263Creator of MPEG4IP, h263.c
unsigned H263plusVideoStreamParser::parse(u_int64_t & currentDuration)
{

//   u_int8_t       frameBuffer[H263_BUFFER_SIZE]; // The input buffer
                 // Pointer which tells LoadNextH263Object where to read data to
//   u_int8_t*      pFrameBuffer = fTo + H263_REQUIRE_HEADER_SIZE_BYTES;
   u_int32_t      frameSize;        // The current frame size
                                // Pointer to receive address of the header data
//   u_int8_t*      pCurrentHeader;// = pFrameBuffer;
//   u_int64_t      currentDuration;  // The current frame's duration
   u_int8_t       trDifference;     // The current TR difference
                                   // The previous TR difference
//   u_int8_t       prevTrDifference = H263_BASIC_FRAME_RATE;
//   u_int64_t      totalDuration = 0;// Duration accumulator
//   u_int64_t      avgBitrate;       // Average bitrate
//   u_int64_t      totalBytes = 0;   // Size accumulator


   try    // The get data routines of the class FramedFilter returns an error when
   {      // the buffer is empty. This occurs at the beginning and at the end of the file.
      fCurrentInfo = fNextInfo;

      // Parse 1 frame
      // For the first time, only the first frame's header is returned.
      // The second time the full first frame is returned
      frameSize = parseH263Frame();

      currentDuration = 0;
      if ((frameSize > 0)){
         // We were able to acquire a frame from the input.

         // Parse the returned frame header (if any)
         if (!ParseShortHeader(fTo, &fNextInfo)) {
#ifdef DEBUG
           fprintf(stderr,"H263plusVideoStreamParser: Fatal error\n");
#endif
         }

         trDifference = GetTRDifference(fNextInfo.tr, fCurrentInfo.tr);

         // calculate the current frame duration
         currentDuration = CalculateDuration(trDifference);

         // Accumulate the frame's size and duration for avgBitrate calculation
         //totalDuration += currentDuration;
         //totalBytes += frameSize;
         //  If needed, recalculate bitrate information
         //    if (h263Bitrates)
         //GetMaxBitrate(&fMaxBitrateCtx, frameSize, prevTrDifference);
         //prevTrDifference = trDifference;

         setParseState(); // Needed for the parsing process in StreamParser
      }
   } catch (int /*e*/) {
#ifdef DEBUG
      fprintf(stderr, "H263plusVideoStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
#endif
      frameSize=0;
   }

   return frameSize;
}


// parseH263Frame derived from LoadNextH263Object of MPEG4IP
// - service routine that reads a single frame from the input file.
// It shall fill the input buffer with data up until - and including - the
// next start code and shall report back both the number of bytes read and a
// pointer to the next start code. The first call to this function shall only
// yield a pointer with 0 data bytes and the last call to this function shall
// only yield data bytes with a NULL pointer as the next header.
//
// TODO: This function only supports valid bit streams. Upon error, it fails
// without the possibility to recover. A Better idea would be to skip frames
// until a parsable frame is read from the file.
//
// Parameters:
//      ppNextHeader - output parameter that upon return points to the location
//                     of the next frame's head in the buffer.
//                     This pointer shall be NULL for the last frame read.
// Returns the total number of bytes read.
// Uses FrameFileSource intantiated by constructor.
int H263plusVideoStreamParser::parseH263Frame( )
{
   char     row = 0;
   u_int8_t * bufferIndex = fTo;
   // The buffer end which will allow the loop to leave place for
   // the additionalBytesNeeded
   u_int8_t * bufferEnd = fTo + fMaxSize - ADDITIONAL_BYTES_NEEDED - 1;

   memcpy(fTo, fNextHeader, H263_REQUIRE_HEADER_SIZE_BYTES);
   bufferIndex += H263_REQUIRE_HEADER_SIZE_BYTES;


   // The state table and the following loop implements a state machine enabling
   // us to read bytes from the file until (and inclusing) the requested
   // start code (00 00 8X) is found

   // Initialize the states array, if it hasn't been initialized yet...
   if (!fStates[0][0]) {
      // One 00 was read
      fStates[0][0] = 1;
      // Two sequential 0x00 ware read
      fStates[1][0] = fStates[2][0] = 2;
      // A full start code was read
      fStates[2][128] = fStates[2][129] = fStates[2][130] = fStates[2][131] = -1;
   }

   // Read data from file into the output buffer until either a start code
   // is found, or the end of file has been reached.
   do {
      *bufferIndex = get1Byte();
   } while ((bufferIndex < bufferEnd) &&                    // We have place in the buffer
            ((row = fStates[(unsigned char)row][*(bufferIndex++)]) != -1)); // Start code was not found

   if (row != -1) {
      fprintf(stderr, "%s: Buffer too small (%u)\n",
         "h263reader:", bufferEnd - fTo + ADDITIONAL_BYTES_NEEDED);
      return 0;
   }

   // Cool ... now we have a start code
   // Now we just have to read the additionalBytesNeeded
   getBytes(bufferIndex, ADDITIONAL_BYTES_NEEDED);
   memcpy(fNextHeader, bufferIndex - H263_STARTCODE_SIZE_BYTES, H263_REQUIRE_HEADER_SIZE_BYTES);

        int sz = bufferIndex - fTo - H263_STARTCODE_SIZE_BYTES;

   if (sz == 5) // first frame
      memcpy(fTo, fTo+H263_REQUIRE_HEADER_SIZE_BYTES, H263_REQUIRE_HEADER_SIZE_BYTES);

   return sz;
}


// ParseShortHeader - service routine that accepts a buffer containing a frame
// header and extracts relevant codec information from it.
//
// NOTE: the first bit in the following commnets is 0 (zero).
//
//       0                   1                   2                   3
//       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
//      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//      |      PSC (Picture Start Code=22 bits)     |  (TR=8 bits)  |   >
//      |0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0|               |1 0>
//      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//      <   (PTYPE=13 bits)   |
//      <. . .|(FMT)|Z|. . . .|
//      +-+-+-+-+-+-+-+-+-+-+-+
//      -> PTYPE.FMT contains a width/height identification
//      -> PTYPE.Z   is 1 for P-Frames, 0 for I-Frames
//      Note: When FMT is 111, there is an extended PTYPE...
//
// Inputs:
//      headerBuffer - pointer to the current header buffer
//      outputInfoStruct - pointer to the structure receiving the data
// Outputs:
//      This function returns a structure of important codec-specific
//      information (The Temporal Reference bits, width & height of the current
//      frame and the sync - or "frame type" - bit. It reports success or
//      failure to the calling function.
bool H263plusVideoStreamParser::ParseShortHeader(
                                   u_int8_t *headerBuffer,
                                   H263INFO *outputInfoStruct)
{
   u_int8_t fmt = 0;
   // Extract temporal reference (TR) from the buffer (bits 22-29 inclusive)
   outputInfoStruct->tr  = (headerBuffer[2] << 6) & 0xC0; // 2 LS bits out of the 3rd byte
   outputInfoStruct->tr |= (headerBuffer[3] >> 2) & 0x3F; // 6 MS bits out of the 4th byte
   // Extract the FMT part of PTYPE from the buffer (bits 35-37 inclusive)
   fmt = (headerBuffer[4] >> 2) & 0x07; // bits 3-5 ouf of the 5th byte
   // If PTYPE is not supported, return a failure notice to the calling function
   // FIXME: PLUSPTYPE is not supported
   if (fmt == 0x07) {
      return false;
   }
   // If PTYPE is supported, calculate the current width and height according to
   // a predefined table
   if (!GetWidthAndHeight(fmt, &(outputInfoStruct->width),
                               &(outputInfoStruct->height))) {
      return false;
   }
   // Extract the frame-type bit, which is the 9th bit of PTYPE (bit 38)
   outputInfoStruct->isSyncFrame = !(headerBuffer[4] & 0x02);

  return true;
}

// GetMaxBitrate- service routine that accepts frame information and
// derives bitrate information from it. This function uses a sliding window
// technique to calculate the maximum bitrates in any window of 1 second
// inside the file.
// The sliding window is implemented with a table of bitrates for the last
// second (30 entries - one entry per TR unit).
//
// Inputs:
//      ctx - context for this function
//      frameSize - the size of the current frame in bytes
//      frameTRDiff - the "duration" of the frame in TR units
// Outputs:
//      This function returns the up-to-date maximum bitrate
void H263plusVideoStreamParser::GetMaxBitrate( MaxBitrate_CTX *ctx,
                                               u_int32_t      frameSize,
                                               u_int8_t       frameTRDiff)
{
   if (frameTRDiff == 0)
      return;

   // Calculate the current frame's bitrate as bits per TR unit (round the result
   // upwards)
   u_int32_t frameBitrate = frameSize * 8 / frameTRDiff + 1;

   // for each TRdiff received,
   while (frameTRDiff--) {
      // Subtract the oldest bitrate entry from the current bitrate
      ctx->windowBitrate -= ctx->bitrateTable[ctx->tableIndex];
      // Update the oldest bitrate entry with the current frame's bitrate
      ctx->bitrateTable[ctx->tableIndex] = frameBitrate;
      // Add the current frame's bitrate to the current bitrate
      ctx->windowBitrate += frameBitrate;
      // Check if we have a new maximum bitrate
      if (ctx->windowBitrate > ctx->maxBitrate) {
         ctx->maxBitrate = ctx->windowBitrate;
          }
      // Advance the table index
      // Wrapping around the bitrateTable size
      ctx->tableIndex = (ctx->tableIndex + 1) %
        ( sizeof(ctx->bitrateTable) / sizeof(ctx->bitrateTable[0]) );
   }
}

// CalculateDuration - service routine that calculates the current frame's
// duration in milli-seconds using it's duration in TR units.
//  - In order not to accumulate the calculation error, we are using the TR
// duration to calculate the current and the next frame's presentation time in
// milli-seconds.
//
// Inputs: trDiff - The current frame's duration in TR units
// Return: The current frame's duration in milli-seconds
u_int64_t H263plusVideoStreamParser::CalculateDuration(u_int8_t trDiff)
{
  u_int64_t        nextPT;          // The next frame's presentation time in milli-seconds
  u_int64_t        duration;        // The current frame's duration in milli-seconds

  fnextTR += trDiff;
  // Calculate the next frame's presentation time, in milli-seconds
  nextPT = (fnextTR * 1001) / H263_BASIC_FRAME_RATE;
  // The frame's duration is the difference between the next presentation
  // time and the current presentation time.
  duration = nextPT - fcurrentPT;
  // "Remember" the next presentation time for the next time this function is called
  fcurrentPT = nextPT;

  return duration;
}

bool H263plusVideoStreamParser::GetWidthAndHeight( u_int8_t  fmt,
                                                   u_int16_t *width,
                                                   u_int16_t *height)
{
   // The 'fmt' corresponds to bits 5-7 of the PTYPE
  static struct {
      u_int16_t width;
      u_int16_t height;
   } const dimensionsTable[8] = {
           { 0,    0 },      // 000 - 0 - forbidden, generates an error
           { 128,  96 },     // 001 - 1 - Sub QCIF
           { 176,  144 },    // 010 - 2 - QCIF
           { 352,  288 },    // 011 - 3 - CIF
           { 704,  576 },    // 100 - 4 - 4CIF
           { 1409, 1152 },   // 101 - 5 - 16CIF
           { 0,    0 },      // 110 - 6 - reserved, generates an error
           { 0,    0 }       // 111 - 7 - extended, not supported by profile 0
   };

   if (fmt > 7)
      return false;

   *width  = dimensionsTable[fmt].width;
   *height = dimensionsTable[fmt].height;

   if (*width  == 0)
     return false;

   return true;
}

u_int8_t H263plusVideoStreamParser::GetTRDifference(
                                              u_int8_t nextTR,
                                              u_int8_t currentTR)
{
   if (currentTR > nextTR) {
      // Wrap around 255...
      return nextTR + (256 - currentTR);
   } else {
      return nextTR - currentTR;
   }
}







// this is the h263.c file of MPEG4IP mp4creator
/*
#include "mp4creator.h"

// Default timescale for H.263 (1000ms)
#define H263_TIMESCALE 1000
// Default H263 frame rate (30fps)
#define H263_BASIC_FRAME_RATE 30

// Minimum number of bytes needed to parse an H263 header
#define H263_REQUIRE_HEADER_SIZE_BYTES 5
// Number of bytes the start code requries
#define H263_STARTCODE_SIZE_BYTES 3
// This is the input buffer's size. It should contain
// 1 frame with the following start code
#define H263_BUFFER_SIZE 256 * 1024
// The default max different (in %) betwqeen max and average bitrates
#define H263_DEFAULT_CBR_TOLERANCE  10

// The following structure holds information extracted from each frame's header:
typedef struct _H263INFO {
  u_int8_t  tr;                 // Temporal Reference, used in duration calculation
  u_int16_t width;              // Width of the picture
  u_int16_t height;             // Height of the picture
  bool      isSyncFrame;        // Frame type (true = I frame = "sync" frame)
} H263INFO;

// Context for the GetMaxBitrate function
typedef struct _MaxBitrate_CTX {
  u_int32_t  bitrateTable[H263_BASIC_FRAME_RATE];// Window of 1 second
  u_int32_t  windowBitrate;              // The bitrate of the current window
  u_int32_t  maxBitrate;                 // The up-to-date maximum bitrate
  u_int32_t  tableIndex;                 // The next TR unit to update
} MaxBitrate_CTX;

// Forward declarations:
static int LoadNextH263Object(  FILE           *inputFileHandle,
                                u_int8_t       *frameBuffer,
                                u_int32_t      *frameBufferSize,
                                u_int32_t       additionalBytesNeeded,
                                u_int8_t      **ppNextHeader);

static bool ParseShortHeader(   u_int8_t       *headerBuffer,
                                H263INFO       *outputInfoStruct);

static u_int8_t GetTRDifference(u_int8_t        nextTR,
                                u_int8_t        currentTR);

static void GetMaxBitrate(      MaxBitrate_CTX *ctx,
                                u_int32_t       frameSize,
                                u_int8_t        frameTRDiff);

static MP4Duration CalculateDuration(u_int8_t   trDiff);

static bool GetWidthAndHeight(  u_int8_t        fmt,
                                u_int16_t      *width,
                                u_int16_t      *height);

static char   states[3][256];
/ *
 * H263Creator - Main function
 * Inputs:
 *      outputFileHandle - The handle of the output file
 *      inputFileHandle - The handle of the input file
 *      Codec-specific parameters:
 *              H263Level - H.263 Level used for this track
 *              H263Profile - H.263 Profile used for this track
 *              H263Bitrates - A Parameter indicating whether the function
 *                             should calculate H263 bitrates or not.
 *              cbrTolerance - CBR tolerance indicates when to set the
 *                             average bitrate.
 * Outputs:
 *      This function returns either the track ID of the newly added track upon
 *      success or a predefined value representing an erroneous state.
 * /
MP4TrackId H263Creator(MP4FileHandle outputFileHandle,
                       FILE*         inputFileHandle,
                       u_int8_t      h263Profile,
                       u_int8_t      h263Level,
                       bool          h263Bitrates,
                       u_int8_t      cbrTolerance)
{
  H263INFO       nextInfo;   // Holds information about the next frame
  H263INFO       currentInfo;// Holds information about the current frame
  MaxBitrate_CTX maxBitrateCtx;// Context for the GetMaxBitrate function
  memset(&nextInfo, 0, sizeof(nextInfo));
  memset(&currentInfo, 0, sizeof(currentInfo));
  memset(&maxBitrateCtx, 0, sizeof(maxBitrateCtx));
  memset(states, 0, sizeof(states));
  u_int8_t       frameBuffer[H263_BUFFER_SIZE]; // The input buffer
                 // Pointer which tells LoadNextH263Object where to read data to
  u_int8_t*      pFrameBuffer = frameBuffer + H263_REQUIRE_HEADER_SIZE_BYTES;
  u_int32_t      frameSize;        // The current frame size
                                // Pointer to receive address of the header data
  u_int8_t*      pCurrentHeader = pFrameBuffer;
  MP4Duration    currentDuration;  // The current frame's duration
  u_int8_t       trDifference;     // The current TR difference
                                   // The previous TR difference
  u_int8_t       prevTrDifference = H263_BASIC_FRAME_RATE;
  MP4Duration    totalDuration = 0;// Duration accumulator
  MP4Duration    avgBitrate;       // Average bitrate
  u_int64_t      totalBytes = 0;   // Size accumulator
  MP4TrackId     trackId = MP4_INVALID_TRACK_ID; // Our MP4 track
  bool           stay = true;      // loop flag

  while (stay) {
    currentInfo = nextInfo;
    memmove(frameBuffer, pCurrentHeader, H263_REQUIRE_HEADER_SIZE_BYTES);
    frameSize = H263_BUFFER_SIZE - H263_REQUIRE_HEADER_SIZE_BYTES;
    // Read 1 frame and the next frame's header from the file.
    // For the first frame, only the first frame's header is returned.
    // For the last frame, only the last frame's data is returned.
    if (! LoadNextH263Object(inputFileHandle, pFrameBuffer, &frameSize,
          H263_REQUIRE_HEADER_SIZE_BYTES - H263_STARTCODE_SIZE_BYTES,
          &pCurrentHeader))
      break; // Fatal error ...

    if (pCurrentHeader) {
      // Parse the returned frame header (if any)
      if (!ParseShortHeader(pCurrentHeader, &nextInfo))
        break; // Fatal error
      trDifference = GetTRDifference(nextInfo.tr, currentInfo.tr);
    } else {
      // This is the last frame ... we have to fake the trDifference ...
      trDifference = 1;
      // No header data has been read at this iteration, so we have to manually
      // add the frame's header we read at the previous iteration.
      // Note that LoadNextH263Object returns the number of bytes read, which
      // are the current frame's data and the next frame's header
      frameSize += H263_REQUIRE_HEADER_SIZE_BYTES;
      // There is no need for the next iteration ...
      stay = false;
    }

    // If this is the first iteration ...
    if (currentInfo.width == 0) {
      // If we have more data than just the header
      if ((frameSize > H263_REQUIRE_HEADER_SIZE_BYTES) ||
          !pCurrentHeader)  // Or no header at all
        break;     // Fatal error
      else
        continue;  // We have only the first frame's header ...
    }

    if (trackId == MP4_INVALID_TRACK_ID) {
      //  If a track has not been added yet, add the track to the file.
      trackId = MP4AddH263VideoTrack(outputFileHandle, H263_TIMESCALE,
          0, currentInfo.width, currentInfo.height,
          h263Level, h263Profile, 0, 0);
      if (trackId == MP4_INVALID_TRACK_ID)
        break; // Fatal error
    }

    // calculate the current frame duration
    currentDuration = CalculateDuration(trDifference);
    // Write the current frame to the file.
    if (!MP4WriteSample(outputFileHandle, trackId, frameBuffer, frameSize,
          currentDuration, 0, currentInfo.isSyncFrame))
      break; // Fatal error

    // Accumulate the frame's size and duration for avgBitrate calculation
    totalDuration += currentDuration;
    totalBytes += frameSize;
    //  If needed, recalculate bitrate information
    if (h263Bitrates)
      GetMaxBitrate(&maxBitrateCtx, frameSize, prevTrDifference);
    prevTrDifference = trDifference;
  } // while (stay)

  // If this is the last frame,
  if (!stay) {
    // If needed and possible, update bitrate information in the file
    if (h263Bitrates && totalDuration) {
      avgBitrate = (totalBytes * 8 * H263_TIMESCALE) / totalDuration;
      if (cbrTolerance == 0)
        cbrTolerance = H263_DEFAULT_CBR_TOLERANCE;
      // Same as: if (maxBitrate / avgBitrate > (cbrTolerance + 100) / 100.0)
      if (maxBitrateCtx.maxBitrate * 100 > (cbrTolerance + 100) * avgBitrate)
        avgBitrate = 0;
      MP4SetH263Bitrates(outputFileHandle, trackId,
          avgBitrate, maxBitrateCtx.maxBitrate);
    }
    // Return the newly added track ID
    return trackId;
  }

  // If we got to here... something went wrong ...
  fprintf(stderr,
    "%s: Could not parse input file, invalid video stream?\n", ProgName);
  // Upon failure, delete the newly added track if it has been added
  if (trackId != MP4_INVALID_TRACK_ID) {
    MP4DeleteTrack(outputFileHandle, trackId);
  }
  return MP4_INVALID_TRACK_ID;
}

/ *
 * LoadNextH263Object - service routine that reads a single frame from the input
 * file. It shall fill the input buffer with data up until - and including - the
 * next start code and shall report back both the number of bytes read and a
 * pointer to the next start code. The first call to this function shall only
 * yield a pointer with 0 data bytes and the last call to this function shall
 * only yield data bytes with a NULL pointer as the next header.
 *
 * TODO: This function only supports valid bit streams. Upon error, it fails
 * without the possibility to recover. A Better idea would be to skip frames
 * until a parsable frame is read from the file.
 *
 * Parameters:
 *      inputFileHandle - The handle of the input file
 *      frameBuffer - buffer where to place read data
 *      frameBufferSize - in/out parameter indicating the size of the buffer on
 *                          entry and the number of bytes copied to the buffer upon
 *                          return
 *      additionalBytesNeeded - indicates how many additional bytes are to be read
 *                          from the next frame's header (over the 3 bytes that
 *                          are already read).
 *                          NOTE: This number MUST be > 0
 *      ppNextHeader - output parameter that upon return points to the location
 *                     of the next frame's head in the buffer
 * Outputs:
 *      This function returns two pieces of information:
 *      1. The total number of bytes read.
 *      2. A Pointer to the header of the next frame. This pointer shall be NULL
 *      for the last frame read.
 * /
static int LoadNextH263Object(  FILE           *inputFileHandle,
                                u_int8_t       *frameBuffer,
                                u_int32_t      *frameBufferSize,
                                u_int32_t       additionalBytesNeeded,
                                u_int8_t      **ppNextHeader)
{
  // This table and the following loop implements a state machine enabling
  // us to read bytes from the file untill (and inclusing) the requested
  // start code (00 00 8X) is found
  int8_t        row = 0;
  u_int8_t     *bufferStart = frameBuffer;
  // The buffer end which will allow the loop to leave place for
  // the additionalBytesNeeded
  u_int8_t     *bufferEnd = frameBuffer + *frameBufferSize -
                                              additionalBytesNeeded - 1;

  // Initialize the states array, if it hasn't been initialized yet...
  if (!states[0][0]) {
    // One 00 was read
    states[0][0] = 1;
    // Two sequential 0x00 ware read
    states[1][0] = states[2][0] = 2;
    // A full start code was read
    states[2][128] = states[2][129] = states[2][130] = states[2][131] = -1;
  }

  // Read data from file into the output buffer until either a start code
  // is found, or the end of file has been reached.
  do {
    if (fread(frameBuffer, 1, 1, inputFileHandle) != 1){
      // EOF or other error before we got a start code
      *ppNextHeader = NULL;
      *frameBufferSize = frameBuffer - bufferStart;
      return 1;
    }
  } while ((frameBuffer < bufferEnd) &&                    // We have place in the buffer
           ((row = states[row][*(frameBuffer++)]) != -1)); // Start code was not found
  if (row != -1) {
    fprintf(stderr, "%s: Buffer too small (%u)\n",
            ProgName, bufferEnd - bufferStart + additionalBytesNeeded);
    return 0;
  }

  // Cool ... now we have a start code
  *ppNextHeader = frameBuffer - H263_STARTCODE_SIZE_BYTES;
  *frameBufferSize = frameBuffer - bufferStart + additionalBytesNeeded;

  // Now we just have to read the additionalBytesNeeded
  if(fread(frameBuffer, additionalBytesNeeded, 1, inputFileHandle) != 1) {
    fprintf(stderr, "%s: Invalid H263 bitstream\n", ProgName);
    return 0;
  }

  return 1;
}


/ *
 * ParseShortHeader - service routine that accepts a buffer containing a frame
 * header and extracts relevant codec information from it.
 *
 * NOTE: the first bit in the following commnets is 0 (zero).
 *
 *
 *       0                   1                   2                   3
 *       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *      |      PSC (Picture Start Code=22 bits)     |  (TR=8 bits)  |   >
 *      |0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0|               |1 0>
 *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *      <   (PTYPE=13 bits)   |
 *      <. . .|(FMT)|Z|. . . .|
 *      +-+-+-+-+-+-+-+-+-+-+-+
 *      -> PTYPE.FMT contains a width/height identification
 *      -> PTYPE.Z   is 1 for P-Frames, 0 for I-Frames
 *      Note: When FMT is 111, there is an extended PTYPE...
 *
 * Inputs:
 *      headerBuffer - pointer to the current header buffer
 *      outputInfoStruct - pointer to the structure receiving the data
 * Outputs:
 *      This function returns a structure of important codec-specific
 *      information (The Temporal Reference bits, width & height of the current
 *      frame and the sync - or "frame type" - bit. It reports success or
 *      failure to the calling function.
 * /
static bool ParseShortHeader(   u_int8_t       *headerBuffer,
                                H263INFO       *outputInfoStruct)
{
  u_int8_t fmt = 0;
  // Extract temporal reference (TR) from the buffer (bits 22-29 inclusive)
  outputInfoStruct->tr  = (headerBuffer[2] << 6) & 0xC0; // 2 LS bits out of the 3rd byte
  outputInfoStruct->tr |= (headerBuffer[3] >> 2) & 0x3F; // 6 MS bits out of the 4th byte
  // Extract the FMT part of PTYPE from the buffer (bits 35-37 inclusive)
  fmt = (headerBuffer[4] >> 2) & 0x07; // bits 3-5 ouf of the 5th byte
  // If PTYPE is not supported, return a failure notice to the calling function
  // FIXME: PLUSPTYPE is not supported
   if (fmt == 0x07) {
    return false;
  }
  // If PTYPE is supported, calculate the current width and height according to
  // a predefined table
  if (!GetWidthAndHeight(fmt, &(outputInfoStruct->width),
                              &(outputInfoStruct->height))) {
    return false;
  }
  // Extract the frame-type bit, which is the 9th bit of PTYPE (bit 38)
  outputInfoStruct->isSyncFrame = !(headerBuffer[4] & 0x02);

  return true;
}

/ *
 * GetMaxBitrate- service routine that accepts frame information and
 * derives bitrate information from it. This function uses a sliding window
 * technique to calculate the maximum bitrates in any window of 1 second
 * inside the file.
 * The sliding window is implemented with a table of bitrates for the last
 * second (30 entries - one entry per TR unit).
 *
 * Inputs:
 *      ctx - context for this function
 *      frameSize - the size of the current frame in bytes
 *      frameTRDiff - the "duration" of the frame in TR units
 * Outputs:
 *      This function returns the up-to-date maximum bitrate
 * /
static void GetMaxBitrate(      MaxBitrate_CTX *ctx,
                                u_int32_t       frameSize,
                                u_int8_t        frameTRDiff)
{
  if (frameTRDiff == 0)
    return;

  // Calculate the current frame's bitrate as bits per TR unit (round the result
  // upwards)
  u_int32_t frameBitrate = frameSize * 8 / frameTRDiff + 1;

  // for each TRdiff received,
  while (frameTRDiff--) {
    // Subtract the oldest bitrate entry from the current bitrate
    ctx->windowBitrate -= ctx->bitrateTable[ctx->tableIndex];
     // Update the oldest bitrate entry with the current frame's bitrate
    ctx->bitrateTable[ctx->tableIndex] = frameBitrate;
    // Add the current frame's bitrate to the current bitrate
    ctx->windowBitrate += frameBitrate;
    // Check if we have a new maximum bitrate
    if (ctx->windowBitrate > ctx->maxBitrate) {
      ctx->maxBitrate = ctx->windowBitrate;
    }
    // Advance the table index
    ctx->tableIndex = (ctx->tableIndex + 1) %
        // Wrapping around the bitrateTable size
        ( sizeof(ctx->bitrateTable) / sizeof(ctx->bitrateTable[0]) );
  }
}

/ *
 * CalculateDuration - service routine that calculates the current frame's
 * duration in milli-seconds using it's duration in TR units.
 *  - In order not to accumulate the calculation error, we are using the TR
 * duration to calculate the current and the next frame's presentation time in
 * milli-seconds.
 *
 * Inputs:
 *      trDiff - The current frame's duration in TR units
 * Outputs:
 *      The current frame's duration in milli-seconds
 * /
static MP4Duration CalculateDuration(u_int8_t   trDiff)
{
  static u_int32_t const    nextTR    = 0;   // The next frame's presentation time in TR units
  static MP4Duration const  currentPT = 0;   // The current frame's presentation time in milli-seconds
  MP4Duration         nextPT;          // The next frame's presentation time in milli-seconds
  MP4Duration         duration;        // The current frame's duration in milli-seconds

  nextTR += trDiff;
  // Calculate the next frame's presentation time, in milli-seconds
  nextPT = (nextTR * 1001) / H263_BASIC_FRAME_RATE;
  // The frame's duration is the difference between the next presentation
  // time and the current presentation time.
  duration = nextPT - currentPT;
  // "Remember" the next presentation time for the next time this function is
  // called
  currentPT = nextPT;

  return duration;
}

static bool GetWidthAndHeight(  u_int8_t        fmt,
                                u_int16_t      *width,
                                u_int16_t      *height)
{
  // The 'fmt' corresponds to bits 5-7 of the PTYPE
  static struct {
    u_int16_t width;
    u_int16_t height;
  } const dimensionsTable[8] = {
    { 0,    0 },      // 000 - 0 - forbidden, generates an error
    { 128,  96 },     // 001 - 1 - Sub QCIF
    { 176,  144 },    // 010 - 2 - QCIF
    { 352,  288 },    // 011 - 3 - CIF
    { 704,  576 },    // 100 - 4 - 4CIF
    { 1409, 1152 },   // 101 - 5 - 16CIF
    { 0,    0 },      // 110 - 6 - reserved, generates an error
    { 0,    0 }       // 111 - 7 - extended, not supported by profile 0
  };

  if (fmt > 7)
    return false;

  *width  = dimensionsTable[fmt].width;
  *height = dimensionsTable[fmt].height;

  if (*width  == 0)
    return false;

  return true;
}

static u_int8_t GetTRDifference(u_int8_t        nextTR,
                                u_int8_t        currentTR)
{
  if (currentTR > nextTR) {
    // Wrap around 255...
    return nextTR + (256 - currentTR);
  } else {
    return nextTR - currentTR;
  }
}

*/

---