/*

* 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:  

* MB decoding in data partitioned mode (MPEG-4).

*

*/

/*

 * Includes 

 */

#include "h263dConfig.h"

#include "decmbs.h"

#include "decmbdct.h"

#include "viddemux.h"

#include "errcodes.h"

#include "sync.h"

#include "mpegcons.h"

#include "debug.h"

/* MVE */

#include "MPEG4Transcoder.h"

/*

 * Local functions

 */

/*

 * Global functions

 */

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

/*

 * dmbsGetAndDecodeIMBsDataPartitioned

 *    

 *

 * Parameters:

 *    inParam                    input parameters

 *    inOutParam                 input/output parameters, these parameters

 *                               may be modified in the function

 *

 * Function:

 *    This function gets and decodes the MBs of a data partitioned 

 *    Video Packet in an Intra Frame.

 *

 * Returns:

 *    >= 0                       the function was successful

 *    < 0                        an error occured

 *

 */

int dmbsGetAndDecodeIMBsDataPartitioned(

   dmbIFrameMBInParam_t *inParam,

   dmbIFrameMBInOutParam_t *inOutParam,

   int *quantParams, CMPEG4Transcoder *hTranscoder)

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

{

   int retValue = DMBS_OK;

   int currMBNumInVP, lastMBNum, numMBsInVP, numCorrectMBs;

   int yWidth = inParam->pictParam->lumMemWidth;

   int uvWidth = yWidth / 2;

   int bitErrorIndication = 0, ret = 0, sncCode, bitsGot, bitErrorsInPart1 = 0;

   u_int32 startVPBitPos = 0, 

         errorBitPos = 0,

         backwards_errorBitPos = 0,

         nextVPBitPos = 0,

         startBlockDataBitPos = 0,

         DCMarkerBitPos = 0;

   u_char fPart1Error=0, fPart2Error=0, fBlockError=0;

   int16 error = 0;

#ifdef DEBUG_OUTPUT

   FILE *rvlc_stat;

#endif

   dlst_t MBList;

   vdxIMBListItem_t *MBinstance;

   vdxGetDataPartitionedIMBLayerInputParam_t vdxDPIn;

   dmdMPEGIParam_t dmdIn;

   if (dlstOpen(&MBList) < 0)

      return DMBS_ERR;

   /* mark the bit position at the beginning of the VP */

   startVPBitPos = bibNumberOfFlushedBits(inParam->inBuffer);

   /* 

    * read the first partition: DC coefficients, etc. 

    */

   vdxDPIn.intra_dc_vlc_thr = inParam->pictParam->intra_dc_vlc_thr;

   vdxDPIn.quant = inOutParam->quant;

   /* MVE */

   ret = vdxGetDataPartitionedIMBLayer_Part1(inParam->inBuffer, inParam->outBuffer, 

         inParam->bufEdit, inParam->iColorEffect, &(inOutParam->StartByteIndex), 

         &(inOutParam->StartBitIndex), hTranscoder, &vdxDPIn, &MBList, 

         &bitErrorIndication);

   bitErrorsInPart1 = bitErrorIndication;

   if (ret < 0) {

       retValue = DMBS_ERR;

       goto exitFunction;

   }

   else if (ret == VDX_OK_BUT_BIT_ERROR) {

      fPart1Error = 1;

      bitErrorIndication = 0;

      deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - DC partition error.\n");

   } else {

      DCMarkerBitPos = bibNumberOfFlushedBits(inParam->inBuffer);

   }

   /* read the next VP header to determine the number of MBs in this VP */

   if ( fPart1Error ) {

       /* Stop decoding this segment */

      goto exitFunction;

   }

   else {

      sncCode = sncRewindAndSeekNewMPEGSync( 1,

          inParam->inBuffer, inParam->pictParam->fcode_forward, &error);

   }

   if (error) {

      if (error == ERR_BIB_NOT_ENOUGH_DATA) error = 0;

      else { 

          retValue = DMBS_ERR;

          goto exitFunction;          

      }

   }

   nextVPBitPos = bibNumberOfFlushedBits(inParam->inBuffer);

   if (sncCode == SNC_VIDPACK) {

      vdxVideoPacketHeader_t header;

      vdxGetVideoPacketHeaderInputParam_t vdxParam;

      int retValue;

      vdxParam.fcode_forward = inParam->pictParam->fcode_forward;

      vdxParam.time_increment_resolution = inParam->pictParam->time_increment_resolution;

      vdxParam.numOfMBs = inParam->pictParam->numMBsInGOB;

      retValue = vdxGetVideoPacketHeader(inParam->inBuffer, &vdxParam, &header, &bitErrorIndication);

      if (retValue < 0) {

          retValue = DMBS_ERR;

          goto exitFunction;      

      } else if (retValue == VDX_OK_BUT_BIT_ERROR) {

         /* If bit error occurred */

         deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - VP Header error.\n");

         bitErrorIndication = 0;

         lastMBNum = 0;

      } else {    

         lastMBNum = header.currMBNum;

      }

   } else {

      lastMBNum = inParam->pictParam->numMBsInGOB;

   }

   /* rewind the bits to the beginning of the current VP data */

   bibRewindBits(bibNumberOfFlushedBits(inParam->inBuffer) - (fPart1Error ? errorBitPos : DCMarkerBitPos),

      inParam->inBuffer, &error);

   if (fPart1Error) {

      /* Seek the DC_MARKER */

      if ((sncSeekBitPattern(inParam->inBuffer, MP4_DC_MARKER, MP4_DC_MARKER_LENGTH, &error) != SNC_PATTERN) ||

         (bibNumberOfFlushedBits(inParam->inBuffer) >= nextVPBitPos)) {

         /* rewind the bits to the beginning of the current VP data */

         bibRewindBits( VDC_MIN(bibNumberOfRewBits(inParam->inBuffer), (bibNumberOfFlushedBits(inParam->inBuffer) - startVPBitPos)),

            inParam->inBuffer, &error);

         deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - Part1Error && No DC marker found.\n");

         goto exitFunction;

      }

   } 

   if ((lastMBNum <= inOutParam->currMBNum) ||

      (lastMBNum > inParam->pictParam->numMBsInGOB) ||

      (sncCode == SNC_EOB)) {

      numMBsInVP = MBList.numItems;

      if (fPart1Error) fPart2Error = 1;

   } else 

      numMBsInVP = lastMBNum - inOutParam->currMBNum;

   if (numMBsInVP != MBList.numItems || fPart1Error) {

      deb("dmbsGetAndDecodePMBsDataPartitioned:ERROR - MB list length != num MBs.\n");

      if ( fPart1Error || bitErrorsInPart1 ) {

         /* Discard few MBs from the end of the list, 

            since there are errors somewhere in the bitstream. 

            If the list is short due to the missing packet, 

            all the read MBs are likely to be OK and there is no

            need to discard them */

         dlstTail(&MBList, (void **) &MBinstance);

         dlstRemove(&MBList, (void **) &MBinstance);

         free( MBinstance );

         if (numMBsInVP > MBList.numItems ) {

            /* Take still one away */

            dlstTail(&MBList, (void **) &MBinstance);

            dlstRemove(&MBList, (void **) &MBinstance);

            free( MBinstance );

         }

      }

      if (numMBsInVP < MBList.numItems ) {

         /* Discard all the extra MBs from the end of the list + 2 just to be sure, 

            since there are errors somewhere in the bitstream */

         while ( MBList.numItems > VDC_MAX(numMBsInVP-2,0) ) {

            dlstTail(&MBList, (void **) &MBinstance);

            dlstRemove(&MBList, (void **) &MBinstance);

            free( MBinstance );

         }

      }

      fPart1Error = 1;

      errorBitPos = bibNumberOfFlushedBits(inParam->inBuffer);

   }

   /* Flush the DC_Marker */

   bibFlushBits(MP4_DC_MARKER_LENGTH, inParam->inBuffer, &bitsGot, &bitErrorIndication, &error);

   if (error)

   {

       retValue = DMBS_ERR;

       goto exitFunction;        

   }

   /*

    * Read the second partition header: cpby, ac_pred_flag 

    */

   ret = vdxGetDataPartitionedIMBLayer_Part2(inParam->inBuffer, inParam->outBuffer, 

         inParam->bufEdit, inParam->iColorEffect, &(inOutParam->StartByteIndex), &(inOutParam->StartBitIndex),

         &MBList, numMBsInVP, &bitErrorIndication);

   if (ret < 0) {

      retValue = DMBS_ERR;

      goto exitFunction;

   }

   else if (ret == VDX_OK_BUT_BIT_ERROR) {

        fPart2Error = 1;

        deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - Part2Error.\n");

        /* Stop decoding this segment */

        goto exitFunction;

   }

   /* common input parameters for all blocks */

   dmdIn.aicData = inOutParam->aicData;

   /* MVE */

   dmdIn.inBuffer = inParam->inBuffer;

   dmdIn.outBuffer = inParam->outBuffer;

   dmdIn.bufEdit = inParam->bufEdit;

   dmdIn.iColorEffect = inParam->iColorEffect;

   dmdIn.iGetDecodedFrame = inParam->iGetDecodedFrame;

   dmdIn.yWidth = inParam->pictParam->lumMemWidth;

   dmdIn.numMBsInMBLine = inParam->pictParam->numMBsInMBLine;

   dmdIn.pictureType = inParam->pictParam->pictureType;

   /*

    * Read block data partition in forward direction 

    */

   startBlockDataBitPos = bibNumberOfFlushedBits(inParam->inBuffer);

   /* set block pointers to the beginning of the VP */   

   dmdIn.yMBInFrame = inOutParam->yMBInFrame;

   dmdIn.uBlockInFrame = inOutParam->uBlockInFrame;

   dmdIn.vBlockInFrame = inOutParam->vBlockInFrame;

   dmdIn.xPosInMBs = inParam->xPosInMBs;

   dmdIn.yPosInMBs = inParam->yPosInMBs;

   dmdIn.currMBNum = inOutParam->currMBNum;

   /* get the first MB of the list */

   dlstHead(&MBList, (void **) &MBinstance);

   for (currMBNumInVP = 0; currMBNumInVP < numMBsInVP; currMBNumInVP++) {

         /* if MBList is shorter then the number of MBs in the VP */

         if (MBinstance == NULL) {

             deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - MB list < num MBs.\n");

             goto exitFunction;

         }

         /* header params. If partition 2 or AC partition contains errors, no bits are read any more 

         from the bitstream, but the blocks are reconstructed based only on DC values */

         dmdIn.cbpy = (fPart2Error || fBlockError) ? 0 : MBinstance->cbpy;

         dmdIn.cbpc = (fPart2Error || fBlockError) ? 0 : MBinstance->cbpc;

         dmdIn.quant = MBinstance->quant;

         /* AC/DC prediction params */

         dmdIn.switched = MBinstance->switched;

         dmdIn.fTopOfVP = (u_char) (currMBNumInVP < inParam->pictParam->numMBsInMBLine);

         dmdIn.fLeftOfVP = (u_char) (currMBNumInVP == 0);

         dmdIn.fBBlockOut = (u_char) (currMBNumInVP <= inParam->pictParam->numMBsInMBLine);

         inOutParam->aicData->ACpred_flag = (u_char) ((fPart2Error || fBlockError) ? 0 : MBinstance->ac_pred_flag);

         /* error resilience params */

         dmdIn.data_partitioned = 1;

         dmdIn.DC = MBinstance->DC;

         dmdIn.reversible_vlc = inParam->pictParam->reversible_vlc;

         dmdIn.vlc_dec_direction = 0;

         /* MVE */

         hTranscoder->OneIMBDataStartedDataPartitioned(MBinstance, &MBList, currMBNumInVP, dmdIn.currMBNum);

         /* get the next macroblock data */

         ret = dmdGetAndDecodeMPEGIMBBlocks(&dmdIn, hTranscoder);

         if ( ret < 0 ) {

             retValue = DMBS_ERR;

             goto exitFunction;         

         }

      else if ( ret == DMD_BIT_ERR ) {

         if (fPart1Error) {

            deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - IMB Blocks decoding error && Part1Error.\n");

            goto exitFunction;

         } else {

            deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - IMB Blocks decoding error. Using DCs only.\n");

            fBlockError = 1;

         }

      }

      /* Store quantizer */

      quantParams[dmdIn.currMBNum] = MBinstance->quant;

      /* increment the block pointers and counters */

      dmdIn.currMBNum++;

      if ( dmdIn.yMBInFrame != NULL )

        {

            dmdIn.yMBInFrame += 16;

            dmdIn.uBlockInFrame += 8;

            dmdIn.vBlockInFrame += 8;

        }

      dmdIn.xPosInMBs++;

      if (dmdIn.xPosInMBs == inParam->pictParam->numMBsInMBLine) {

         if ( dmdIn.yMBInFrame )

            {

             dmdIn.yMBInFrame += 15 * yWidth;

             dmdIn.uBlockInFrame += 7 * uvWidth;

             dmdIn.vBlockInFrame += 7 * uvWidth;

            }

         dmdIn.xPosInMBs = 0;

         dmdIn.yPosInMBs++;

         if (dmdIn.yPosInMBs >= inParam->pictParam->numMBLinesInGOB)

            break;

      }

      dlstNext(&MBList, (void **) &MBinstance);

   }

   if (!fPart1Error && !fPart2Error && !fBlockError) {

         if (sncCode == SNC_EOB) {

             inOutParam->currMBNum += numMBsInVP;

             goto exitFunction;

         } else {

             sncCode = sncCheckMpegSync(inParam->inBuffer, inParam->pictParam->fcode_forward, &error);

             if (sncCode == SNC_NO_SYNC) {

                 deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - After block data no start code found.\n");

                 if (lastMBNum != 0) 

                     fBlockError = 1;

             }

         }

   }

   /*

    * In case of error, read block data partition in backward direction 

    */

   /* WARNING: backwards decoding of INTRA frame RVLC is disabled by setting the VP size

      higher then 10. The useful VP sizes used in low bitrates allow max. 8-10 MBs per

     VP, but in average 3-5 MBs. With this small amount the backwards decoding always

     causes overlap of the MB counter, and the overlapped MBs must be discarded. So the

     RVLC doesn't have any use. */

   if (!fPart2Error && fBlockError && inParam->pictParam->reversible_vlc && (numMBsInVP >= 10)) {

      numCorrectMBs = currMBNumInVP;

#ifdef DEBUG_OUTPUT

      {

         int bitPos[6], xpos, ypos, mbnum;

         rvlc_stat = fopen("rvlc.log", "a+t");

         fprintf(rvlc_stat, "I-VOP: (frame)(MB_first):%3d  (MB_last):%3d\n", 

            inOutParam->currMBNum, (inOutParam->currMBNum + numMBsInVP-1));

         for (xpos = inParam->xPosInMBs, ypos = inParam->yPosInMBs, mbnum = 0; mbnum < numCorrectMBs; mbnum++, xpos++) {

            if (xpos / inParam->pictParam->numMBsInMBLine)

               xpos = 0, ypos++;

            fprintf(rvlc_stat, "fw: MB#%3d\tY0: %8d | Y1: %8d | Y2: %8d | Y3: %8d | U: %8d | V: %8d\n", 

               inOutParam->currMBNum+mbnum, bitPos[0], bitPos[1], bitPos[2], bitPos[3], bitPos[4], bitPos[5]); 

         }

      }

#endif

         /* find next VP header (end of MB block data of this VP) */

      sncCode = sncRewindAndSeekNewMPEGSync(errorBitPos-startBlockDataBitPos, inParam->inBuffer,

         inParam->pictParam->fcode_forward, &error);      

      if (error) {

          if (error == ERR_BIB_NOT_ENOUGH_DATA) error = 0;

          else { 

              retValue = DMBS_ERR;

              goto exitFunction;              

          }

      }

      if (sncCode == SNC_EOB) {

         inOutParam->currMBNum += numMBsInVP;

         goto exitFunction;

      }

      nextVPBitPos = bibNumberOfFlushedBits(inParam->inBuffer);

      backwards_errorBitPos = startBlockDataBitPos;

      /* rewind the stuffing bits */

      if (sncCode != SNC_NO_SYNC || !(nextVPBitPos % 8)) {

         if(sncRewindStuffing(inParam->inBuffer, &error) != SNC_PATTERN) {

            deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - Backwards decoding, stuffing not found.\n");

            inOutParam->currMBNum = dmdIn.currMBNum;

            goto exitFunction;

         }

      }

      /* set the block pointers and counters to the end of the VP */

      if ( dmdIn.yMBInFrame != NULL )

        {

          dmdIn.yMBInFrame = inOutParam->yMBInFrame + 16 * (numMBsInVP-1);

          dmdIn.uBlockInFrame = inOutParam->uBlockInFrame + 8 * (numMBsInVP-1);

          dmdIn.vBlockInFrame = inOutParam->vBlockInFrame + 8 * (numMBsInVP-1);

        }

      else

        {

            dmdIn.yMBInFrame = dmdIn.uBlockInFrame = dmdIn.vBlockInFrame = NULL;

        }

      dmdIn.xPosInMBs = inParam->xPosInMBs + (numMBsInVP-1);

      dmdIn.yPosInMBs = inParam->yPosInMBs;

      if (dmdIn.xPosInMBs / inParam->pictParam->numMBsInMBLine) {

         int numFullLines = dmdIn.xPosInMBs / inParam->pictParam->numMBsInMBLine;

         if ( dmdIn.yMBInFrame != NULL )

            {

                dmdIn.yMBInFrame += 15 * yWidth * numFullLines;

                dmdIn.uBlockInFrame += 7 * uvWidth * numFullLines;

                dmdIn.vBlockInFrame += 7 * uvWidth * numFullLines;

            }

         dmdIn.xPosInMBs = dmdIn.xPosInMBs % inParam->pictParam->numMBsInMBLine;

         dmdIn.yPosInMBs+=numFullLines;

      }

      dmdIn.currMBNum = inOutParam->currMBNum + (numMBsInVP-1);

      /* get the last MB of the list */

      dlstTail(&MBList, (void **) &MBinstance);

      for (currMBNumInVP = numMBsInVP-1; currMBNumInVP >= 0; currMBNumInVP--) {

         /* header params */

         dmdIn.cbpy = MBinstance->cbpy;

         dmdIn.cbpc = MBinstance->cbpc;

         dmdIn.quant = MBinstance->quant;

         /* AC/DC prediction params */

         dmdIn.switched = MBinstance->switched;

         dmdIn.fTopOfVP = (u_char) (currMBNumInVP < inParam->pictParam->numMBsInMBLine);

         dmdIn.fLeftOfVP = (u_char) (currMBNumInVP == 0);

         dmdIn.fBBlockOut = (u_char) (currMBNumInVP <= inParam->pictParam->numMBsInMBLine);

         inOutParam->aicData->ACpred_flag = MBinstance->ac_pred_flag;

         /* error resilience params */

         dmdIn.data_partitioned = 1;

         dmdIn.DC = MBinstance->DC;

         dmdIn.reversible_vlc = 1;

         dmdIn.vlc_dec_direction = 1;

         /* get the next macroblock data */

         ret = dmdGetAndDecodeMPEGIMBBlocks(&dmdIn, hTranscoder);

         if ( ret < 0 ) {

             retValue = DMBS_ERR;

             goto exitFunction;                      

         }

         else if ( ret == DMD_BIT_ERR ) {

            backwards_errorBitPos = bibNumberOfFlushedBits(inParam->inBuffer);

            deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - Backwards decoding, IMB Blocks error.\n");

            break;

         }

         if (bibNumberOfFlushedBits(inParam->inBuffer) <= startBlockDataBitPos) {

            deb("dmbsGetAndDecodeIMBsDataPartitioned:ERROR - Backwards decoding, block data start position reached.\n");

            break;

         }

         /* deincrement the block pointers and counters */

         dmdIn.xPosInMBs--;

         if (dmdIn.xPosInMBs < 0) {

            if (dmdIn.yPosInMBs > 0) {

               if ( dmdIn.yMBInFrame != NULL )

                {

                   dmdIn.yMBInFrame -= 15 * yWidth;

                   dmdIn.uBlockInFrame -= 7 * uvWidth;

                   dmdIn.vBlockInFrame -= 7 * uvWidth;

                }