--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/avcedit/src/vld.cpp Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,1796 @@
+/*
+* 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
+ *
+ * Function:
+ * Get the amount of copy macroblocks.
+ *
+ * Returns:
+ * The number of copy MBs
+ *
+ */
+unsigned int vldGetRunIndicator(bitbuffer_s *bitbuf)
+{
+ return vldGetUVLC(bitbuf);
+}
+
+
+/*
+ *
+ * vldGetMBtype:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * hdr Return pointer for MB params
+ * picType Type of current picture (intra/inter)
+ *
+ * Function:
+ * Get macroblock type. If MB is 16x16 intra then form cbp. Subblock
+ * mode are also fetched if main mode is 8x8 inter.
+ *
+ * Returns:
+ * VLD_OK for no error and VLD_ERROR for error.
+ *
+ */
+int vldGetMBtype(bitbuffer_s *bitbuf, vldMBtype_s *hdr, int picType)
+{
+ unsigned int code;
+ int nc;
+ int i;
+
+ /* Get macroblock mode */
+ code = vldGetUVLC(bitbuf);
+
+ if (IS_SLICE_I(picType)) {
+ /* INTRA macroblock in INTRA slice */
+ if (code >= VLD_NUM_MB_CODES_INTRA)
+ return VLD_ERROR;
+
+ hdr->type = MBK_INTRA;
+ }
+ else {
+ if (code >= VLD_NUM_MB_CODES_INTER)
+ return VLD_ERROR;
+
+ if (code >= 5) {
+ /* INTRA macroblock in INTER slice */
+ hdr->type = MBK_INTRA;
+ code -= 5;
+ }
+ else {
+ /* INTER macroblock in INTER slice */
+ hdr->type = MBK_INTER;
+ hdr->interMode = code+1;
+
+ if (hdr->interMode >= 4) {
+
+ /*
+ * Get sub-macroblock mode modes
+ */
+
+ for (i = 0; i < 4; i++) {
+ code = vldGetUVLC(bitbuf);
+
+ if (code > VLD_MAX_SUB_MB_MODE)
+ return VLD_ERROR;
+
+ hdr->inter8x8modes[i] = code;
+ }
+
+ }
+
+ if (bibGetStatus(bitbuf) < 0)
+ return VLD_ERROR;
+
+ return VLD_OK;
+ }
+ }
+
+ if (bibGetStatus(bitbuf) < 0)
+ return VLD_ERROR;
+
+ /*
+ * This is INTRA macroblock, find out INTRA type
+ */
+
+ if (code == 0)
+ hdr->intraType = MBK_INTRA_TYPE1;
+ else if (code != VLD_NUM_MB_CODES_INTRA-1) {
+ /* 16x16 INTRA - compose cbp value */
+ hdr->intraType = MBK_INTRA_TYPE2;
+ code -= 1;
+ hdr->intraMode = code & 3;
+ code >>= 2;
+ if (code < 3) {
+ nc = code;
+ hdr->cbpY = 0;
+ }
+ else {
+ nc = code-3;
+ hdr->cbpY = 0xffff;
+ }
+ setChromaCbp(nc, &hdr->cbpChromaDC, &hdr->cbpC);
+ }
+ else {
+ hdr->intraType = MBK_INTRA_TYPE_PCM;
+ hdr->cbpY = 0xffff;
+ hdr->cbpC = 0xff;
+ hdr->cbpChromaDC = 0x3;
+ }
+
+
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetIntraPred:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * ipTab Return pointer for intra pred. modes
+ *
+ * Function:
+ * Get 4x4 intra prediction modes. First a one bit flag is read. If flag
+ * is 1, mode is predicted from neighborin blocks. If flag is 0,
+ * additional 3 bit mode code is read. Process is repeated for 16 blocks.
+ *
+ * Returns:
+ * VLD_OK for no error and VLD_ERROR for error.
+ *
+ */
+int vldGetIntraPred(bitbuffer_s *bitbuf, int8 *ipTab)
+{
+ int i, j, k, l;
+ int bit;
+ int modeCode;
+
+ for (j = 0; j < BLK_PER_MB; j+=2) {
+ for (i = 0; i < BLK_PER_MB; i+=2) {
+ for (k = 0; k < 2; k++) {
+ for (l = 0; l < 2; l++) {
+ bibGetBit(bitbuf, &bit); /* Read flag */
+ if (bit == 1) /* If 1, predict from neighbors */
+ ipTab[(j+k)*4+i+l] = -1;
+ else { /* If 0, read mode code */
+ bibGetMax8bits(bitbuf, 3, &modeCode);
+ ipTab[(j+k)*4+i+l] = (int8)modeCode;
+ }
+ }
+ }
+ }
+ }
+
+ /* Check if error occured */
+ if (bibGetStatus(bitbuf) < 0)
+ return VLD_ERROR;
+ else
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetChromaIntraPred:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ *
+ * Function:
+ * Get chroma intra prediction mode.
+ *
+ * Returns:
+ * Prediction mode.
+ *
+ */
+int vldGetChromaIntraPred(bitbuffer_s *bitbuf)
+{
+ unsigned int mode;
+
+ mode = vldGetUVLC(bitbuf);
+
+ if (bibGetStatus(bitbuf) < 0 || mode > VLD_MAX_IPR_CHROMA_MODE)
+ return VLD_ERROR;
+
+ return (int)mode;
+}
+
+
+/*
+ *
+ * vldGetMotVecs:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * interMode Motion mode (16x16, 8x16, ...)
+ * hasRef Flag for multiple ref. frames
+ * refNum Return pointer for ref. indices
+ * predVecs Return pointer for delta vectors
+ * numVecs Number of vectors to read
+ *
+ * Function:
+ * Get reference indices and delta motion vectors for MB
+ *
+ * Returns:
+ * VLD_OK for no error and VLD_ERROR for error
+ *
+ */
+int vldGetMotVecs(bitbuffer_s *bitbuf, int interMode, int numRefFrames,
+ int *refNum, int predVecs[][2], int numVecs)
+{
+ int i, j;
+ int code;
+ int refIdx;
+
+ if (numRefFrames > 1 && interMode < 5) {
+ if (numRefFrames == 2) {
+ for (i = 0; i < numRefIndices[interMode]; i++) {
+ bibGetBit(bitbuf, &refIdx);
+ refNum[i] = 1 - refIdx;
+ }
+ }
+ else {
+ for (i = 0; i < numRefIndices[interMode]; i++) {
+ if ((refNum[i] = (int)vldGetUVLC(bitbuf)) >= numRefFrames)
+ return VLD_ERROR;
+ }
+ }
+ }
+ else
+ refNum[0] = 0;
+
+ for(j = 0; j < numVecs; j++) {
+ for(i = 0; i < 2; i++) {
+ code = vldGetUVLC(bitbuf);
+ predVecs[j][i] = (code+1)>>1;
+ if ((code & 1) == 0)
+ predVecs[j][i] = -predVecs[j][i];
+ }
+ }
+
+ if (bibGetStatus(bitbuf) < 0)
+ return VLD_ERROR;
+ else
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetCBP:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * mbType Macroblock type (intra/inter)
+ * cbpY Return pointer for luma CBP
+ * cbpChromaDC Return pointer for chroma DC CBP
+ * cbpC Return pointer for chroma CBP
+ *
+ * Function:
+ * Get Coded Block Patterns for both luma and chroma
+ *
+ * Returns:
+ * VLD_OK for no error and VLD_ERROR for error
+ *
+ */
+int vldGetCBP(bitbuffer_s *bitbuf, int mbType,
+ int *cbpY, int *cbpChromaDC, int *cbpC)
+{
+ unsigned int code;
+ int cbp;
+
+ code = vldGetUVLC(bitbuf);
+
+ if (bibGetStatus(bitbuf) < 0 || code > VLD_MAX_CBP_CODE)
+ return VLD_ERROR;
+
+ if (mbType == MBK_INTRA)
+ cbp = code2cbp[code][0];
+ else
+ cbp = code2cbp[code][1];
+
+ *cbpY = getLumaBlkCbp(cbp%16);
+ setChromaCbp(cbp>>4, cbpChromaDC, cbpC);
+
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetDeltaqp:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * delta_qp Return pointer for delta QP
+ *
+ * Function:
+ * Get macroblock delta QP
+ *
+ * Returns:
+ * VLD_OK for no error and VLD_ERROR for error
+ *
+ */
+int vldGetDeltaqp(bitbuffer_s *bitbuf, int *delta_qp)
+{
+ unsigned int code;
+
+ code = vldGetUVLC(bitbuf);
+
+ if (bibGetStatus(bitbuf) < 0 || code > VLD_MAX_DELTA_QP_CODE)
+ return VLD_ERROR;
+
+ *delta_qp = (code+1)>>1;
+
+ if ((code & 1) == 0)
+ *delta_qp = -(*delta_qp);
+
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * getCoefLevelVLC0:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ *
+ * Function:
+ * Get CAVLC coefficient level for VLC0 code format
+ *
+ * Returns:
+ * Coefficient level
+ *
+ */
+static int getCoefLevelVLC0(bitbuffer_s *bitbuf)
+{
+ int numLeadingZeroBits;
+ u_int32 bits;
+ int len;
+ int coef;
+
+ bibShowMax16bits(bitbuf, 16, &bits);
+
+ if (bits > 0x0003) {
+ if (bits > 0x00ff)
+ numLeadingZeroBits = numLeadZerosTab[(int)(bits>>(16-7))];
+ else
+ numLeadingZeroBits = 7 + numLeadZerosTab[(int)(bits>>(16-7-7))];
+
+ coef = (numLeadingZeroBits >> 1) + 1;
+ if (numLeadingZeroBits & 1)
+ coef = -coef;
+
+ len = numLeadingZeroBits + 1;
+ bibSkipBits(bitbuf, len);
+ }
+ else if (bits > 0x0001) {
+ bibGetBits(bitbuf, 19, &bits);
+ coef = 8 + (((int)bits & 15) >> 1);
+ if (bits & 1)
+ coef = -coef;
+ }
+ else if (bits == 0x0001) {
+ bibSkipBits(bitbuf, 16);
+ bibGetMax16bits(bitbuf, 12, &bits);
+ coef = 16 + ((int)bits >> 1);
+ if (bits & 1)
+ coef = -coef;
+ }
+ else {
+ bibRaiseError(bitbuf, BIB_ERR_BIT_ERROR);
+ coef = 0;
+ }
+
+ return coef;
+}
+
+/*
+ *
+ * getCoefLevelVLCN:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * tabNum VLC table number to be used
+ *
+ * Function:
+ * Get CAVLC coefficient level for VLC1-6 code format
+ *
+ * Returns:
+ * Coefficient level
+ *
+ */
+static int getCoefLevelVLCN(bitbuffer_s *bitbuf, int tabNum)
+{
+ int numLeadingZeroBits;
+ u_int32 bits;
+ int len;
+ int coef;
+
+ bibShowBits(bitbuf, 21, &bits);
+
+ if (bits > 0x00003f) {
+ if (bits > 0x001fff)
+ numLeadingZeroBits = numLeadZerosTab[(int)(bits>>(21-7))];
+ else
+ numLeadingZeroBits = 7 + numLeadZerosTab[(int)(bits>>(21-7-7))];
+
+ len = numLeadingZeroBits + 1 + tabNum;
+ bits = (bits >> (21 - len)) & ((1 << tabNum) - 1);
+ coef = (int)((numLeadingZeroBits << (tabNum - 1)) + (bits >> 1) + 1);
+ if (bits & 1)
+ coef = -coef;
+
+ bibSkipBits(bitbuf, len);
+ }
+ else if (bits > 0x00001f) {
+ bibSkipBits(bitbuf, 16);
+ bibGetMax16bits(bitbuf, 12, &bits);
+ coef = (15 << (tabNum - 1)) + ((int)bits >> 1) + 1;
+ if (bits & 1)
+ coef = -coef;
+ }
+ else {
+ bibRaiseError(bitbuf, BIB_ERR_BIT_ERROR);
+ coef = 0;
+ }
+
+ return coef;
+}
+
+
+/*
+ *
+ * get4x4coefs:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * coef Return pointer for 4x4 coefficients
+ * blkIdxX Horizontal block pos. within MB
+ * blkIdxY Vertical block pos. within MB
+ * numCoefUpPred Block coefficients counts of upper block
+ * numCoefLeftPred Block coefficients counts of left block
+ * mbAvailBits Macroblock availability flags
+ * dcSkip if 1, there's no DC coefficient
+ *
+ * Function:
+ * Decode coefficients for 4x4 block.
+ *
+ * Returns:
+ * VLD_OK for no error, VLD_ERROR for error
+ *
+ */
+static int get4x4coefs(bitbuffer_s *bitbuf, int coef[4][4],
+ int blkIdxX, int blkIdxY, int8 *numCoefUpPred,
+ int8 *numCoefLeftPred, int mbAvailBits, int dcSkip)
+{
+ int numCoefPred;
+ int tabNum;
+ u_int32 bits;
+ int code;
+ int numTrailingOnes;
+ int numLeadingZeroBits;
+ int totalCoef;
+ int numBits;
+ u_int32 flc;
+ int tmpLevel[16];
+ int level;
+ int numBigCoef;
+ u_int32 signs;
+ int s;
+ int i;
+ const u_int8 *totalZerosPtr;
+ int offset;
+ int totalZeros;
+ int zerosLeft;
+ int run;
+ int coefPos;
+ int coefNum;
+
+ static const int vlcNumTab[8] = {
+ 0, 0, 1, 1, 2, 2, 2, 2
+ };
+
+ static const unsigned int incVlc[7] = {
+ 0,3,6,12,24,48,32768 /* maximum vlc = 6 */
+ };
+
+ static const int zigZagPos[16] = {
+ 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
+ };
+
+ /*
+ * Decode number of coefficients and number of trailing ones
+ */
+
+ /* Predict number of coefficients from neighboring blocks */
+ if (blkIdxX || (mbAvailBits & 1)) {
+ numCoefPred = numCoefLeftPred[0];
+ if (blkIdxY || (mbAvailBits & 2))
+ numCoefPred = (numCoefPred + numCoefUpPred[0] + 1) >> 1;
+ }
+ else
+ numCoefPred = (blkIdxY || (mbAvailBits & 2)) ? numCoefUpPred[0] : 0;
+
+ /* Select variable length code or fixed length decoding */
+ if (numCoefPred < 8) {
+
+ /* Use variable length code */
+
+ /* Select table number based on the prediction */
+ tabNum = vlcNumTab[numCoefPred];
+
+ bibShowBits(bitbuf, 18, &bits);
+
+ /* Compute number of leading zeros using look-up table */
+ if (bits >= 0x00400)
+ numLeadingZeroBits = numLeadZerosTab[(int)(bits>>(18-7))];
+ else
+ numLeadingZeroBits = 7 + numLeadZerosTab[(int)(bits>>(18-7-7))];
+
+ /* Shift excess bits away */
+ bits >>= 18-4-numLeadingZeroBits;
+
+ /* numTrailingOnes, totalCoef and length of the codeword are codec in one code */
+ code = numCoefTrailTab[tabNum][numLeadingZeroBits][(int)bits&7];
+
+ /* Total number of bits in codeword is sum of the number of leading zero bits, */
+ /* 1 one bit and the number of bits in postfix. We know the number of leading zero */
+ /* bits. Postfix length is extracted from 2 highest bits of code. */
+ numBits = numLeadingZeroBits + 1 + (code >> 6);
+
+ bibSkipBits(bitbuf, numBits);
+
+ if ((code & 0x3f) == 2) {
+ /* All coefficients are zero */
+ numCoefUpPred[0] = numCoefLeftPred[0] = 0;
+ return VLD_OK;
+ }
+ else {
+ /* 2 lowest bits contains number of trailing ones */
+ numTrailingOnes = code & 3;
+ /* 4 middle bits contain total number of coefficients minus 1 */
+ totalCoef = ((code >> 2) & 15) + 1;
+ }
+ }
+ else {
+
+ /* Use fixed length code */
+
+ bibGetMax8bits(bitbuf, 6, &flc);
+
+ if (flc != 3) {
+ /* 2 lowest bits contains number of trailing ones */
+ numTrailingOnes = (int)flc & 0x03;
+ /* high bits contain total number of coefficients minus 1 */
+ totalCoef = ((int)flc >> 2) + 1;
+ if (totalCoef < numTrailingOnes)
+ return VLD_ERROR;
+ }
+ else {
+ /* All coefficients are zero */
+ numCoefUpPred[0] = numCoefLeftPred[0] = 0;
+ return VLD_OK;
+ }
+ }
+
+ numCoefUpPred[0] = numCoefLeftPred[0] = (int8) totalCoef;
+
+
+ /*
+ * Decode signs for trailing ones and store trailing ones in tmpLevel.
+ */
+
+ numBigCoef = totalCoef - numTrailingOnes;
+
+ if (numTrailingOnes != 0) {
+
+ /* Get signs for trailing ones. There can be maximum of 3 of them */
+ bibGetMax8bits(bitbuf, numTrailingOnes, &signs);
+
+ for (i = numTrailingOnes-1; i >= 0; i--) {
+ s = ((int)signs >> i) & 1;
+ tmpLevel[numBigCoef+i] = 1 - 2*s;
+ }
+ }
+
+ if (numBigCoef != 0) {
+
+ /*
+ * Decode first "big" level
+ */
+
+ if (totalCoef > 10 && numTrailingOnes < 3)
+ level = getCoefLevelVLCN(bitbuf, 1);
+ else
+ level = getCoefLevelVLC0(bitbuf);
+
+ if (numTrailingOnes < 3)
+ level += (level > 0) ? 1 : -1;
+
+ tmpLevel[numBigCoef-1] = level;
+
+ tabNum = (Abs((int32)level) > 3) ? 2 : 1;
+
+ /*
+ * Decode rest of the "big" levels
+ */
+
+ for (i = numBigCoef - 2; i >= 0; i--) {
+
+ level = getCoefLevelVLCN(bitbuf, tabNum);
+
+ tmpLevel[i] = level;
+
+ /* update VLC table number */
+ if (Abs((int32)level) > (int32)incVlc[tabNum])
+ tabNum++;
+ }
+
+ }
+
+ /*
+ * Get total number of zero coefficients
+ */
+
+ if (totalCoef < 16-dcSkip) {
+
+ bibShowMax16bits(bitbuf, 9, &bits);
+
+ totalZerosPtr = &totalZerosTab[totalZerosTabOffset[totalCoef-1]];
+ code = totalZerosPtr[(int)bits>>6];
+
+ if (code > 0xc0) {
+ offset = code - 0xc0;
+ code = totalZerosPtr[offset+(((int)bits>>3)&7)];
+ if (code > 0xc0) {
+ offset = code - 0xc0;
+ code = totalZerosPtr[offset+((int)bits&7)];
+ }
+ }
+
+ totalZeros = code & 15;
+
+ numBits = code >> 4;
+ bibSkipBits(bitbuf, numBits);
+ }
+ else
+ totalZeros = 0;
+
+ if (dcSkip + totalCoef + totalZeros > 16)
+ return VLD_ERROR;
+
+ /* All coefficients are initially zero */
+ for (i = 0; i < 4; i++) {
+ coef[i][0] = 0;
+ coef[i][1] = 0;
+ coef[i][2] = 0;
+ coef[i][3] = 0;
+ }
+
+ /*
+ * Get run of zeros before each coefficient and store coeffs. in tmpCoef
+ */
+
+ zerosLeft = totalZeros;
+ coefPos = dcSkip + totalCoef + totalZeros - 1;
+ coefNum = totalCoef - 1;
+
+ while (zerosLeft > 0 && coefNum > 0) {
+
+ coef[0][zigZagPos[coefPos]] = tmpLevel[coefNum];
+
+ // select VLC for runbefore
+ tabNum = zerosLeft <= 7 ? zerosLeft-1 : 6;
+
+ bibShowMax8bits(bitbuf, 3, &bits);
+
+ if (tabNum == 6 && bits == 0) {
+ bibShowMax16bits(bitbuf, 11, &bits);
+ if (bits == 0)
+ return VLD_ERROR;
+ numLeadingZeroBits = numLeadZerosTab[(int)bits>>1];
+ run = 7 + numLeadingZeroBits;
+ if (run > zerosLeft)
+ return VLD_ERROR;
+ numBits = 4 + numLeadingZeroBits;
+ }
+ else {
+ code = runBeforeTab[tabNum][(int)bits];
+ run = code & 15;
+ numBits = code >> 4;
+ }
+
+ bibSkipBits(bitbuf, numBits);
+
+ zerosLeft -= run;
+ coefPos -= run + 1;
+ coefNum--;
+ }
+
+ do {
+ coef[0][zigZagPos[coefPos]] = tmpLevel[coefNum];
+ coefPos--;
+ coefNum--;
+ } while (coefNum >= 0);
+
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * get2x2coefsCDC:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * coef Return pointer for 2x2 coefficients
+ * numCoef Return pointer number of nonzero cefficients
+ *
+ * Function:
+ * Decode coefficients for 2x2 DC block.
+ *
+ * Returns:
+ * VLD_OK for no error, VLD_ERROR for error
+ *
+ */
+static int get2x2coefsCDC(bitbuffer_s *bitbuf, int coef[4], int *numCoef)
+{
+ int tabNum;
+ u_int32 bits;
+ int code;
+ int numTrailingOnes;
+ int numLeadingZeroBits;
+ int totalCoef;
+ int numBits;
+ int tmpLevel[4];
+ int level;
+ int numBigCoef;
+ u_int32 signs;
+ int s;
+ int i;
+ int totalZeros;
+ int zerosLeft;
+ int run;
+ int coefPos;
+ int coefNum;
+
+ static const unsigned int incVlc[7] = {
+ 0,3,6,12,24,48,32768 /* maximum vlc = 6 */
+ };
+
+
+ /*
+ * Decode number of coefficients and number of trailing ones
+ */
+
+ bibShowMax16bits(bitbuf, 10, &bits);
+
+ /* Compute number of leading zeros using look-up table */
+ numLeadingZeroBits = numLeadZerosTab[(int)bits>>(10-7)];
+
+ /* Shift excess bits away */
+ bits >>= 10-3-numLeadingZeroBits;
+
+ /* Fetch numTrailingOnes and totalCoef */
+ code = numCoefTrailTabChroma[numLeadingZeroBits][(int)bits&3];
+
+ numTrailingOnes = code & 3;
+ totalCoef = (code >> 2) & 7;
+
+ numBits = (code >> 5) + 1;
+
+ bibSkipBits(bitbuf, numBits);
+
+ *numCoef = totalCoef;
+
+ if (totalCoef == 0)
+ return VLD_OK;
+
+
+ /*
+ * Decode signs for trailing ones
+ */
+
+ numBigCoef = totalCoef - numTrailingOnes;
+
+ if (numTrailingOnes != 0) {
+
+ /* Get signs for trailing ones. There can be maximum of 3 of them */
+ bibGetMax8bits(bitbuf, numTrailingOnes, &signs);
+
+ for (i = numTrailingOnes-1; i >= 0; i--) {
+ s = ((int)signs >> i) & 1;
+ tmpLevel[numBigCoef+i] = 1 - 2*s;
+ }
+ }
+
+ if (numBigCoef != 0) {
+
+ /*
+ * Decode first level
+ */
+
+ level = getCoefLevelVLC0(bitbuf);
+
+ if (numTrailingOnes < 3)
+ level += (level > 0) ? 1 : -1;
+
+ tmpLevel[numBigCoef-1] = level;
+
+ tabNum = (Abs((int32)level) > 3) ? 2 : 1;
+
+ /*
+ * Decode rest of the levels
+ */
+
+ for (i = numBigCoef - 2; i >= 0; i--) {
+
+ level = getCoefLevelVLCN(bitbuf, tabNum);
+
+ tmpLevel[i] = level;
+
+ /* update VLC table number */
+ if (Abs((int32)level) > (int32)incVlc[tabNum])
+ tabNum++;
+ }
+
+ }
+
+ /*
+ * Get total zeros
+ */
+
+ if (totalCoef < 4) {
+ bibShowMax8bits(bitbuf, 3, &bits);
+ code = totalZerosTabChroma[totalCoef-1][(int)bits];
+ totalZeros = code & 15;
+ numBits = code >> 4;
+ bibSkipBits(bitbuf, numBits);
+ }
+ else
+ totalZeros = 0;
+
+ /* All coefficients are initially zero */
+ coef[0] = 0;
+ coef[1] = 0;
+ coef[2] = 0;
+ coef[3] = 0;
+
+ /*
+ * Get run before each coefficient
+ */
+
+ zerosLeft = totalZeros;
+ coefPos = totalCoef + totalZeros - 1;
+ coefNum = totalCoef - 1;
+
+ while (zerosLeft > 0 && coefNum > 0) {
+
+ coef[coefPos] = tmpLevel[coefNum];
+
+ bibShowMax8bits(bitbuf, 3, &bits);
+
+ code = runBeforeTab[zerosLeft-1][(int)bits];
+ run = code & 15;
+ numBits = code >> 4;
+
+ bibSkipBits(bitbuf, numBits);
+
+ zerosLeft -= run;
+ coefPos -= run + 1;
+ coefNum--;
+ }
+
+ do {
+ coef[coefPos] = tmpLevel[coefNum];
+ coefPos--;
+ coefNum--;
+ } while (coefNum >= 0);
+
+
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetLumaDCcoeffs:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * coef Return pointer for 4x4 coefficients
+ * numCoefUpPred Block coefficients counts of upper block
+ * numCoefLeftPred Block coefficient counts of blocks to the left
+ * mbAvailBits Macroblock availability flags
+ *
+ * Function:
+ * Decode coefficients for 4x4 luma DC block.
+ *
+ * Returns:
+ * VLD_OK for no error, negative value for error
+ *
+ */
+int vldGetLumaDCcoeffs(bitbuffer_s *bitbuf, int coef[4][4],
+ int8 *numCoefUpPred, int8 *numCoefLeftPred,
+ int mbAvailBits)
+{
+ int j;
+ int8 numCoef = *numCoefUpPred;
+ int8 numCoefLP = *numCoefLeftPred;
+ int retCode;
+
+ retCode = get4x4coefs(bitbuf, coef, 0, 0, &numCoef, &numCoefLP, mbAvailBits, 0);
+
+ if (retCode < 0)
+ return retCode;
+
+ if (numCoef == 0) {
+ for (j = 0; j < 4; j++) {
+ coef[j][0] = 0;
+ coef[j][1] = 0;
+ coef[j][2] = 0;
+ coef[j][3] = 0;
+ }
+ }
+
+ if (bibGetStatus(bitbuf) < 0)
+ return VLD_ERROR;
+ else
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetLumaCoeffs:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * mbType Macroblock type (intra/inter)
+ * intraType Intra type (16x16 or 4x4 intra pred)
+ * cbpY Return pointer coded block pattern
+ * coef Return pointer for 16x4x4 coefficients
+ * numCoefUpPred Block coefficients counts of upper block
+ * numCoefLeftPred Block coefficient counts of blocks to the left
+ * mbAvailBits Macroblock availability flags
+ *
+ * Function:
+ * Decode coefficients for 16 4x4 luma blocks.
+ *
+ * Returns:
+ * VLD_OK for no error, negative value for error
+ *
+ */
+int vldGetLumaCoeffs(bitbuffer_s *bitbuf, int mbType, int intraType,
+ int *cbpY, int coef[4][4][4][4], int8 *numCoefUpPred,
+ int8 *numCoefLeftPred, int mbAvailBits)
+{
+ int bx, by;
+ int blkIdxX, blkIdxY;
+ int i, j;
+ int cbp, cbpTemp;
+ int dcSkip;
+ int retCode;
+
+ dcSkip = mbType == MBK_INTRA && intraType == MBK_INTRA_TYPE2 ? 1 : 0;
+
+ cbp = cbpTemp = *cbpY;
+
+ for (by = 0; by < 4; by+=2) {
+ for (bx = 0; bx < 4; bx+=2) {
+
+ /* Check if any of the blocks in the current 8x8 block is codec */
+ if ((cbpTemp & 33) != 0) {
+ for (j = 0; j < 2; j++) {
+ for (i = 0; i < 2; i++) {
+
+ blkIdxX = bx + i;
+ blkIdxY = by + j;
+
+ retCode = get4x4coefs(bitbuf, coef[blkIdxY][blkIdxX], blkIdxX, blkIdxY,
+ &numCoefUpPred[blkIdxX], &numCoefLeftPred[blkIdxY],
+ mbAvailBits, dcSkip);
+
+ if (retCode < 0)
+ return retCode;
+
+ if (numCoefUpPred[blkIdxX] == 0)
+ cbp &= ~(1<<(blkIdxY*BLK_PER_MB+blkIdxX));
+ }
+
+ }
+ }
+ else {
+ numCoefUpPred[bx] = 0;
+ numCoefUpPred[bx+1] = 0;
+ numCoefLeftPred[by] = 0;
+ numCoefLeftPred[by+1] = 0;
+ }
+
+ cbpTemp >>= 2;
+ }
+ cbpTemp >>= 4;
+ }
+
+ *cbpY = cbp;
+
+ if (bibGetStatus(bitbuf) < 0)
+ return VLD_ERROR;
+ else
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetChromaDCcoeffs:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * coef Return pointer for 2x2x2 coefficients
+ * cbpYDC Return pointer chroma DC coded block pattern
+ *
+ * Function:
+ * Decode coefficients for 2 2x2 chroma DC blocks.
+ *
+ * Returns:
+ * VLD_OK for no error, negative value for error
+ *
+ */
+int vldGetChromaDCcoeffs(bitbuffer_s *bitbuf, int coef[2][2][2], int *cbpDC)
+{
+ int comp;
+ int numCoef;
+ int retCode;
+
+ for (comp = 0; comp < 2; comp++) {
+
+ retCode = get2x2coefsCDC(bitbuf, &coef[comp][0][0], &numCoef);
+
+ if (retCode < 0)
+ return retCode;
+
+ if (numCoef == 0)
+ *cbpDC &= ~(1<<comp);
+ }
+
+ if (bibGetStatus(bitbuf) < 0)
+ return VLD_ERROR;
+ else
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetChromaCoeffs:
+ *
+ * Parameters:
+ * bitbuf Bitbuffer object
+ * coef Return pointer for 2x2x2x4x4 coefficients
+ * cbp Return pointer chroma coded block pattern
+ * numCoefUpPred Block coefficients counts of upper block for U frame
+ * numCoefUpPredV Block coefficients counts of upper block for V frame
+ * numCoefLeftPred Block coefficient counts of blocks to the left for U frame
+ * numCoefLeftPredV Block coefficient counts of blocks to the left for V frame
+ * mbAvailBits Macroblock availability flags
+ *
+ * Function:
+ * Decode coefficients for 8 4x4 chroma blocks.
+ *
+ * Returns:
+ * VLD_OK for no error, negative value for error
+ *
+ */
+int vldGetChromaCoeffs(bitbuffer_s *bitbuf, int coef[2][2][2][4][4], int *cbp,
+ int8 *numCoefUpPred, int8 *numCoefUpPredV,
+ int8 *numCoefLeftPred, int8 *numCoefLeftPredV,
+ int mbAvailBits)
+{
+ int comp;
+ int i, j;
+ int retCode;
+
+ for (comp = 0; comp < 2; comp++) {
+
+ for (j = 0; j < 2; j++) {
+ for (i = 0; i < 2; i++) {
+
+ retCode = get4x4coefs(bitbuf, coef[comp][j][i], i, j, &numCoefUpPred[i],
+ &numCoefLeftPred[j], mbAvailBits, 1);
+
+ if (retCode < 0)
+ return retCode;
+
+ if (numCoefUpPred[i] == 0)
+ *cbp &= ~(1<<(comp*4+j*2+i));
+ }
+
+ }
+
+ /* Switch to V frame */
+ numCoefUpPred = numCoefUpPredV;
+ numCoefLeftPred = numCoefLeftPredV;
+ }
+
+ if (bibGetStatus(bitbuf) < 0)
+ return VLD_ERROR;
+ else
+ return VLD_OK;
+}
+
+
+/*
+ *
+ * vldGetZeroLumaCoeffs:
+ *
+ * Parameters:
+ * numCoefUpPred Block coefficient counts of upper block
+ * numCoefLeftPred Block coefficient counts of blocks to the left
+ *
+ * Function:
+ * Called when there are no luma coefficients.
+ * Sets luma cefficient counts to zero for current MB.
+ *
+ * Returns:
+ * -
+ */
+void vldGetZeroLumaCoeffs(int8 *numCoefUpPred, int8 *numCoefLeftPred)
+{
+ int i;
+
+ for (i = 0; i < 4; i++) {
+ numCoefUpPred[i] = 0;
+ numCoefLeftPred[i] = 0;
+ }
+}
+
+
+/*
+ *
+ * vldGetZeroChromaCoeffs:
+ *
+ * Parameters:
+ * numCoefUpPredU Block coefficient counts of upper block for U frame
+ * numCoefUpPredV Block coefficient counts of upper block for V frame
+ * numCoefLeftPred Block coefficient counts of blocks to the left
+ *
+ * Function:
+ * Called when there are no chroma coefficients.
+ * Sets chroma cefficient counts to zero for current MB.
+ *
+ * Returns:
+ * -
+ */
+void vldGetZeroChromaCoeffs(int8 *numCoefUpPredU, int8 *numCoefUpPredV,
+ int8 numCoefLeftPred[2][2])
+{
+ int i;
+
+ for (i = 0; i < 2; i++) {
+ numCoefUpPredU[i] = 0;
+ numCoefUpPredV[i] = 0;
+ numCoefLeftPred[0][i] = 0;
+ numCoefLeftPred[1][i] = 0;
+ }
+}
+
+
+/*
+ *
+ * vldGetAllCoeffs:
+ *
+ * Parameters:
+ * numCoefUpPredY Block coefficient counts for Y frame
+ * numCoefUpPredU Block coefficient counts for U frame
+ * numCoefUpPredV Block coefficient counts for V frame
+ * numCoefLeftPredY Luma block coefficient counts of blocks to the left
+ * numCoefLeftPredC Chroma block coefficient counts of blocks to the left
+ *
+ * Function:
+ * Called when all coefficients are non-zero (e.g. PCM mactroblock).
+ * Sets cefficient counts to "all coded".
+ *
+ * Returns:
+ * -
+ */
+void vldGetAllCoeffs(int8 *numCoefUpPredY, int8 *numCoefUpPredU,
+ int8 *numCoefUpPredV, int8 *numCoefLeftPredY,
+ int8 numCoefLeftPredC[2][2])
+{
+ int i;
+
+ for (i = 0; i < 4; i++) {
+ numCoefUpPredY[i] = 16;
+ numCoefLeftPredY[i] = 16;
+ }
+
+ for (i = 0; i < 2; i++) {
+ numCoefUpPredU[i] = 16;
+ numCoefUpPredV[i] = 16;
+ numCoefLeftPredC[0][i] = 16;
+ numCoefLeftPredC[1][i] = 16;
+ }
+}
+
+
+/*
+ *
+ * vldSetUVLC:
+ *
+ * Parameters:
+ * codeNumber value to encode - range [0, 65535]
+ * codeword output codeword
+ * codewordLength length of output codeword
+ *
+ * Function:
+ * Encode a value to 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:
+ * 1 on error, 0 on none
+ *
+ */
+int vldSetUVLC(int codeNumber, int* codeword, int* codewordLength)
+{
+ int c;
+ int bits;
+
+ if (codeNumber < 0 || codeNumber > 65535)
+ return 1;
+
+ c = codeNumber+1;
+ bits = 0;
+
+ do
+ {
+ c >>= 1;
+ bits++;
+ }
+ while (c);
+
+ *codeword = codeNumber + 1;
+ *codewordLength = (bits << 1) - 1;
+
+ return 0;
+}
+
+#endif //VIDEOEDITORENGINE_AVC_EDITING