/*

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

#include "parameterset.h"

#define MIN_CHROMA_QP_INDEX           -12

#define MAX_CHROMA_QP_INDEX            12

#define NUM_LEVELS                     16     /* The number of AVC levels */

#define MAX_PIC_SIZE_IN_MBS            36864

#define MAX_PIC_WIDTH_IN_MBS           543    /* Sqrt( MAX_PIC_SIZE_IN_MBS * 8 ) */

#define MAX_PIC_HEIGHT_IN_MBS          543    /* Sqrt( MAX_PIC_SIZE_IN_MBS * 8 ) */

/* These fields are defined in Annex A of the standard */

typedef struct _level_s 

{

  int8 levelNumber;

  int8 constraintSet3flag;

  int32 maxMBPS;

  int32 maxFS;

  int32 maxDPB;

  int32 maxBR;

  int32 maxCPB;

  int16 maxVmvR;

  int8 minCR;

  int8 maxMvsPer2Mb;

} level_s;

/* Parameters for all levels */

static const level_s levelArray[NUM_LEVELS] = {

  {10, 0,   1485,    99,   152064,     64,    175,  64, 2, 32},

  {11, 1,   1485,    99,   152064,    128,    350,  64, 2, 32}, /* level 1b */

  {11, 0,   3000,   396,   345600,    192,    500, 128, 2, 32},

  {12, 0,   6000,   396,   912384,    384,   1000, 128, 2, 32},

  {13, 0,  11880,   396,   912384,    768,   2000, 128, 2, 32},

  {20, 0,  11880,   396,   912384,   2000,   2000, 128, 2, 32},

  {21, 0,  19800,   792,  1824768,   4000,   4000, 256, 2, 32},

  {22, 0,  20250,  1620,  3110400,   4000,   4000, 256, 2, 32},

  {30, 0,  40500,  1620,  3110400,  10000,  10000, 256, 2, 32},

  {31, 0, 108000,  3600,  6912000,  14000,  14000, 512, 4, 16},

  {32, 0, 216000,  5120,  7864320,  20000,  20000, 512, 4, 16},

  {40, 0, 245760,  8192, 12582912,  20000,  25000, 512, 4, 16},

  {41, 0, 245760,  8192, 12582912,  50000,  62500, 512, 2, 16},

  {42, 0, 491520,  8192, 12582912,  50000,  62500, 512, 2, 16},

  {50, 0, 589824, 22080, 42393600, 135000, 135000, 512, 2, 16},

  {51, 0, 983040, 36864, 70778880, 240000, 240000, 512, 2, 16}

};

#ifdef VIDEOEDITORENGINE_AVC_EDITING

struct aspectRatio_s 

{

  int width;

  int height;

};

static const struct aspectRatio_s aspectRatioArr[13] = 

{

  {  1,  1},

  { 12, 11},

  { 10, 11},

  { 16, 11},

  { 40, 33},

  { 24, 11},

  { 20, 11},

  { 32, 11},

  { 80, 33},

  { 18, 11},

  { 15, 11},

  { 64, 33},

  {160, 99}

};

#endif  // VIDEOEDITORENGINE_AVC_EDITING

/*

 * 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 PS_ERROR;

  return PS_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 PS_ERROR;

  if (*val > maxVal)

    return PS_ERR_ILLEGAL_VALUE;

  return PS_OK;

}

/* Return long signed UVLC code */

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

{

  *val = vldGetSignedUVLClong(bitbuf);

  if (bibGetStatus(bitbuf) < 0)

    return PS_ERROR;

  return PS_OK;

}

/* Return long unsigned UVLC code */

static int ue_v_long(bitbuffer_s *bitbuf, u_int32 *val, u_int32 maxVal)

{

  *val = vldGetUVLClong(bitbuf);

  if (bibGetStatus(bitbuf) < 0)

    return PS_ERROR;

  if (*val > maxVal)

    return PS_ERR_ILLEGAL_VALUE;

  return PS_OK;

}

#ifdef VIDEOEDITORENGINE_AVC_EDITING

/* 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 PS_ERROR;

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

    return PS_ERR_ILLEGAL_VALUE;

  return PS_OK;

}

#endif  // VIDEOEDITORENGINE_AVC_EDITING

/*

 * getLevel:

 *

 * Parameters:

 *      levelNumber

 *      constraintSet3flag

 *

 * Function:

 *      Return parameters for level based on level number.

 *

 *  Return:

 *      Pointer to level or 0 if level does not exist

 */

static const level_s *getLevel(int levelNumber, int constraintSet3flag)

{

  int i;

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

    if (levelArray[i].levelNumber == levelNumber &&

        levelArray[i].constraintSet3flag == constraintSet3flag)

      return &levelArray[i];

  }

  PRINT((_L("Unknown level: %i.\n"), levelNumber));            

  return 0;

}

/*

 *

 * getHrdParameters:

 *

 * Parameters:

 *      bitbuf                The bitbuffer object

 *      hrd                   the pointer for returning HRD parameters

 *

 * Function:

 *      decode the HRD Parameters

 *

 * Returns:

 *      PS_OK:                Hrd parameters decoded succesfully

 *      <0:                   Fail

 */

static int getHrdParameters(bitbuffer_s *bitbuf, hrd_parameters_s *hrd)

{

  unsigned int i;

  int retCode;

  if ((retCode = ue_v(bitbuf, &hrd->cpb_cnt_minus1, 31)) < 0)

    return retCode;

  if ((retCode = u_n(bitbuf, 4, &hrd->bit_rate_scale)) < 0)

    return retCode;

  if ((retCode = u_n(bitbuf, 4, &hrd->cpb_size_scale)) < 0)

    return retCode;

  for (i = 0; i <= hrd->cpb_cnt_minus1; i++) {

    /* bit_rate_value_minus1 must be in range of 0 to 2^32-2 */

    if ((retCode = ue_v_long(bitbuf, &hrd->bit_rate_value_minus1[i], (u_int32)4294967294U)) < 0)

      return retCode;

    /* cpb_size_value_minus1 must be in range of 0 to 2^32-2 */

    if ((retCode = ue_v_long(bitbuf, &hrd->cpb_size_value_minus1[i], (u_int32)4294967294U)) < 0)

      return retCode;

    if ((retCode = u_n(bitbuf, 1, &hrd->cbr_flag[i])) < 0)

      return retCode;

  }

  if ((retCode = u_n(bitbuf, 5, &hrd->initial_cpb_removal_delay_length_minus1)) < 0)

    return retCode;

  if ((retCode = u_n(bitbuf, 5, &hrd->cpb_removal_delay_length_minus1)) < 0)

    return retCode;

  if ((retCode = u_n(bitbuf, 5, &hrd->dpb_output_delay_length_minus1)) < 0)

    return retCode;

  if ((retCode = u_n(bitbuf, 5, &hrd->time_offset_length)) < 0)

    return retCode;

  return PS_OK;

}

/*

 *

 * getVUI:

 *

 * Parameters:

 *      bitbuf                The bitbuffer object

 *      vui                   the pointer for returning VUI parameters

 *

 * Function:

 *      decode the VUI Parameters

 *

 * Returns:

 *      PS_OK:                VUI parameters decoded succesfully

 *      <0:                   Fail

 */

static int getVUI(bitbuffer_s *bitbuf, vui_parameters_s *vui)

{

  unsigned tempWordHi, tempWordLo;

  int retCode;

  if ((retCode = u_n(bitbuf, 1, &vui->aspect_ratio_info_present_flag)) < 0)

    return retCode;

  if (vui->aspect_ratio_info_present_flag) {

    if ((retCode = u_n(bitbuf, 8, &vui->aspect_ratio_idc)) < 0)

      return retCode;

    if (vui->aspect_ratio_idc == PS_EXTENDED_SAR) {

      if ((retCode = u_n(bitbuf, 16, &vui->sar_width)) < 0)

        return retCode;

      if ((retCode = u_n(bitbuf, 16, &vui->sar_height)) < 0)

        return retCode;

    }

  }

  if ((retCode = u_n(bitbuf, 1, &vui->overscan_info_present_flag)) < 0)

    return retCode;

  if (vui->overscan_info_present_flag) {

    if ((retCode = u_n(bitbuf, 1, &vui->overscan_appropriate_flag)) < 0)

      return retCode;

  }

  if ((retCode = u_n(bitbuf, 1, &vui->video_signal_type_present_flag)) < 0)

    return retCode;

  if (vui->video_signal_type_present_flag) {

    if ((retCode = u_n(bitbuf, 3, &vui->video_format)) < 0)

      return retCode;

    if ((retCode = u_n(bitbuf, 1, &vui->video_full_range_flag)) < 0)

      return retCode;

    if ((retCode = u_n(bitbuf, 1, &vui->colour_description_present_flag)) < 0)

      return retCode;

    if (vui->colour_description_present_flag) {

      if ((retCode = u_n(bitbuf, 8, &vui->colour_primaries)) < 0)

        return retCode;

      if ((retCode = u_n(bitbuf, 8, &vui->transfer_characteristics)) < 0)

        return retCode;

      if ((retCode = u_n(bitbuf, 8, &vui->matrix_coefficients)) < 0)

        return retCode;

    }

  }

  if ((retCode = u_n(bitbuf, 1, &vui->chroma_loc_info_present_flag)) < 0)

    return retCode;

  if (vui->chroma_loc_info_present_flag) {

    if ((retCode = ue_v(bitbuf, &vui->chroma_sample_loc_type_top_field, 5)) < 0)

      return retCode;

    if ((retCode = ue_v(bitbuf, &vui->chroma_sample_loc_type_bottom_field, 5)) < 0)

      return retCode;

  }

  if ((retCode = u_n(bitbuf, 1, &vui->timing_info_present_flag)) < 0)

    return retCode;

  if (vui->timing_info_present_flag) {

    if ((retCode = u_n(bitbuf, 16, &tempWordHi)) < 0)

      return retCode;

    if ((retCode = u_n(bitbuf, 16, &tempWordLo)) < 0)

      return retCode;

    vui->num_units_in_tick = (((u_int32)tempWordHi) << 16) | ((u_int32)tempWordLo);

    if ((retCode = u_n(bitbuf, 16, &tempWordHi)) < 0)

      return retCode;

    if ((retCode = u_n(bitbuf, 16, &tempWordLo)) < 0)

      return retCode;

    vui->time_scale = (((u_int32)tempWordHi) << 16) | ((u_int32)tempWordLo);

    if ((retCode = u_n(bitbuf, 1, &vui->fixed_frame_rate_flag)) < 0)

      return retCode;

  }

  if ((retCode = u_n(bitbuf, 1, &vui->nal_hrd_parameters_present_flag)) < 0)

    return retCode;

  if (vui->nal_hrd_parameters_present_flag) {

    if ((retCode = getHrdParameters(bitbuf, &vui->nal_hrd_parameters)) < 0)

      return retCode;

  }

  if ((retCode = u_n(bitbuf, 1, &vui->vcl_hrd_parameters_present_flag)) < 0)

    return retCode;

  if (vui->vcl_hrd_parameters_present_flag) {

    if ((retCode = getHrdParameters(bitbuf, &vui->vcl_hrd_parameters)) < 0)

      return retCode;

  }

  if (vui->nal_hrd_parameters_present_flag || vui->vcl_hrd_parameters_present_flag) {

    if ((retCode = u_n(bitbuf, 1, &vui->low_delay_hrd_flag)) < 0)

      return retCode;

  }

  if ((retCode = u_n(bitbuf, 1, &vui->pic_struct_present_flag)) < 0)

    return retCode;

  if ((retCode = u_n(bitbuf, 1, &vui->bitstream_restriction_flag)) < 0)

    return retCode;

  if (vui->bitstream_restriction_flag) {

    if ((retCode = u_n(bitbuf, 1, &vui->motion_vectors_over_pic_boundaries_flag)) < 0)

      return retCode;

    if ((retCode = ue_v(bitbuf, &vui->max_bytes_per_pic_denom, 16)) < 0)

      return retCode;

    if ((retCode = ue_v(bitbuf, &vui->max_bits_per_mb_denom, 16)) < 0)

      return retCode;

    if ((retCode = ue_v(bitbuf, &vui->log2_max_mv_length_horizontal, 16)) < 0)

      return retCode;

    if ((retCode = ue_v(bitbuf, &vui->log2_max_mv_length_vertical, 16)) < 0)

      return retCode;

    if ((retCode = ue_v(bitbuf, &vui->num_reorder_frames, 16)) < 0)

      return retCode;

    if ((retCode = ue_v(bitbuf, &vui->max_dec_frame_buffering, 16)) < 0)

      return retCode;

  }

  return PS_OK;

}

/*

 *

 * setVUIdefaults:

 *

 * Parameters:

 *      vui                   Pointer to VUI parameters

 *

 * Function:

 *      Set VUI parameters to their default values when default value is non-zero.

 *

 * Returns:

 *      -

 */

static void setVUIdefaults(seq_parameter_set_s *sps)

{

  vui_parameters_s *vui;

  const level_s *level;

  int MaxDpbSize;

  vui = &sps->vui_parameters;

  vui->video_format                            = 5;

  vui->colour_primaries                        = 2;

  vui->transfer_characteristics                = 2;

  vui->matrix_coefficients                     = 2;

  vui->motion_vectors_over_pic_boundaries_flag = 1;

  vui->max_bytes_per_pic_denom                 = 2;

  vui->max_bits_per_mb_denom                   = 1;

  vui->log2_max_mv_length_horizontal           = 16;

  vui->log2_max_mv_length_vertical             = 16;

  level = getLevel(sps->level_idc, sps->constraint_set3_flag);

  MaxDpbSize = level->maxDPB /

    ((sps->pic_width_in_mbs_minus1+1) * (sps->pic_height_in_map_units_minus1+1) * 384);

  MaxDpbSize = clip(1, 16, MaxDpbSize);

  vui->max_dec_frame_buffering = MaxDpbSize;

  vui->num_reorder_frames      = vui->max_dec_frame_buffering;

}

/*

 *

 * psDecodeSPS:

 *      

 * Parameters:

 *      bitbuf                Bitbuffer object

 *      spsList               The list for SPS's, the newly decoded SPS will be stored into the list

 *

 * Function:

 *      Decode the SPS, and store it into the SPS list

 *

 * Returns:

 *      PS_OK:                SPS decoded succesfully

 *      <0:                   Fail

 */

int psDecodeSPS( bitbuffer_s *bitbuf, seq_parameter_set_s **spsList, 

                 TInt& aWidth, TInt& aHeight )

{

  seq_parameter_set_s *sps;

  unsigned int i;

  int retCode;

  unsigned  profile_idc;                                      // u(8)

  Boolean   constraint_set0_flag;                             // u(1)

  Boolean   constraint_set1_flag;                             // u(1)

  Boolean   constraint_set2_flag;                             // u(1)

  Boolean   constraint_set3_flag;                             // u(1)

  Boolean   reserved_zero_4bits;                              // u(4)

  unsigned  level_idc;                                        // u(8)

  unsigned  seq_parameter_set_id;                             // ue(v)

  /*

   * Parse sequence parameter set syntax until sps id

   */

  if ((retCode = u_n(bitbuf, 8, &profile_idc)) < 0)

    return retCode;

  /* If constraint_set0_flag == 1, stream is Baseline Profile compliant */

  if ((retCode = u_n(bitbuf, 1, &constraint_set0_flag)) < 0)

    return retCode;

  /* If constraint_set1_flag == 1, stream is Main Profile compliant */

  if ((retCode = u_n(bitbuf, 1, &constraint_set1_flag)) < 0)

    return retCode;

  /* If constraint_set2_flag == 1, stream is Extended Profile compliant */

  if ((retCode = u_n(bitbuf, 1, &constraint_set2_flag)) < 0)

    return retCode;

  if ((retCode = u_n(bitbuf, 1, &constraint_set3_flag)) < 0)

    return retCode;

  /* If CABAC is not defined we support only baseline compliant streams */

#ifndef ENABLE_CABAC

  if (profile_idc != PS_BASELINE_PROFILE_IDC && constraint_set0_flag == 0)

    return PS_ERR_UNSUPPORTED_PROFILE;

#else

  if (profile_idc != PS_BASELINE_PROFILE_IDC && constraint_set0_flag == 0 &&

      profile_idc != PS_MAIN_PROFILE_IDC && constraint_set1_flag == 0)

    return PS_ERR_UNSUPPORTED_PROFILE;

#endif

  /* We don't care what is in these bits */

  if ((retCode = u_n(bitbuf, 4, &reserved_zero_4bits)) < 0)

    return retCode;

  /* Fetch level */

  if ((retCode = u_n(bitbuf, 8, &level_idc)) < 0)

    return retCode;

  /* Find level in the list of legal levels */

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

    if ((int)level_idc == levelArray[i].levelNumber)

      break;

  }

  /* If level was not found in the list, return with error */

  if (i == NUM_LEVELS)

    return PS_ERR_ILLEGAL_VALUE;

  /* Get sequence parameter set id */

  if ((retCode = ue_v(bitbuf, &seq_parameter_set_id, PS_MAX_NUM_OF_SPS-1)) < 0)

    return retCode;

  /*

   * Allocate memory for SPS

   */

  /* Pointer to sequence parameter set structure */

  sps = spsList[seq_parameter_set_id];

  /* allocate mem for SPS, if it has not been allocated already */

  if (!sps) {