/*

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

*

*/

#include <string.h>

#include "globals.h"

#include "framebuffer.h"

#include "dpb.h"

/*

 *

 * dpbOpen:

 *

 * Parameters:

 *

 * Function:

 *      Allocate DPB.

 *

 * Returns:

 *      Pointer to dpb or NULL

 *

 */

dpb_s *dpbOpen()

{

  dpb_s *dpb;

  dpb = (dpb_s *)User::Alloc(sizeof(dpb_s));

  if (dpb != NULL)

    memset(dpb, 0, sizeof(dpb_s));

  return dpb;

}

/*

 *

 * dpbClose:

 *

 * Parameters:

 *      dpb                   DPB object

 *

 * Function:

 *      Deinitialize DPB.

 *

 * Returns:

 *      -

 *

 */

void dpbClose(dpb_s *dpb)

{

  int i;

  for (i = 0; i < DPB_MAX_SIZE; i++)

    frmCloseRef(dpb->buffers[i]);

  User::Free(dpb);

}

/*

 *

 * dpbSetSize:

 *

 * Parameters:

 *      dpb                   DPB object

 *      dpbSize               New DPB size

 *

 * Function:

 *      Set DPB size in frames.

 *

 * Returns:

 *      -

 *

 */

void dpbSetSize(dpb_s *dpb, int dpbSize)

{

  int i;

  /* If new DPB size is smaller than old, close any unneeded frame buffers */

  for (i = dpbSize; i < dpb->size; i++) {

    frmCloseRef(dpb->buffers[i]);

    dpb->buffers[i] = NULL;

  }

  dpb->size = min(dpbSize, DPB_MAX_SIZE);

}

/*

 *

 * dpbGetNextOutputPic:

 *

 * Parameters:

 *      dpb                   DPB object

 *      dpbHasIDRorMMCO5      Set upon return if IDR picture or picture with

 *                            MMCO5 command is found in DPB

 *

 * Function:

 *      Find next frame to output (frame with the lowest POC).

 *      Search is started from the last active frame in dpb and is

 *      stopped if all frames have been checked or IDR picture or

 *      picture with MMCO5 is found.

 *

 * Returns:

 *      Framebuffer with the lowest POC or 0 if DPB is empty

 *

 */

frmBuf_s *dpbGetNextOutputPic(dpb_s *dpb, int *dpbHasIDRorMMCO5)

{

  frmBuf_s * tmpFrm;

  int i;

  tmpFrm = 0;

  /* Find first output pic in decoding order */

  for (i = dpb->fullness-1; i >= 0; i--) {

    if (dpb->buffers[i]->forOutput) {

      tmpFrm = dpb->buffers[i];

      break;

    }

  }

  *dpbHasIDRorMMCO5 = 0;

  /* Find picture with lowest poc. Stop search if IDR or MMCO5 is found */

  for (; i >= 0; i--) {

    if (dpb->buffers[i]->isIDR || dpb->buffers[i]->hasMMCO5) {

      *dpbHasIDRorMMCO5 = 1;

      break;

    }

    if (dpb->buffers[i]->forOutput && dpb->buffers[i]->poc < tmpFrm->poc)

      tmpFrm = dpb->buffers[i];

  }

  return tmpFrm;

}

/*

 *

 * dpbStorePicture:

 *

 * Parameters:

 *      dpb                   DPB object

 *      currPic               Current picture

 *      outputQueue           Output queue

 *

 * Function:

 *      - Remove unused frames (non-reference, non-output frames) from the DPB.

 *      - If there is room in the DPB, put picture to DPB.

 *      - If there is no room in DPB, put pictures to output queue

 *        until frame is available.

 *

 * Returns:

 *      The number of pictures in output queue or negative value for error.

 *

 */

int dpbStorePicture(dpb_s *dpb, frmBuf_s *currPic, frmBuf_s *outputQueue[])

{

  frmBuf_s *tmpRemList[DPB_MAX_SIZE];

  frmBuf_s *tmpFrm;

  int numFrm, numRemFrm;

  int i;

  int freeBufferFound;

  int numOutput;

  int dpbHasIDRorMMCO5;

  /*

   * If the current picture is a reference picture and DPB is already full of

   * reference pictures, we cannot insert current picture to DPB. Therefore,

   * we force one reference picture out of DPB to make space for current

   * picture. This situation can only happen with corrupted bitstreams.

   */

  if (currPic->refType != FRM_NON_REF_PIC &&

      (dpb->numShortTermPics+dpb->numLongTermPics) == dpb->size)

  {

    if (dpb->numLongTermPics == dpb->size)

      dpb->buffers[dpb->fullness-1]->refType = FRM_NON_REF_PIC;

    else

      dpbMarkLowestShortTermPicAsNonRef(dpb);

  }

  /*

   * Remove unused frames from dpb

   */

  numFrm = 0;

  numRemFrm = 0;

  for (i = 0; i < dpb->fullness; i++) {

    if (dpb->buffers[i]->refType != FRM_NON_REF_PIC || dpb->buffers[i]->forOutput) {

      dpb->buffers[numFrm] = dpb->buffers[i];

      numFrm++;

    }

    else {

      /* Put unsused pics to temporary list */

      tmpRemList[numRemFrm] = dpb->buffers[i];

      numRemFrm++;

    }

  }

  /* Copy unused pics after active pics */

  for (i = 0; i < numRemFrm; i++)

    dpb->buffers[numFrm+i] = tmpRemList[i];

  dpb->fullness = numFrm;

  /*

   * Try to store current pic to dpb. If there is no room in dpb, we have to

   * output some pictures to make room.

   */

  /* Case 1: if current pic is unused, it won't be stored in dpb */

  if (currPic->refType == FRM_NON_REF_PIC && !currPic->forOutput) {

    return 0;

  }

  /* Case 2: if there is space left in dpb, store current pic */

  if (dpb->fullness < dpb->size) {

    tmpFrm = dpb->buffers[dpb->fullness];   /* Unused frame */

    tmpFrm = frmMakeRefFrame(currPic, tmpFrm);

    if (tmpFrm == NULL)

      return DPB_ERR_MEM_ALLOC;

    /* Move frames one position toward end of the list */

    for (i = dpb->fullness; i > 0; i--)

      dpb->buffers[i] = dpb->buffers[i-1];

    /* Always insert new frame to the beginning of the list */

    dpb->buffers[0] = tmpFrm;

    dpb->fullness++;

    if (currPic->refType == FRM_SHORT_TERM_PIC)

      dpb->numShortTermPics++;

    else if (currPic->refType == FRM_LONG_TERM_PIC)

      dpb->numLongTermPics++;

    /* Current picture is marked unused */

    currPic->forOutput = 0;

    currPic->refType   = FRM_NON_REF_PIC;

    /* No pictures in ouput queue */

    return 0;

  }

  /* Case 3: output pictures with bumping process until there is space in dpb or

  *  current pic is non-reference and has lowest poc */

  freeBufferFound = 0;

  numOutput       = 0;

  while (!freeBufferFound) {

    /* Next picture to output is a picture having smallest POC in DPB */

    tmpFrm = dpbGetNextOutputPic(dpb, &dpbHasIDRorMMCO5);

    /* Current picture is output if it is non-reference picture having */

    /* smaller POC than any of the pictures in DPB                     */

    if (currPic->refType == FRM_NON_REF_PIC &&

        (tmpFrm == 0 || (!dpbHasIDRorMMCO5 && currPic->poc < tmpFrm->poc)))

    {

      /* Output current picture  */

      currPic->forOutput = 0;

      outputQueue[numOutput] = currPic;

      numOutput++;

      freeBufferFound = 1;

    }

    else {

      /* Output picture that we got from DPB */

      tmpFrm->forOutput = 0;

      outputQueue[numOutput] = tmpFrm;

      numOutput++;

      if (tmpFrm->refType == FRM_NON_REF_PIC)

        freeBufferFound = 1;

    }

  }

  return numOutput;

}

/*

 *

 * dpbUpdatePicNums:

 *

 * Parameters:

 *      dpb                   DPB object

 *      frameNum              Current picture frame number

 *      maxFrameNum           Maximum frame number

 *

 * Function:

 *      Compute picture numbers for all pictures in DPB.

 *

 * Returns:

 *      -

 *

 */

void dpbUpdatePicNums(dpb_s *dpb, int32 frameNum, int32 maxFrameNum)

{

  int i;

  frmBuf_s **refPicList;

  refPicList = dpb->buffers;

  for (i = 0; i < dpb->fullness; i++) {

    if (refPicList[i]->refType == FRM_SHORT_TERM_PIC) {

      /* Short term pictures */

      if (refPicList[i]->frameNum > frameNum)

        refPicList[i]->picNum = refPicList[i]->frameNum - maxFrameNum;

      else

        refPicList[i]->picNum = refPicList[i]->frameNum;

    }

    else if (refPicList[i]->refType == FRM_LONG_TERM_PIC)

      /* Long term pictures */

      refPicList[i]->longTermPicNum = refPicList[i]->longTermFrmIdx;

  }

}

/*

 *

 * dpbMarkAllPicsAsNonRef:

 *

 * Parameters:

 *      dpb                   DPB object

 *

 * Function:

 *      Mark all picrures as non-reference pictures.

 *

 * Returns:

 *      -

 *

 */

void dpbMarkAllPicsAsNonRef(dpb_s *dpb)

{

  int i;

  /* Mark all pictures as not used for reference */

  for (i = 0; i < dpb->fullness; i++)

    dpb->buffers[i]->refType = FRM_NON_REF_PIC;

  dpb->numShortTermPics = 0;

  dpb->numLongTermPics  = 0;

}

/*

 *

 * dpbMarkLowestShortTermPicAsNonRef:

 *

 * Parameters:

 *      dpb                   DPB object

 *

 * Function:

 *      Mark short-term picture having lowest picture number as

 *      non-reference pictures.

 *

 * Returns:

 *      -

 *

 */

void dpbMarkLowestShortTermPicAsNonRef(dpb_s *dpb)

{

  int picIdx;

  int i;

  /* Find short term pic with lowest picNum */

  picIdx = -1;

  for (i = dpb->fullness-1; i >= 0; i--) {

    if (dpb->buffers[i]->refType == FRM_SHORT_TERM_PIC &&

        (picIdx < 0 || dpb->buffers[i]->picNum < dpb->buffers[picIdx]->picNum))

      picIdx = i;

  }

  /* Mark short term pic with lowest picNum as not reference picture */

  if (picIdx >= 0) {

    dpb->buffers[picIdx]->refType = FRM_NON_REF_PIC;

    dpb->numShortTermPics--;

  }

}

/*

 *

 * dpbMarkShortTermPicAsNonRef:

 *

 * Parameters:

 *      dpb                   DPB object

 *      picNum                Picture number

 *

 * Function:

 *      Mark short-term picture having picture number picNum as

 *      non-reference picture.

 *

 * Returns:

 *      DPB_OK or DPB_ERR_PICTURE_NOT_FOUND

 *

 */

int dpbMarkShortTermPicAsNonRef(dpb_s *dpb, int32 picNum)

{

  int i;

  for (i = 0; i < dpb->fullness; i++) {

    if (dpb->buffers[i]->refType == FRM_SHORT_TERM_PIC &&

        dpb->buffers[i]->picNum == picNum)

    {

      dpb->buffers[i]->refType = FRM_NON_REF_PIC;

      dpb->numShortTermPics--;

      return DPB_OK;

    }

  }

  return DPB_ERR_PICTURE_NOT_FOUND;

}

/*

 *

 * dpbMarkLongTermPicAsNonRef:

 *

 * Parameters:

 *      dpb                   DPB object

 *      longTermPicNum        Long-term picture number

 *

 * Function:

 *      Mark long-term picture having long-term picture number longTermPicNum

 *      as non-reference picture.

 *

 * Returns:

 *      DPB_OK or DPB_ERR_PICTURE_NOT_FOUND

 *

 */

int dpbMarkLongTermPicAsNonRef(dpb_s *dpb, int longTermPicNum)

{

  int i;

  for (i = 0; i < dpb->fullness; i++) {

    if (dpb->buffers[i]->refType == FRM_LONG_TERM_PIC &&

        dpb->buffers[i]->longTermPicNum == longTermPicNum)

    {

      dpb->buffers[i]->refType = FRM_NON_REF_PIC;

      dpb->numLongTermPics--;

      return DPB_OK;

    }

  }

  return DPB_ERR_PICTURE_NOT_FOUND;

}

/*

 *

 * dpbVerifyLongTermFrmIdx:

 *

 * Parameters:

 *      dpb                   DPB object

 *      longTermFrmIdx        Long-term frame index

 *

 * Function:

 *      If there is a long-term picture having long term frame index

 *      longTermFrmIdx, mark that picture as non-reference picture.

 *

 * Returns:

 *      -

 *

 */

void dpbVerifyLongTermFrmIdx(dpb_s *dpb, int longTermFrmIdx)

{

  int i;

  /* Check if longTermFrmIdx is already in use */

  for (i = 0; i < dpb->fullness; i++) {

    if (dpb->buffers[i]->refType == FRM_LONG_TERM_PIC &&

        dpb->buffers[i]->longTermFrmIdx == longTermFrmIdx)

    {

      dpb->buffers[i]->refType = FRM_NON_REF_PIC;

      dpb->numLongTermPics--;

      break;

    }

  }

}

/*

 *

 * dpbMarkShortTermPicAsLongTerm:

 *

 * Parameters:

 *      dpb                   DPB object

 *      picNum                Picture number

 *      longTermFrmIdx        Long-term frame index

 *

 * Function:

 *      Mark short-term picture having picture number picNum as long-term

 *      picture having long-term frame index longTermFrmIdx.

 *

 * Returns:

 *      DPB_OK or DPB_ERR_PICTURE_NOT_FOUND

 *

 */

int dpbMarkShortTermPicAsLongTerm(dpb_s *dpb, int32 picNum, int longTermFrmIdx)

{

  int i;

  /* To avoid duplicate of longTermFrmIdx */

  dpbVerifyLongTermFrmIdx(dpb, longTermFrmIdx);

  /* Mark pic with picNum as long term and assign longTermFrmIdx to it */

  for (i = 0; i < dpb->fullness; i++) {

    if (dpb->buffers[i]->refType == FRM_SHORT_TERM_PIC &&

        dpb->buffers[i]->picNum == picNum)