/*

* 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 "bitbuffer.h"

#include "vld.h"

#include "macroblock.h"

#include "parameterset.h"

#include "framebuffer.h"

#include "dpb.h"

#include "slice.h"

#include "sequence.h"

#define MIN_ALPHA_BETA_OFFSET   -6

#define MAX_ALPHA_BETA_OFFSET   6

/*

 * AVC syntax functions as specified in specification

 */

/*

 * Static functions

 */

static int getRefPicListReorderingCmds(slice_s *slice, unsigned int numRefFrames,

                                       bitbuffer_s *bitbuf);

static int getDecRefPicMarkingCmds(slice_s *slice, unsigned int numRefFrames,

                                   bitbuffer_s *bitbuf);

static int refPicListReordering(slice_s *slice, dpb_s *dpb,

                                 frmBuf_s *refPicList[], int numRefPicActive,

                                 sliceRefPicListReorderCmd_s reorderCmdList[]);

/*

 * AVC syntax functions as specified in specification

 */

/* Return fixed length code */

static int u_n(bitbuffer_s *bitbuf, int len, unsigned int *val)

{

  *val = vldGetFLC(bitbuf, len);

  if (bibGetStatus(bitbuf) < 0)

    return SLICE_ERROR;

  return SLICE_OK;

}

/* Return unsigned UVLC code */

static int ue_v(bitbuffer_s *bitbuf, unsigned int *val, unsigned int maxVal)

{

  *val = vldGetUVLC(bitbuf);

  if (bibGetStatus(bitbuf) < 0)

    return SLICE_ERROR;

  if (*val > maxVal)

    return SLICE_ERR_ILLEGAL_VALUE;

  return SLICE_OK;

}

/* Return signed UVLC code */

static int se_v(bitbuffer_s *bitbuf, int *val, int minVal, int maxVal)

{

  *val = vldGetSignedUVLC(bitbuf);

  if (bibGetStatus(bitbuf) < 0)

    return SLICE_ERROR;

  if (*val < minVal || *val > maxVal)

    return SLICE_ERR_ILLEGAL_VALUE;

  return SLICE_OK;

}

/* Return long signed UVLC code */

static int se_v_long(bitbuffer_s *bitbuf, int32 *val)

{

  *val = vldGetSignedUVLClong(bitbuf);

  if (bibGetStatus(bitbuf) < 0)

    return SLICE_ERROR;

  return SLICE_OK;

}

/*

 *

 * sliceOpen:

 *

 * Parameters:

 *

 * Function:

 *      Allocate and initialize a slice.

 *

 * Returns:

 *      Pointer to slice

 *

 */

slice_s *sliceOpen()

{

  slice_s *slice;

  slice = (slice_s *)User::Alloc(sizeof(slice_s));

  if (slice != NULL)

    memset(slice, 0, sizeof(slice_s));

  return slice;

}

/*

 *

 * sliceClose:

 *

 * Parameters:

 *      slice                 Slice object

 *

 * Function:

 *      Deallocate slice

 *

 * Returns:

 *      Nothing

 *

 */

void sliceClose(slice_s *slice)

{

  User::Free(slice);

}

/*

 * getRefPicListReorderingCmds:

 *

 * Parameters:

 *     slice               Slice object

 *     bitbuf              Bitbuffer object

 *     numRefFrames        Number of reference frames in used

 *

 * Function:

 *     Parse and store the ref pic reordering commands

 *

 * Return:

 *     The number of bits being parsed

 */

static int getRefPicListReorderingCmds(slice_s *slice, unsigned int numRefFrames,

                                       bitbuffer_s *bitbuf)

{

  int i;

  unsigned int reordering_of_pic_nums_idc;

  int retCode;

  if (!IS_SLICE_I(slice->slice_type)) {

    if ((retCode = u_n(bitbuf, 1, &slice->ref_pic_list_reordering_flag0)) < 0)

      return retCode;

    if (slice->ref_pic_list_reordering_flag0) {

      i = 0;

      do {

        /* Get command */

        if ((retCode = ue_v(bitbuf, &reordering_of_pic_nums_idc, 3)) < 0)

          return retCode;

        slice->reorderCmdList[i].reordering_of_pic_nums_idc = reordering_of_pic_nums_idc;

        /* Get command parameters */

        if (reordering_of_pic_nums_idc == 0 || reordering_of_pic_nums_idc == 1) {

          unsigned int maxDiff = slice->maxFrameNum/2-1;

          if (reordering_of_pic_nums_idc == 1)

            maxDiff = maxDiff - 1;

          if ((retCode = ue_v(bitbuf, &slice->reorderCmdList[i].abs_diff_pic_num_minus1, maxDiff)) < 0)

            return retCode;

        }

        else if (reordering_of_pic_nums_idc == 2) {

          /* longTermPicNum be in the range of 0 to num_ref_frames, inclusive. */

          if ((retCode = ue_v(bitbuf, &slice->reorderCmdList[i].long_term_pic_num, numRefFrames)) < 0)

            return retCode;

        }

        i++;

      } while (reordering_of_pic_nums_idc != 3 && i < MAX_NUM_OF_REORDER_CMDS);

    }

  }

  return SLICE_OK;

}

/*

 * getDecRefPicMarkingCmds:

 *

 * Parameters:

 *     slice               Slice object

 *     bitbuf              Bitbuffer object

 *     numRefFrames        Number of reference frames in used

 *

 * Function:

 *     Parse and store the MMCO commands

 *

 * Return:

 *     The number of bits being parsed

 */

static int getDecRefPicMarkingCmds(slice_s *slice, unsigned int numRefFrames,

                                   bitbuffer_s *bitbuf)

{

  int i;

  unsigned int mmco;

  int retCode;

  /* MMCO commands can exist only in slice header of a reference picture */

  if (slice->nalRefIdc != 0) {

    if (slice->isIDR) {

      if ((retCode = u_n(bitbuf, 1, &slice->no_output_of_prior_pics_flag)) < 0)

        return retCode;

      if ((retCode = u_n(bitbuf, 1, &slice->long_term_reference_flag)) < 0)

        return retCode;

    }

    else {

      if ((retCode = u_n(bitbuf, 1, &slice->adaptive_ref_pic_marking_mode_flag)) < 0)

        return retCode;

      if (slice->adaptive_ref_pic_marking_mode_flag) {

        i = 0;

        do {

          /* Get MMCO command */

          if ((retCode = ue_v(bitbuf, &mmco, 6)) < 0)

            return retCode;

          slice->mmcoCmdList[i].memory_management_control_operation = mmco;

          /* Get command parameter (if any) */

          if (mmco == 1 || mmco == 3) {

            if ((retCode = ue_v(bitbuf, &slice->mmcoCmdList[i].difference_of_pic_nums_minus1, 65535)) < 0)

              return retCode;

          }

          if (mmco == 2) {

            if ((retCode = ue_v(bitbuf, &slice->mmcoCmdList[i].long_term_pic_num, numRefFrames)) < 0)

              return retCode;

          }

          if (mmco == 3 || mmco == 6) {

            if ((retCode = ue_v(bitbuf, &slice->mmcoCmdList[i].long_term_frame_idx, numRefFrames)) < 0)

              return retCode;

          }

          if (mmco == 4) {

            if ((retCode = ue_v(bitbuf, &slice->mmcoCmdList[i].max_long_term_frame_idx_plus1, numRefFrames)) < 0)

              return retCode;

          }

          if (mmco == 5) {

            slice->picHasMMCO5 = 1;

          }

          i++;

        } while (mmco != 0 && i < MAX_NUM_OF_MMCO_OPS);

      }

    }

  }

  else

    slice->adaptive_ref_pic_marking_mode_flag = 0;

  return 1;

}

/*

 * sliceInitRefPicList:

 *

 * Parameters:

 *     dpb                  DPB buffer

 *     refPicList           Reference picture list (output)

 *

 * Fucntion:

 *     Initialize reference picture list.

 *

 * Return:

 *     Number of reference frames in the list

 */

int sliceInitRefPicList(dpb_s *dpb, frmBuf_s *refPicList[])

{

  int numRef, numShort;

  frmBuf_s *refTmp;

  int i, j;

  /*

   * Select the reference pictures from the DPB

   */

  j = 0;

  /* Put short term pictures first in the list */

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

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

      refPicList[j++] = dpb->buffers[i];

  }

  numShort = j;

  /* Put long term pictures after the short term pictures */

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

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

      refPicList[j++] = dpb->buffers[i];

  }

  numRef = j;

  /* numLong = numRef - numShort; */

  /*

   * Initialisation process for reference picture lists

   */

  /* Sort short term pictures in the order of descending picNum */

  for (i = 0; i < numShort; i++) {

    for (j = i+1; j < numShort; j++) {

      if (refPicList[i]->picNum < refPicList[j]->picNum) {

        /* exchange refPicList[i] and refPicList[j] */

        refTmp = refPicList[i];

        refPicList[i] = refPicList[j];

        refPicList[j] = refTmp;

      }

    }

  }

  /* Sort long term pictures in the order of ascending longTermPicNum */

  for (i = numShort; i < numRef; i++) {

    for (j = i+1; j < numRef; j++) {

      if (refPicList[i]->longTermPicNum > refPicList[j]->longTermPicNum) {

        /* exchange refPicList[i] and refPicList[j] */

        refTmp = refPicList[i];

        refPicList[i] = refPicList[j];

        refPicList[j] = refTmp;

      }

    }

  }

  return numRef;

}

/*

 * sliceFixRefPicList:

 *

 * Parameters:

 *     dpb                  DPB buffer

 *     refPicList           Reference picture list (output)

 *     numRefPicActive      Number of active reference frames

 *     numExistingRefFrames Number of reference frames in refPicList

 *

 * Fucntion:

 *     If numExistingRefFrames < numRefPicActive, try to fill up the

 *     reference frame list

 *

 * Return:

 *     0 for no pictures exist in reference frame list

 *     1 for pictures exist in reference frame list

 */

int sliceFixRefPicList(dpb_s *dpb, frmBuf_s *refPicList[],

                       int numRefPicActive, int numExistingRefFrames,

                       int width, int height)

{

  int i;

  if (numExistingRefFrames == 0) {

    /* Try to find any picture in DPB, even non-reference frame */

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

      if (dpb->buffers[i] != NULL && dpb->buffers[i]->width == width && dpb->buffers[i]->height == height)

        break;

    }

    if (i < dpb->size) {

      refPicList[0] = dpb->buffers[i];

      numExistingRefFrames = 1;

    }

    else

      return 0;

  }

  /* Duplicate last extry of the reference frame list so that list becomes full */

  for (i = numExistingRefFrames; i < numRefPicActive; i++)

    refPicList[i] = refPicList[numExistingRefFrames-1];

  return 1;

}

/*

 * refPicListReordering:

 *

 * Parameters:

 *     slice                Current slice object

 *     dpb                  DPB buffer

 *     refPicList           Reference picture list (modified by this function)

 *     numRefPicActive      Number of active reference frames

 *     reorderCmdList       Reordering command list

 *

 * Fucntion:

 *     Reorder the reference picture list for current slice

 *

 * Return:

 *     SLICE_OK for no error and negative value for error

 */

static int refPicListReordering(slice_s *slice, dpb_s *dpb,

                                frmBuf_s *refPicList[], int numRefPicActive,

                                sliceRefPicListReorderCmd_s reorderCmdList[])

{

  int i;

  int reordering_of_pic_nums_idc, longTermPicNum;

  int32 absDiffPicNum;

  int refIdx;

  int32 currPicNum, picNumPred, picNumNoWrap;

  int32 maxPicNum, picNum;

  int cmdNum;

  int cIdx, nIdx;

  /*

   * 3. Reordering process for reference picture list

   */

  maxPicNum = slice->maxFrameNum;   /* for frame coding only */

  currPicNum = slice->frame_num;

  picNumPred = currPicNum;

  refIdx = 0;

  cmdNum = 0;

  do {

    reordering_of_pic_nums_idc = reorderCmdList[cmdNum].reordering_of_pic_nums_idc;

    if (reordering_of_pic_nums_idc == 0 || reordering_of_pic_nums_idc == 1) {

      /*

       * reorder short-term ref pic  -subclause 8.2.4.3.1

       */

      absDiffPicNum = reorderCmdList[cmdNum].abs_diff_pic_num_minus1 + 1;

      /* Derive picNumNoWrap */

      if (reordering_of_pic_nums_idc == 0) {

        if (picNumPred - absDiffPicNum < 0)

          picNumNoWrap = picNumPred - absDiffPicNum + maxPicNum;

        else

          picNumNoWrap = picNumPred - absDiffPicNum;

      }

      else { /* reordering_of_pic_nums_idc == 1 */

        if (picNumPred + absDiffPicNum >= maxPicNum) 

          picNumNoWrap = picNumPred + absDiffPicNum - maxPicNum;

        else

          picNumNoWrap = picNumPred + absDiffPicNum;

      }

      /* Derive picNum */

      if (picNumNoWrap > currPicNum)

        picNum = picNumNoWrap - maxPicNum;

      else

        picNum = picNumNoWrap;

      /* Find short term picture with picture number picNum */

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

        if (!dpb->buffers[i]->nonExisting &&

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

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

          break;

      }

      /* If picNum was not found */

      if (i == dpb->fullness) {

        PRINT((_L("The short term ref pic(%d) is not found!\n"), picNum));

        return SLICE_ERR_ILLEGAL_VALUE;

      }

      /* Shift remaining pictures later in the list */

      for (cIdx = numRefPicActive; cIdx > refIdx; cIdx--)

        refPicList[cIdx] = refPicList[cIdx - 1];

      /* Place picture with number picNum into the index position refIdx */

      refPicList[refIdx++] = dpb->buffers[i];

      /* Remove duplicate of the inserted picture */

      nIdx = refIdx;

      for (cIdx = refIdx; cIdx <= numRefPicActive; cIdx++)

        if (refPicList[cIdx]->refType == FRM_LONG_TERM_PIC || refPicList[cIdx]->picNum != picNum)

          refPicList[nIdx++] = refPicList[cIdx];

      picNumPred = picNumNoWrap;

    }

    else if (reordering_of_pic_nums_idc == 2) {

      /*

       * reorder long-term ref pic  -subclause 8.2.4.3.2

       */

      /* Get long-term picture number */

      longTermPicNum = reorderCmdList[cmdNum].long_term_pic_num;

      /* Find long-term picture with picture number longTermPicNum */

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

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

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

          break;

      if (i == dpb->fullness) {

        // something wrong !

        PRINT((_L("The long term ref pic(%d) is not found!\n"), longTermPicNum));

        return SLICE_ERR_ILLEGAL_VALUE;

      }

      /* Shift remaining pictures later in the list */

      for (cIdx = numRefPicActive; cIdx > refIdx; cIdx--)

        refPicList[cIdx] = refPicList[cIdx - 1];

      /* Place picture with number longTermPicNum into the index position refIdx */