/*

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

#include "bitbuffer.h"

#include "vld.h"

#include "framebuffer.h"

#include "avcdapi.h"

#include "parameterset.h"

#include "dpb.h"

#include "sequence.h"

#define SEQ_OK                      0

#define SEQ_ERROR                  -1

#define SEQ_ERR_MEM                -2

#define SEQ_ERR_GAPS_IN_FRAME_NUM  -3

#define SEQ_ERR_DPB_CORRUPTED      -4

// Definitions of SEI types

#define SEI_TYPE_SCENE_INFO       9

#ifdef CHECK_MV_RANGE

int maxVerticalMvRange;

#endif

void GenerateEmptyFrame(sequence_s *seq, bitbuffer_s *bitbuf, TUint aFrameNumber);

/*

 * setLower4Bits:

 *

 * Parameters:

 *      value               the destination to store the 4 bits

 *      bits                the 4 bits to be copied

 *

 * Function:

 *      Assign the value to the lowest 4 bits

 *

 *  Return:

 *      -

 */

#define setLower4Bits(value, bits) (value) = ((value) & ~0xF) | ((bits))

/*

 *

 * avcdOpen:

 *

 * Parameters:

 *      -

 *

 * Function:

 *      Open AVC decoder.

 *      

 * Returns:

 *      Pointer to initialized avcdDecoder_t object

 */

avcdDecoder_t *avcdOpen()

{

  sequence_s *seq;

  // Allocate sequence object

  if ((seq = (sequence_s *)User::Alloc(sizeof(sequence_s))) == NULL)

    return NULL;

  memset(seq, 0, sizeof(sequence_s));

  // Open bitbuffer

  if ((seq->bitbuf = bibOpen()) == NULL)

    return NULL;

  seq->isFirstSliceOfSeq       = 1;

  seq->unusedShortTermFrameNum = -1;

#ifdef VIDEOEDITORENGINE_AVC_EDITING

  // Open slices

  if ((seq->currSlice = sliceOpen()) == NULL)

    return NULL;

  if ((seq->nextSlice = sliceOpen()) == NULL)

    return NULL;

  // Open dpb

  if ((seq->dpb = dpbOpen()) == NULL)

    return NULL;

	seq->iFrameNumber = 0;

	seq->iFromEncoder = 0;

	seq->iEncodeUntilIDR = 0;

	seq->iBitShiftInSlice = 0;

	seq->iPreviousPPSId = 0;

	seq->iNumSPS = 0;

	seq->iNumPPS = 0;

	seq->iTotalFrameNumber = 0;

#endif  // VIDEOEDITORENGINE_AVC_EDITING

  return seq;

}

/*

 *

 * avcdClose:

 *

 * Parameters:

 *      seq                   Sequence object

 *

 * Function:

 *      Close sequence.

 *      

 * Returns:

 *      -

 */

void avcdClose(avcdDecoder_t *dec)

{

  sequence_s *seq = (sequence_s *)dec;

  /* Close bitbuffer */

  bibClose(seq->bitbuf);

  /* Close parameter sets */

  psCloseParametersSets(seq->spsList, seq->ppsList);

#ifdef VIDEOEDITORENGINE_AVC_EDITING

  /* Close current frame */

  frmClose(seq->recoBuf, seq->mbData);

  /* Close decoded picture buffer */

  dpbClose(seq->dpb);

  /* Close slices */

  sliceClose(seq->currSlice);

  sliceClose(seq->nextSlice);

#endif  // VIDEOEDITORENGINE_AVC_EDITING

  User::Free(seq);

}

/*

 *

 * initSPSParsing

 *

 * Parameters:

 *      dec                   Sequence object

 *      nauUnitBits           Buffer containing SPS NAL unit

 *      nalUnitLen            Length of buffer

 *

 * Function:

 *      Initialises bit buffer for parsing, checks

 *      nal_unit_type

 *      

 * Returns:

 *      KErrNone for no error, negative value for error

 */

TInt initSPSParsing(avcdDecoder_t *dec, void *nalUnitBits, TUint* nalUnitLen)

{

    sequence_s *seq = (sequence_s *)dec;

    TInt nalHeaderByte;

    TInt nalType;

    TUint nalUnitLength = *nalUnitLen;

    // tempData allocation

    TUint8* tempData = (TUint8*) User::Alloc(nalUnitLength);

  	if (!tempData)

  	    return KErrNoMemory;

  	Mem::Copy(tempData, nalUnitBits, nalUnitLength);  	  	

    if (bibInit(seq->bitbuf, tempData, nalUnitLength) < 0)

    {

        User::Free(seq->bitbuf->data);

        return AVCD_ERROR;

    }

    if (bibGetByte(seq->bitbuf, &nalHeaderByte))

    {

        User::Free(seq->bitbuf->data);

        return AVCD_ERROR;

    }

    // Decode NAL unit type

    nalType   = nalHeaderByte & 0x1F;    

    if (nalType != NAL_TYPE_SPS)

    {

        User::Free(seq->bitbuf->data);

        return AVCD_ERROR;

    }

    return KErrNone;

}

/*

 *

 * avcdParseLevel

 *

 * Parameters:

 *      dec                   Sequence object

 *      nauUnitBits           Buffer containing SPS NAL unit

 *      nalUnitLen            Length of buffer

 *      aLevel                [output]Parsed level

 *

 * Function:

 *      Parses AVC level from SPS

 *      

 * Returns:

 *      KErrNone for no error, negative value for error

 */

TInt avcdParseLevel(avcdDecoder_t *dec, void *nalUnitBits, TUint* nalUnitLen, TInt& aLevel)                    

{

    TInt error = initSPSParsing(dec, nalUnitBits, nalUnitLen);

    if (error < 0)

    	return AVCD_ERROR;

    sequence_s *seq = (sequence_s *)dec;

    error = psParseLevelFromSPS(seq->bitbuf, aLevel);

    User::Free(seq->bitbuf->data);

    if (error < 0)

    	return AVCD_ERROR;

    return KErrNone;    	    

}

/*

 *

 * avcdParseResolution

 *

 * Parameters:

 *      dec                   Sequence object

 *      nauUnitBits           Buffer containing SPS NAL unit

 *      nalUnitLen            Length of buffer

 *      aResolution           [output]Parsed resolution

 *

 * Function:

 *      Parses resolution from SPS

 *      

 * Returns:

 *      KErrNone for no error, negative value for error

 */

TInt avcdParseResolution(avcdDecoder_t *dec, void *nalUnitBits, TUint* nalUnitLen, 

                         TInt& aWidth, TInt& aHeight)

{

    TInt error = initSPSParsing(dec, nalUnitBits, nalUnitLen);

    if (error < 0)

    	return AVCD_ERROR;

    sequence_s *seq = (sequence_s *)dec;

    error = psDecodeSPS(seq->bitbuf, seq->spsList, aWidth, aHeight);

    User::Free(seq->bitbuf->data);

    if (error < 0)

    	return AVCD_ERROR;

    return KErrNone;    	    

}

#ifdef VIDEOEDITORENGINE_AVC_EDITING

/*

 *

 * slidingWindowDecRefPicMarking:

 *

 * Parameters:

 *      seq                   Sequence object

 *

 * Function:

 *      Sliding window decoded reference picture marking. Reference pictures

 *      in dpb are marked based on first in first out principle.

 *      

 * Returns:

 *      SEQ_OK for no error, negative value for error

 */

static int slidingWindowDecRefPicMarking(sequence_s *seq)

{

  dpb_s *dpb;

  int numRefPics;

  dpb = seq->dpb;

  numRefPics = dpb->numShortTermPics + dpb->numLongTermPics;

  /* If dpb contains maximum number of reference pitures allowed, short */

  /*  term reference picture with lowest picture number is removed.     */

  if (numRefPics == dpb->maxNumRefFrames) {

    if (dpb->numShortTermPics == 0) {

      PRINT((_L("numShortTerm must be greater than zero\n")));

      return SEQ_ERR_DPB_CORRUPTED;

    }

    dpbMarkLowestShortTermPicAsNonRef(dpb);

  }

  return SEQ_OK;

}

/*

 *

 * adaptiveDecRefPicMarking:

 *

 * Parameters:

 *      seq                   Sequence object

 *

 * Function:

 *      Adaptive decoded reference picture marking. Reference pictures in dpb

 *      are marked based on memory management command operations that were

 *      decoded in slice header earlier.

 *      

 * Returns:

 *      SEQ_OK for no error, SEQ_ERR_DPB_CORRUPTED for error in DPB

 */

static int adaptiveDecRefPicMarking(sequence_s *seq)

{

  dpb_s *dpb;

  sliceMMCO_s *mmcoCmdList;

  int32 currPicNum, picNumX;

  int i;

  dpb = seq->dpb;

  currPicNum = seq->currSlice->frame_num;

  mmcoCmdList = seq->currSlice->mmcoCmdList;

  i = 0;

  do {

    switch (mmcoCmdList[i].memory_management_control_operation) {

      case 1:

        picNumX = currPicNum - (mmcoCmdList[i].difference_of_pic_nums_minus1 + 1);

        if (dpbMarkShortTermPicAsNonRef(dpb, picNumX) < 0)

          return SEQ_ERR_DPB_CORRUPTED;

        break;

      case 2:

        if (dpbMarkLongTermPicAsNonRef(dpb, mmcoCmdList[i].long_term_pic_num) < 0)

          return SEQ_ERR_DPB_CORRUPTED;

        break;

      case 3:

        picNumX = currPicNum - (mmcoCmdList[i].difference_of_pic_nums_minus1 + 1);

        if (dpbMarkShortTermPicAsLongTerm(dpb, picNumX, mmcoCmdList[i].long_term_frame_idx) < 0)

          return SEQ_ERR_DPB_CORRUPTED;

        break;

      case 4:

        dpbSetMaxLongTermFrameIdx(dpb, mmcoCmdList[i].max_long_term_frame_idx_plus1);

        break;

      case 5:

        dpbMarkAllPicsAsNonRef(dpb);

        dpb->maxLongTermFrameIdx = -1;

        break;

      case 6:

        /* To avoid duplicate of longTermFrmIdx */

        dpbVerifyLongTermFrmIdx(dpb, mmcoCmdList[i].long_term_frame_idx);

        seq->recoBuf->refType        = FRM_LONG_TERM_PIC;

        seq->recoBuf->longTermFrmIdx = mmcoCmdList[i].long_term_frame_idx;

        break;

    }

    i++;

  } while (mmcoCmdList[i].memory_management_control_operation != 0 && i < MAX_NUM_OF_MMCO_OPS);

  return SEQ_OK;

}

/*

 *

 * decRefPicMarking:

 *

 * Parameters:

 *      seq                   Sequence object

 *

 * Function:

 *      Decoded reference picture marking. Reference pictures in dpb are marked

 *      differently depending on whether current picture is IDR picture or not

 *      and whether it is reference picture or non-reference picture.

 *      If current picture is non-IDR reference picture, reference pictures are

 *      marked with either sliding window marking process or adaptive marking

 *      process depending on the adaptiveRefPicMarkingModeFlag flag.

 *      

 * Returns:

 *      -

 */

static int decRefPicMarking(sequence_s *seq)

{

  slice_s *slice;

  frmBuf_s *recoBuf;

  slice = seq->currSlice;

  recoBuf = seq->recoBuf;

  recoBuf->refType  = FRM_SHORT_TERM_PIC;

  recoBuf->frameNum = slice->frame_num;

  recoBuf->hasMMCO5 = slice->picHasMMCO5;

  recoBuf->isIDR    = slice->isIDR;

  if (slice->isIDR) {

    recoBuf->idrPicID = slice->idr_pic_id;

    /* All reference frames are marked as non-reference frames */

    dpbMarkAllPicsAsNonRef(seq->dpb);

    /* Set reference type for current picture */

    if (!slice->long_term_reference_flag) {

      seq->dpb->maxLongTermFrameIdx = -1;

    }

    else {

      recoBuf->refType         = FRM_LONG_TERM_PIC;

      recoBuf->longTermFrmIdx  = 0;

      seq->dpb->maxLongTermFrameIdx = 0;

    }

  }

  else if (slice->nalRefIdc != 0) {

    if (!slice->adaptive_ref_pic_marking_mode_flag)

      return slidingWindowDecRefPicMarking(seq);

    else

      return adaptiveDecRefPicMarking(seq);

  }

  else

    recoBuf->refType  = FRM_NON_REF_PIC;

  return SEQ_OK;

} 

/*

 *

 * buildSliceGroups:

 *

 * Parameters:

 *      seq                   Sequence object

 *      slice                 Slice object

 *      sps                   Sequence parameter set

 *      pps                   Picture parameter set

 *

 * Function:

 *      Build slice group map. Syntax elements for slice groups are

 *      in active picture parameter set.

 *      

 * Returns:

 *      -

 *

 */

static void buildSliceGroups(sequence_s* seq, slice_s *slice,

                             seq_parameter_set_s *sps, pic_parameter_set_s *pps)

{

  int xTopLeft, yTopLeft;

  int xBottomRight, yBottomRight;

  int x, y;

  int leftBound, topBound;

  int rightBound, bottomBound;

  int xDir, yDir;

  int mapUnitsInSliceGroup0;

  int mapUnitVacant;

  int sizeOfUpperLeftGroup;

  int iGroup, picSizeInMapUnits;

  int picWidthInMbs, picHeightInMapUnits;

  int i, j, k;

  int *sliceMap;

  sliceMap = seq->mbData->sliceMap;

  picWidthInMbs = sps->pic_width_in_mbs_minus1+1;

  picHeightInMapUnits = sps->pic_height_in_map_units_minus1+1;

  picSizeInMapUnits = picWidthInMbs * picHeightInMapUnits;

  if (pps->num_slice_groups_minus1 == 0) {

    /* Only one slice group */

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

      sliceMap[i] = 0;

  }

  else {

    /* There are more than one slice groups in this picture */

    switch (pps->slice_group_map_type) {

    case PS_SLICE_GROUP_MAP_TYPE_INTERLEAVED:

      i = 0;

      do {

        for (iGroup = 0; iGroup <= (int)pps->num_slice_groups_minus1 && i < picSizeInMapUnits;

          i += pps->run_length_minus1[iGroup++] + 1)

        {

          for (j = 0; j <= (int)pps->run_length_minus1[iGroup] && i+j < picSizeInMapUnits; j++)

            sliceMap[i+j] = iGroup;   /* Only the group number */

        }

      } while (i < picSizeInMapUnits);

      break;

    case PS_SLICE_GROUP_MAP_TYPE_DISPERSED:

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

        sliceMap[i] = ( ( i % picWidthInMbs ) + 

        ( ( ( i / picWidthInMbs ) * ( pps->num_slice_groups_minus1 + 1 ) ) / 2 ) )