/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:  

* Picture header decoding functions.

*

*/

#include "h263dConfig.h"

#include "decpich.h"

#include "debug.h"

#include "vdeims.h"

#include "vdeimb.h"

#include "viddemux.h"

#include "sync.h"

/*

 * Global functions

 */

/* {{-output"dphGetPictureHeader.txt"}} */

/*

 * dphGetPictureHeader

 *    

 *

 * Parameters:

 *    inParam                    input parameters

 *    inOutParam                 input/output parameters, these parameters

 *                               may be modified in the function

 *    outParam                   output parameters

 *    bitErrorIndication         bit error indication, see biterr.h for

 *                               the possible values

 *

 * Function:

 *    This function gets and decodes a picture header which should start

 *    with a PSC at the current position of the bit buffer. At first,

 *    the function reads the picture header fields from the bitstream.

 *    Then, it checks whether the values of the fields are supported.

 *    An unsupported value is interpreted as a bit error. Finally,

 *    the function updates VDC instance data and output parameters

 *    (according to the new picture header).

 *

 * Returns:

 *    DPH_OK

 *    DPH_OK_BUT_BIT_ERROR

 *    DPH_ERR

 *    DPH_ERR_NO_INTRA

 *    DPH_ERR_FORMAT_CHANGE

 *

 */

int dphGetPictureHeader(

   const dphInParam_t *inParam,

   dphInOutParam_t *inOutParam,

   dphOutParam_t *outParam,

   int *bitErrorIndication)

/* {{-output"dphGetPictureHeader.txt"}} */

{

   bibBuffer_t *inBuffer = inOutParam->inBuffer;

   u_char fPrevIntraGot;         /* Non-zero if an INTRA frame has been decoded

                           before the current frame */

   vdxGetPictureHeaderInputParam_t picHdrIn;

   vdxPictureHeader_t picHeader;

   vdcInstance_t *instance = inOutParam->vdcInstance;

   vdcPictureParam_t *pictureParam = &instance->pictureParam;

   vdcPictureParam_t prevPictParam;

   int trd;                      /* Difference between present and previous tr */

   int fInterFrame;              /* non-zero = INTER frame, 0 = INTRA frame */

   int fPBFrame;                 /* Flag indicating a PB-frame */

   int fRPS;                     /* 1 = RPS used, 0 = RPS not used */

   int ret = 0;                  /* temporary variable to carry return values */

   int retVal = DPH_OK;          /* return value if everything as expected,

                                    either DPH_OK or DPH_OK_BUT_SKIP */

   int16 error = 0;              /* snc and mvc module error code */

   /* 

    * Get picture header 

    */

   picHdrIn.numStuffBits = inParam->numStuffBits;

   picHdrIn.fCustomPCF = 0;

   picHdrIn.fScalabilityMode = 0;

   picHdrIn.fRPS = instance->fRPS;

   picHdrIn.flushBits = bibFlushBits;

   picHdrIn.getBits = bibGetBits;

   picHdrIn.showBits = bibShowBits;

    /* Used to recover the 1st picture segment */

    u_int32 picHeaderStartPos = bibNumberOfFlushedBits(inBuffer);

    if ( inParam->numStuffBits ) {

     bibFlushBits(inParam->numStuffBits, inBuffer, &picHdrIn.numStuffBits, bitErrorIndication, &error);

     picHdrIn.numStuffBits = 0;

    }

    // Read header bits normally from the bitstream

    ret = vdxGetPictureHeader(inBuffer, &picHdrIn, &picHeader, 

            bitErrorIndication);      

    if ( ret < 0 )

        return DPH_ERR;

    else if ( ret == VDX_OK_BUT_BIT_ERROR ) 

    {

        // Bit error exists.

        return DPH_OK_BUT_BIT_ERROR;

    } // end of if ( ret == VDX_OK_BUT_BIT_ERROR ) 

   /* 

    * Check picture header validity 

    */

   /* Local parameters needed in validity check (and possibly afterwards) */

   fPrevIntraGot = instance->fIntraGot;

   fInterFrame = (picHeader.pictureType == VDX_PIC_TYPE_P ||

      picHeader.pictureType == VDX_PIC_TYPE_PB ||

      picHeader.pictureType == VDX_PIC_TYPE_IPB);

   fPBFrame = ((picHeader.pictureType == VDX_PIC_TYPE_PB)||

      (picHeader.pictureType == VDX_PIC_TYPE_IPB));

   /* TR with the same value as in the previous picture can be interpreted

      two ways:

         - if Reference Picture Selection is enabled, it means

           a synchronization frame

         - if Reference Picture Selection is not used, it means the maximum

           difference between two frames.

           However, at least VDOPhone uses TR equal to zero always, which

           in practice should be interpreted that TR field is not used in

           display timing. */

   /* At first, check if RPS is used */

   if (picHeader.fPLUSPTYPE && picHeader.ufep)

      fRPS = picHeader.fRPS;

   else

      fRPS = instance->fRPS;

   /* Calculate temporal reference difference (from the previous frame) */

   trd = picHeader.tr - instance->pictureParam.tr;

   if (trd < 0)

      trd += 256; /* Note: Add ETR support */

   /* If TR is the same as in the previous frame and Reference Picture Selection

      is not used and not the very first frame (in which case previous tr == 0), 

      the temporal reference difference is the maximum one. */

   if (trd == 0 && !fRPS && instance->frameNum > 0)

      trd = 256; /* Note: Add ETR support */

   /* If unsupported picture type */

   if (picHeader.pictureType != VDX_PIC_TYPE_I

      && picHeader.pictureType != VDX_PIC_TYPE_P

      && picHeader.pictureType != VDX_PIC_TYPE_PB

      && picHeader.pictureType != VDX_PIC_TYPE_IPB

      ) {

      return DPH_OK_BUT_BIT_ERROR;

   }

   if (picHeader.pictureType == VDX_PIC_TYPE_PB ||

      picHeader.pictureType == VDX_PIC_TYPE_IPB) {

      return DPH_OK_BUT_BIT_ERROR;

   }

   if (picHeader.cpm) {

      /* No CPM support */

      return DPH_OK_BUT_BIT_ERROR;

   }

   if (picHeader.fPLUSPTYPE) {

      /* If unsupported modes (and UFEP is whatever) */

      if (picHeader.fRPR ||

         picHeader.fRRU) {

         return DPH_OK_BUT_BIT_ERROR;

      }

      if (picHeader.ufep == 1) {

         /* If unsupported mode */

         if (picHeader.fISD ||

            picHeader.fSAC ||

            picHeader.fAIV ||

            picHeader.fCustomPCF) {

            return DPH_OK_BUT_BIT_ERROR;

         }

         if (picHeader.fUMV) {

            return DPH_OK_BUT_BIT_ERROR;

         }

         if (picHeader.fAP) {

            return DPH_OK_BUT_BIT_ERROR;

         }

         if (picHeader.fAIC) {

            return DPH_OK_BUT_BIT_ERROR;

         }

         if (picHeader.fDF) {

            return DPH_OK_BUT_BIT_ERROR;

         }

         if (picHeader.fSS) {

            return DPH_OK_BUT_BIT_ERROR;

         }

         if (picHeader.fMQ) {

            return DPH_OK_BUT_BIT_ERROR;

         }

      }

      /* Note: Add check for "The Indenpenent Segment Decoding mode shall not

         be used with the Reference Picture Resampling mode"

         from section 5.1.4.6 of the H.263 recommendation whenever both of

         the modes in question are supported. 

         Note that this check cannot reside in vdxGetPictureHeader since

         ISD and RPR can be turned on in different pictures. */

   }

   /* Else no PLUSPTYPE */

   else {

      /* If unsupported modes */

      if (picHeader.fSAC) {

         return DPH_OK_BUT_BIT_ERROR;

      }

         if (picHeader.fUMV) {

            return DPH_OK_BUT_BIT_ERROR;

         }

         if (picHeader.fAP) {

            return DPH_OK_BUT_BIT_ERROR;

         }

   }

   /* If no INTRA frame has ever been decoded and the current frame is INTER */

   if (!fPrevIntraGot && fInterFrame)

      return DPH_ERR_NO_INTRA;

   if (fPrevIntraGot) {

      /* If width and height are indicated in the header and

         they are different from the previous */

      if ((picHeader.fPLUSPTYPE == 0 || picHeader.ufep == 1) &&

         (instance->pictureParam.lumWidth != picHeader.lumWidth ||

         instance->pictureParam.lumHeight != picHeader.lumHeight)) {

         if (fInterFrame) {

            /* INTER frame, check that the source format has not changed */

            deb("vdcDecodeFrame: ERROR - Source format has changed "

               "(INTER frame)\n");

            return DPH_OK_BUT_BIT_ERROR;

         }

         else if ( *bitErrorIndication ) {

            deb("vdcDecodeFrame: ERROR - Frame size changing during "

               "the sequence, cause: bitError\n");

            return DPH_OK_BUT_BIT_ERROR;

         }

         else {

            /* At the moment do NOT allow source format changes during

               the sequence. */

            deb("vdcDecodeFrame: ERROR - Frame size changing during "

               "the sequence\n");

            return DPH_ERR_FORMAT_CHANGE;

         }

      }

   }

   /* If the temporal reference of B points after P */

   if (fPBFrame && trd <= picHeader.trb) {

      deb("vdcDecodeFrame: ERROR - TRB illegal.\n");

      return DPH_OK_BUT_BIT_ERROR;

   }

   /* Now, the picture header is considered to be error-free,

      and its contents are used to manipulate instance data */

   /*

    * Update instance data and output parameters

    */

   /* Update frame numbers */

   {

      int32 oldFrameNum = instance->frameNum;

      instance->frameNum += trd;

      if (instance->frameNum < 0)

         /* Wrap from 0x7fffffff to 0 instead of the largest negative number */

         instance->frameNum += 0x80000000;

      if (fPBFrame) {

         instance->frameNumForBFrame = oldFrameNum + picHeader.trb;

         if (instance->frameNumForBFrame < 0)

            /* Wrap from 0x7fffffff to 0 instead of the largest negative number */

            instance->frameNumForBFrame += 0x80000000;

      }

      else

         instance->frameNumForBFrame = -1;

   }

   /* Note: If no INTRA has been got the function has already returned */

   instance->fIntraGot = 1;

   outParam->pquant = picHeader.pquant;

   instance->fRPS = fRPS;

   if (instance->fRPS && picHeader.trpi)

      outParam->trp = picHeader.trp;

   else

      outParam->trp = -1;

   if (instance->fRPS && picHeader.fPLUSPTYPE && picHeader.ufep)

      instance->rpsMode = picHeader.rpsMode;

   /* Store previous picture parameters temporarily */

   memcpy(&prevPictParam, pictureParam, sizeof(vdcPictureParam_t));

   /* Update picture parameters */

   pictureParam->tr = picHeader.tr;

   pictureParam->trd = trd;

   pictureParam->fSplitScreenIndicator = picHeader.fSplitScreen;

   pictureParam->fDocumentCameraIndicator = picHeader.fDocumentCamera;

   pictureParam->fFullPictureFreezeRelease = picHeader.fFreezePictureRelease;

   pictureParam->pictureType = picHeader.pictureType;

   pictureParam->fPLUSPTYPE = picHeader.fPLUSPTYPE;

   pictureParam->cpm = picHeader.cpm;

   pictureParam->psbi = picHeader.psbi;

   if (fPBFrame) {

      pictureParam->trb = picHeader.trb;

      pictureParam->dbquant = picHeader.dbquant;

   }

   if (!picHeader.fPLUSPTYPE || picHeader.ufep) {

      pictureParam->lumWidth = picHeader.lumWidth;

      pictureParam->lumHeight = picHeader.lumHeight;

      pictureParam->fUMV = picHeader.fUMV;

      pictureParam->fSAC = picHeader.fSAC;

      pictureParam->fAP = picHeader.fAP;

      if (pictureParam->lumWidth % 16)

         pictureParam->lumMemWidth = 

            (pictureParam->lumWidth / 16 + 1) * 16;

      else

         pictureParam->lumMemWidth = pictureParam->lumWidth;

      if (pictureParam->lumHeight % 16)

         pictureParam->lumMemHeight = (pictureParam->lumHeight / 16 + 1) * 16;

      else

         pictureParam->lumMemHeight = pictureParam->lumHeight;

      if (picHeader.lumHeight <= 400)

         pictureParam->numMBLinesInGOB = 1;

      else if (picHeader.lumHeight <= 800)

         pictureParam->numMBLinesInGOB = 2;

      else

         pictureParam->numMBLinesInGOB = 4;

      pictureParam->numMBsInMBLine = pictureParam->lumMemWidth / 16;

      {

         int 

            numMBLines = pictureParam->lumMemHeight / 16,

            numMBLinesInLastGOB = 

               numMBLines % pictureParam->numMBLinesInGOB;

         if (numMBLinesInLastGOB) {

            pictureParam->numGOBs = 

               numMBLines / pictureParam->numMBLinesInGOB + 1;

            pictureParam->fLastGOBSizeDifferent = 1;

            pictureParam->numMBsInLastGOB = 

               numMBLinesInLastGOB * pictureParam->numMBsInMBLine;

         }

         else {

            pictureParam->numGOBs = 

               numMBLines / pictureParam->numMBLinesInGOB ;

            pictureParam->fLastGOBSizeDifferent = 0;

            pictureParam->numMBsInLastGOB = 

               pictureParam->numMBLinesInGOB * pictureParam->numMBsInMBLine;

         }

      }

      pictureParam->numMBsInGOB = 

         pictureParam->numMBsInMBLine * pictureParam->numMBLinesInGOB;

   }

   else {

      pictureParam->lumWidth = prevPictParam.lumWidth;

      pictureParam->lumHeight = prevPictParam.lumHeight;

      pictureParam->lumMemWidth = prevPictParam.lumMemWidth;

      pictureParam->lumMemHeight = prevPictParam.lumMemHeight;

      pictureParam->fUMV = prevPictParam.fUMV;

      pictureParam->fSAC = prevPictParam.fSAC;

      pictureParam->fAP = prevPictParam.fAP;

   }

   /* Note: Mode inference rules defined in section 5.1.4.5 of

      the H.263 recommendation are (in most cases) not reflected to members

      of pictureParam due to the fact that they are implicitly turned

      off or irrelevant in the current implementation. (This is particularly

      true when assigning inferred state "off".) */

   if (picHeader.fPLUSPTYPE) {

      pictureParam->fRPR = picHeader.fRPR;

      pictureParam->fRRU = picHeader.fRRU;

      pictureParam->rtype = picHeader.rtype;

      /* Note: irrelevant if Annex O is not in use */

      pictureParam->elnum = picHeader.elnum;

      if (picHeader.ufep) {

         pictureParam->fCustomSourceFormat = picHeader.fCustomSourceFormat;

         pictureParam->fAIC = picHeader.fAIC;

         pictureParam->fDF = picHeader.fDF;

         pictureParam->fSS = picHeader.fSS;

         pictureParam->fRPS = picHeader.fRPS;

         pictureParam->fISD = picHeader.fISD;

         pictureParam->fAIV = picHeader.fAIV;

         pictureParam->fMQ = picHeader.fMQ;

         pictureParam->fUMVLimited = picHeader.fUMVLimited;

      }

      /* Else no UFEP */

      else {

         pictureParam->fCustomSourceFormat = 

            prevPictParam.fCustomSourceFormat;

         pictureParam->fAIC = prevPictParam.fAIC;

         pictureParam->fDF = prevPictParam.fDF;

         pictureParam->fSS = prevPictParam.fSS;

         pictureParam->fRPS = prevPictParam.fRPS;

         pictureParam->fISD = prevPictParam.fISD;

         pictureParam->fAIV = prevPictParam.fAIV;

         pictureParam->fMQ = prevPictParam.fMQ;

         pictureParam->fUMVLimited = prevPictParam.fUMVLimited;

      }

   }

   /* Else no PLUSPTYPE */

   else {

      /* Section 5.1.4.5 of the H.263 recommendation states:

         "If a picture is sent which does not contain (PLUSPTYPE),

         a state "off" shall be assigned to all modes not explicitly set to

         "on" in the PTYPE filed, and all modes shall continue to have 

         an inferred state of "off" until a new picture containing

         the optional part of PLUSPTYPE is sent." */

      /* Fields occuring in mandatory part of PLUSPTYPE are copied from

         the previous picture. */

      pictureParam->fRPR = prevPictParam.fRPR;

      pictureParam->fRRU = prevPictParam.fRRU;

      /* RTYPE is set to zero according to section 6.1.2 of 

         the H.263 recommendation */

      pictureParam->rtype = 0;

      /* Modes occuring in the optional part of PLUSPTYPE are turned off

         (unless occuring in PTYPE field too, like Advanced Prediction). */

      pictureParam->fCustomSourceFormat = 0;

      pictureParam->fCustomPCF = 0;

      pictureParam->fAIC = 0;

      pictureParam->fDF = 0;

      pictureParam->fSS = 0;

      pictureParam->fRPS = 0;

      pictureParam->fISD = 0;

      pictureParam->fAIV = 0;

      pictureParam->fMQ = 0;

      /* Other related settings turned off just to be sure that they are

         not misused. */

      pictureParam->fUMVLimited = 0;

   }

   pictureParam->fMVsOverPictureBoundaries =

      (pictureParam->fUMV || pictureParam->fAP || 

      pictureParam->fDF);

   /* Initialize motion vector count module */

    mvcStart(   &instance->mvcData, 

               instance->pictureParam.lumMemWidth / 16 - 1, 

               pictureParam->lumMemWidth, 

               pictureParam->lumMemHeight, &error);

   /* Note: This assumes that the memory for frame->mvcData is filled with 0

      in the first time the function is called.

      (This is ensured by setting the instance data to zero when it is

      initialized in vdcOpen.) */

   instance->mvcData.fSS = pictureParam->fSS;

   if (error) {

      deb("mvcStart failed.\n");

      return DPH_ERR;

   }

   /* Get image buffers */

   {

      vdeIms_t *store = instance->imageStore;

      vdeImsItem_t *imsItem;

      vdeImb_t *imb;

      int width, height;

      vdeImsSetYUVNeed(store, inParam->fNeedDecodedFrame);

      if (vdeImsGetFree(store, instance->pictureParam.lumMemWidth, 

         instance->pictureParam.lumMemHeight, 

         &instance->currFrame) < 0)