/*

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

#include "globals.h"

#include "bitbuffer.h"

#include "vld.h"

#define VLD_MAX_CW_LEN              33

#define VLD_MAX_LONG_CW_LEN         65

#define VLD_MAX_UVLC_CODE_NUM       65535         /* 2^16-1 */

#define VLD_MAX_LONG_UVLC_CODE_NUM  4294967295U    /* 2^32-1 */

#define VLD_NUM_MB_CODES_INTRA      (1+4*3*2+1)   /* 1 4x4, 24 16x16, 1 PCM */

#define VLD_NUM_MB_CODES_INTER      (5+1+4*3*2+1) /* 5 inter, 1 4x4, 24 16x16, 1 PCM */

#define VLD_MAX_SUB_MB_MODE         3

#define VLD_MAX_IPR_CHROMA_MODE     3

#define VLD_MAX_CBP_CODE            47

#define VLD_MAX_DELTA_QP_CODE       52

#ifdef VIDEOEDITORENGINE_AVC_EDITING

/*

 * Static tables for VLD decoder

 */

/* gives CBP value from codeword number, both for intra and inter */

static const int8 code2cbp[VLD_MAX_CBP_CODE+1][2] = {  

  {47, 0},{31,16},{15, 1},{ 0, 2},{23, 4},{27, 8},{29,32},{30, 3},{ 7, 5},{11,10},{13,12},{14,15}, 

  {39,47},{43, 7},{45,11},{46,13},{16,14},{ 3, 6},{ 5, 9},{10,31},{12,35},{19,37},{21,42},{26,44},

  {28,33},{35,34},{37,36},{42,40},{44,39},{ 1,43},{ 2,45},{ 4,46},{ 8,17},{17,18},{18,20},{20,24},

  {24,19},{ 6,21},{ 9,26},{22,28},{25,23},{32,27},{33,29},{34,30},{36,22},{40,25},{38,38},{41,41}    

};

static const int numRefIndices[5] = {

  0, 1, 2, 2, 4

};

/* Look-up table for determining the number of leading zero bits in a 7-bit bumber */

static const int8 numLeadZerosTab[128] = {

  7,6,5,5,4,4,4,4,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,

  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

};

/*

 * Structure of the code is XXYYYYZZ, where XX is the length of the code

 * minus (number of leading zero bits plus 1), YYYY is totalCoef-1 and

 * ZZ is numTrailingOnes. Code xx000010 means that there are no coefficients.

 * 0 is illegal.

 */

static const u_int8 numCoefTrailTab[3][16][8] = {

  {

    {  2,  2,  2,  2,  2,  2,  2,  2}, {  1,  1,  1,  1,  1,  1,  1,  1},

    {  6,  6,  6,  6,  6,  6,  6,  6}, {133,133,128,128, 75, 75, 75, 75},

    {147,147,138,138, 79, 79, 79, 79}, {151,151,142,142,137,137,132,132},

    {155,155,146,146,141,141,136,136}, {159,159,150,150,145,145,140,140},

    {163,163,154,154,149,149,144,144}, {220,226,221,216,231,222,217,212},

    {239,234,229,228,235,230,225,224}, {247,242,237,236,243,238,233,232},

    {255,250,249,244,251,246,245,240}, {188,188,190,190,189,189,184,184},

    { 49, 49, 49, 49, 49, 49, 49, 49}, {  0,  0,  0,  0,  0,  0,  0,  0}

  },

  {

    { 65, 65, 65, 65, 66, 66, 66, 66}, {143,143,139,139, 70, 70, 70, 70},

    {215,202,201,192,147,147,133,133}, {155,155,142,142,141,141,132,132},

    {159,159,146,146,145,145,136,136}, {144,144,150,150,149,149,140,140},

    {163,163,154,154,153,153,148,148}, {235,226,225,220,231,222,221,216},

    {232,234,233,228,239,230,229,224}, {247,242,241,240,243,238,237,236},

    {249,248,250,245,182,182,180,180}, {191,191,190,190,189,189,188,188},

    { 59, 59, 59, 59, 59, 59, 59, 59}, {  0,  0,  0,  0,  0,  0,  0,  0},

    {  0,  0,  0,  0,  0,  0,  0,  0}, {  0,  0,  0,  0,  0,  0,  0,  0}

  },

  {

    {219,215,211,207,203,198,193,194}, {209,210,205,206,201,223,202,197},

    {200,218,217,196,227,214,213,192}, {216,212,226,208,231,222,221,204},

    {239,234,229,224,235,230,225,220}, {236,242,237,232,243,238,233,228},

    {249,244,247,246,245,240,177,177}, {189,189,184,184,187,187,186,186},

    {127,127,127,127,126,126,126,126}, { 60, 60, 60, 60, 60, 60, 60, 60},

    {  0,  0,  0,  0,  0,  0,  0,  0}, {  0,  0,  0,  0,  0,  0,  0,  0},

    {  0,  0,  0,  0,  0,  0,  0,  0}, {  0,  0,  0,  0,  0,  0,  0,  0},

    {  0,  0,  0,  0,  0,  0,  0,  0}, {  0,  0,  0,  0,  0,  0,  0,  0}

  }

};

/*

 * The structure of the code is XXXYYYXX where XXX is the length of the code

 * minus 1, YYY is total number of non-zero coefficients and XX is

 * the number of trailing ones.

 */

static const u_int8 numCoefTrailTabChroma[8][4] = {

  {  5,  5,  5,  5},

  { 32, 32, 32, 32},

  { 74, 74, 74, 74},

  {168,175,169,164},

  {176,176,172,172},

  {206,206,205,205},

  {242,242,241,241},

  {211,211,211,211}

};

/* Offsets for 15 Huffman tables in totalZerosTab */

static const int totalZerosTabOffset[15] = {

  0, 40, 72, 104, 136, 168,

  184, 200, 216, 232, 248, 264, 280,

  288, 296

};

/*

 * The meaning of the code in the table is the following:

 *  If (code > 0xc0) then (code - 0xc0) is an offset to the next position 

 *  in the Huffman tree

 *  Otherwise, code structure is XXXXYYYY where XXXX is the length of the code

 *  and YYYY is the number of zero coefficients.

 */

static const u_int8 totalZerosTab[304] = {

  0xC8, 0xD0, 0x32, 0x31, 0x10, 0x10, 0x10, 0x10,  /* totalCoef==1 */

  0xD8, 0xE0, 0x68, 0x67, 0x56, 0x56, 0x55, 0x55,  /* prefix 000 */

  0x44, 0x44, 0x44, 0x44, 0x43, 0x43, 0x43, 0x43,  /* prefix 001 */

  0x00, 0x9f, 0x9e, 0x9d, 0x8c, 0x8c, 0x8b, 0x8b,  /* prefix 000000 */

  0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79,  /* prefix 000001 */

  0xC8, 0xD0, 0xD8, 0x34, 0x33, 0x32, 0x31, 0x30,  /* totalCoef==2 */

  0x6e, 0x6d, 0x6c, 0x6b, 0x5a, 0x5a, 0x59, 0x59,  /* prefix 000 */

  0x48, 0x48, 0x48, 0x48, 0x47, 0x47, 0x47, 0x47,  /* prefix 001 */

  0x46, 0x46, 0x46, 0x46, 0x45, 0x45, 0x45, 0x45,  /* prefix 010 */

  0xC8, 0xD0, 0xD8, 0x37, 0x36, 0x33, 0x32, 0x31,  /* totalCoef==3 */

  0x6d, 0x6b, 0x5c, 0x5c, 0x5a, 0x5a, 0x59, 0x59,  /* prefix 000 */

  0x48, 0x48, 0x48, 0x48, 0x45, 0x45, 0x45, 0x45,  /* prefix 001 */

  0x44, 0x44, 0x44, 0x44, 0x40, 0x40, 0x40, 0x40,  /* prefix 010 */

  0xC8, 0xD0, 0xD8, 0x38, 0x36, 0x35, 0x34, 0x31,  /* totalCoef==4 */

  0x5c, 0x5c, 0x5b, 0x5b, 0x5a, 0x5a, 0x50, 0x50,  /* prefix 000 */

  0x49, 0x49, 0x49, 0x49, 0x47, 0x47, 0x47, 0x47,  /* prefix 001 */

  0x43, 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x42,  /* prefix 010 */

  0xC8, 0xD0, 0xD8, 0x37, 0x36, 0x35, 0x34, 0x33,  /* totalCoef==5 */

  0x5b, 0x5b, 0x59, 0x59, 0x4a, 0x4a, 0x4a, 0x4a,  /* prefix 000 */

  0x48, 0x48, 0x48, 0x48, 0x42, 0x42, 0x42, 0x42,  /* prefix 001 */

  0x41, 0x41, 0x41, 0x41, 0x40, 0x40, 0x40, 0x40,  /* prefix 010 */

  0xC8, 0x39, 0x37, 0x36, 0x35, 0x34, 0x33, 0x32,  /* totalCoef==6 */

  0x6a, 0x60, 0x51, 0x51, 0x48, 0x48, 0x48, 0x48,  /* prefix 000 */

  0xC8, 0x38, 0x36, 0x34, 0x33, 0x32, 0x25, 0x25,  /* totalCoef==7 */

  0x69, 0x60, 0x51, 0x51, 0x47, 0x47, 0x47, 0x47,  /* prefix 000 */

  0xC8, 0x37, 0x36, 0x33, 0x25, 0x25, 0x24, 0x24,  /* totalCoef==8 */

  0x68, 0x60, 0x52, 0x52, 0x41, 0x41, 0x41, 0x41,  /* prefix 000 */

  0xC8, 0x35, 0x26, 0x26, 0x24, 0x24, 0x23, 0x23,  /* totalCoef==9 */

  0x61, 0x60, 0x57, 0x57, 0x42, 0x42, 0x42, 0x42,  /* prefix 000 */

  0xC8, 0x32, 0x25, 0x25, 0x24, 0x24, 0x23, 0x23,  /* totalCoef==10 */

  0x51, 0x51, 0x50, 0x50, 0x46, 0x46, 0x46, 0x46,  /* prefix 000 */

  0xC8, 0x32, 0x33, 0x35, 0x14, 0x14, 0x14, 0x14,  /* totalCoef==11 */

  0x40, 0x40, 0x40, 0x40, 0x41, 0x41, 0x41, 0x41,  /* prefix 000 */

  0xC8, 0x34, 0x22, 0x22, 0x13, 0x13, 0x13, 0x13,  /* totalCoef==12 */

  0x40, 0x40, 0x40, 0x40, 0x41, 0x41, 0x41, 0x41,  /* prefix 000 */

  0x30, 0x31, 0x23, 0x23, 0x12, 0x12, 0x12, 0x12,  /* totalCoef==13 */

  0x20, 0x20, 0x21, 0x21, 0x12, 0x12, 0x12, 0x12,  /* totalCoef==14 */

  0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11,  /* totalCoef==15 */

};

/*

 * The structure of the code is XXXXYYYY where XXXX is the length of the code

 * and YYYY is the number of zero coefficients.

 */

static const u_int8 totalZerosTabChroma[3][8] = {

  {0x33, 0x32, 0x21, 0x21, 0x10, 0x10, 0x10, 0x10},

  {0x22, 0x22, 0x21, 0x21, 0x10, 0x10, 0x10, 0x10},

  {0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10}

};

/*

 * The structure of the code is XXXXYYYY where XXXX is the length of the code

 * and YYYY is run length.

 */

static const u_int8 runBeforeTab[7][8] = {

  {0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10},

  {0x22, 0x22, 0x21, 0x21, 0x10, 0x10, 0x10, 0x10},

  {0x23, 0x23, 0x22, 0x22, 0x21, 0x21, 0x20, 0x20},

  {0x34, 0x33, 0x22, 0x22, 0x21, 0x21, 0x20, 0x20},

  {0x35, 0x34, 0x33, 0x32, 0x21, 0x21, 0x20, 0x20},

  {0x31, 0x32, 0x34, 0x33, 0x36, 0x35, 0x20, 0x20},

  {0x00, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30},

};

/*

 * Static function prototypes

 */

static int getCoefLevelVLC0(bitbuffer_s *bitbuf);

static int getCoefLevelVLCN(bitbuffer_s *bitbuf, int tabNum);

static int get4x4coefs(bitbuffer_s *bitbuf, int coef[4][4],

                       int blkIdxX, int blkIdxY, int8 *numCoefUpPred,

                       int8 *numCoefLeftPred, int mbAvailbits, int dcSkip);

static int get2x2coefsCDC(bitbuffer_s *bitbuf, int coef[4], int *numCoef);

#endif  // VIDEOEDITORENGINE_AVC_EDITING

/*

 * Functions begin here

 */

/*

 *

 * vldGetFLC:

 *

 * Parameters:

 *      bitbuf                Bitbuffer object

 *      len                   Length of the code

 *

 * Function:

 *      Get Fixed Length Code (max length 16 bits).

 *

 * Returns:

 *      Code

 *

 */

unsigned int vldGetFLC(bitbuffer_s *bitbuf, int len)

{

  u_int32 code;

  bibGetMax16bits(bitbuf, len, &code);

  return (unsigned int)code;

}

/*

 *

 * vldGetUVLC:

 *

 * Parameters:

 *      bitbuf                Bitbuffer object

 *

 * Function:

 *      Decode an UVLC codeword, UVLC codeword is of the form:

 *      code          codeword

 *      0                1

 *      1               010

 *      2               011

 *      3              00100

 *      4              00101

 *      5              00110

 *      6              00111

 *      7             0001000

 *      8             0001001

 *      ...             ...

 *

 * Returns:

 *      Codenumber in the range [0, 65535]

 *

 */

#if 1

unsigned int vldGetUVLC(bitbuffer_s *bitbuf)

{

  u_int32 c;

  int prefixLen;

  int bit;

  bibGetBit(bitbuf, &bit);

  if (bit == 1)

    return 0;

  prefixLen = 0;

  do {

    bibGetBit(bitbuf, &bit);

    prefixLen += 1;

    /* Maximum prefix length is VLD_MAX_CW_LEN/2 */

    if (prefixLen == VLD_MAX_CW_LEN/2) {

      bibGetMax16bits(bitbuf, VLD_MAX_CW_LEN/2, &c);

      if (bit != 1 || c != 0) {

        /* We encoutered overlong codeword or we encoutered too big code */

        bibRaiseError(bitbuf, BIB_ERR_BIT_ERROR);

        return 0;

      }

      else

        return VLD_MAX_UVLC_CODE_NUM;  /* Otherwise, return maximum 16-bit code number */

    }

  } while (bit == 0);

  bibGetMax16bits(bitbuf, prefixLen, &c);

  return (unsigned int)(c + (1<<prefixLen)-1);

}

#else

unsigned int vldGetUVLC(bitbuffer_s *bitbuf)

{

  int prefixLen, len;

  u_int32 bits;

  bibShowMax16bits(bitbuf, 16, &bits);

  if (bits >= 0x0100) {

    prefixLen = numLeadZerosTab[bits>>9];

    len = 2*prefixLen+1;

    bibSkipBits(bitbuf, len);

    return (unsigned int)((bits >> (16-len)) - 1);

  }

  else {

    if (bits >= 0x0001)

      prefixLen = 8 + numLeadZerosTab[bits>>1];

    else

      prefixLen = 16;

    bibSkipBits(bitbuf, prefixLen);

    bibGetBits(bitbuf, prefixLen+1, &bits);

    return (unsigned int)(bits - 1);

  }

}

#endif

/*

 *

 * vldGetSignedUVLClong:

 *

 * Parameters:

 *      bitbuf                Bitbuffer object

 *

 * Function:

 *      Decode an UVLC codeword and produce signed 32-bit integer

 *

 * Returns:

 *      Code in the range [-2^31, 2^31-1]

 *

 */

int32 vldGetSignedUVLClong(bitbuffer_s *bitbuf)

{

  u_int32 codeNum;

  int32 code;

  codeNum = vldGetUVLClong(bitbuf);

  /* Decode magnitude */

  code = (int32)((codeNum >> 1) + (codeNum & 1));

  /* Decode sign */

  if ((codeNum & 1) == 0)

    code = -code;

  return code;

}

/*

 *

 * vldGetUVLClong:

 *

 * Parameters:

 *      bitbuf                Bitbuffer object

 *      code                  Return pointer for code

 *

 * Function:

 *      Decode long UVLC codeword.

 *

 * Returns:

 *      Codenumber in the range [0, 2^32-1]

 *

 */

u_int32 vldGetUVLClong(bitbuffer_s *bitbuf)

{

  u_int32 c, cLo;

  int prefixLen, len0;

  int bits;

  prefixLen = -1;

  do {

    bibGetBit(bitbuf, &bits);

    prefixLen += 1;

    /* Is codeword too long? */

    if (prefixLen > VLD_MAX_LONG_CW_LEN/2) {

      bibRaiseError(bitbuf, BIB_ERR_BIT_ERROR);

      return 0;

    }

  } while (bits == 0);

  len0 = min(24, prefixLen);

  bibGetBits(bitbuf, len0, &c);

  if (prefixLen > 24) {

    /* We have to read bits in two pieces because bibGetBits can only fetch */

    /* max. 24 bits */

    bibGetMax16bits(bitbuf, prefixLen-24, &cLo);

    c = (c << (prefixLen-24)) | cLo;  /* Combine two pieces */

    if (prefixLen == VLD_MAX_LONG_CW_LEN/2) {

      /* Is codeword too big? */

      if (c != 0) {

        bibRaiseError(bitbuf, BIB_ERR_BIT_ERROR);

        return 0;

      }

      else

        return (u_int32)VLD_MAX_LONG_UVLC_CODE_NUM;  /* Otherwise, return maximum 32-bit code number */

    }

  }

  return (c + (1<<prefixLen)-1);

}

#ifdef VIDEOEDITORENGINE_AVC_EDITING

/*

 *

 * vldGetSignedUVLC:

 *

 * Parameters:

 *      bitbuf                Bitbuffer object

 *

 * Function:

 *      Decode an UVLC codeword and produce signed integer.

 *

 * Returns:

 *      Code is in the range [-32768,32767].

 *

 */

int vldGetSignedUVLC(bitbuffer_s *bitbuf)

{

  unsigned int codeNum;

  int code;

  codeNum = vldGetUVLC(bitbuf);

  /* Decode magnitude */

  code = (int)(((int32)codeNum+1)>>1);

  /* Decode sign */

  if ((codeNum & 1) == 0)

    code = -code;

  return code;

}

/*

 *

 * setChromaCbp:

 *

 * Parameters:

 *      nc                    If 0, all CBP are zero

 *      cbpDC                 Coded Bit Pattern for chroma DC

 *      cbp                   Coded Bit Pattern for chroma AC

 *

 * Function:

 *      Set chroma DC and AC CBP values

 *      nc = 0:   No coefficients

 *      nc = 1:   Only nonzero DC coefficients

 *      nc = 2:   Nonzero AC and DC coefficients

 *

 * Returns:

 *      -

 */

void setChromaCbp(int nc, int *cbpDC, int *cbp)

{

  if (nc == 0)

    *cbpDC = *cbp = 0;

  else if (nc == 1)

    *cbpDC = 3, *cbp = 0;

  else

    *cbpDC = 3, *cbp = (1<<2*BLK_PER_MB/2*BLK_PER_MB/2)-1;

}

/*

 *

 * getLumaBlkCbp:

 *

 * Parameters:

 *      cbpY                  CBP for 8x8 blocks

 *

 * Function:

 *      Convert Codec Block Pattern of 8x8 blocks to Codec Block Pattern for

 *      4x4 blocks. If 8x8 block has nonzero coefficients then all 4x4 blocks

 *      within that 8x8 block are marked nonzero.

 *

 * Returns:

 *      CBP for 4x4 blocks

 *

 */

int getLumaBlkCbp(int cbpY)

{

  int cbp;

  cbp  = (cbpY & (1<<0)) == 0 ? 0 : 0x0033;

  cbp |= (cbpY & (1<<1)) == 0 ? 0 : 0x00cc;

  cbp |= (cbpY & (1<<2)) == 0 ? 0 : 0x3300;

  cbp |= (cbpY & (1<<3)) == 0 ? 0 : 0xcc00;

  return cbp;

}

/*

 *

 * vldGetRunIndicator:

 *

 * Parameters:

 *      bitbuf                Bitbuffer object

 *