Subversion Repositories funbase_ip_library

/*---------------------------------------------------------------------------

 *

 *  Course:   Systems Design II

  *

 *  Module:   vlc.c

 *

 *  Purpose:  To encapsulate VLC coding tables for H.263 encoder

 *

 *  Notes:    Module required for slave CPUs. Codewords are taken from

 *            Telenor's H.263 encoder implementation.

 *

 *  Author:   Olli Lehtoranta and Tero Kangas

 *

 *  History:  23/09/2002: + Original version commented and ready

 *            31/10/2002: + TK: modified for Digital Systems Design II course

 **---------------------------------------------------------------------------

 */

#include "headers.h"

/*

* Intra picture coded block pattern for chrominance and macroblock mode

*

* Table element format = { Bit pattern value, codeword length }

*

* indexing with [mode][chroma block pattern]

*  mode 0 = INTRA

*  mode 1 = INTRA_Q

*

*/

const structVLC mcbpcIntraTable[2][4] =

{

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

   { {1,4},{1,6},{2,6},{6,6} }

};

/*

*

* Luminance block pattern table for Intra/Inter pictures

*

*/

const structVLC cbpyTable[16] =

{

   {3,4}, {5,5}, {4,5}, {9,4}, {3,5}, {7,4}, {2,6}, {11,4},

   {2,5}, {3,6}, {5,4}, {10,4}, {4,4}, {8,4}, {6,4}, {3,2}

};

/*

*

* H.263 DCT encoding tables (Taken from Telenor's implementation)

*/

static const structVLC coeffTab0[24] =

{

   /* run = 0 */

   {0x02, 2}, {0x0f, 4}, {0x15, 6}, {0x17, 7},

   {0x1f, 8}, {0x25, 9}, {0x24, 9}, {0x21,10},

   {0x20,10}, {0x07,11}, {0x06,11}, {0x20,11},

   /* run = 1 */

   {0x06, 3}, {0x14, 6}, {0x1e, 8}, {0x0f,10},

   {0x21,11}, {0x50,12}, {0x00, 0}, {0x00, 0},

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

};

static const structVLC coeffTab1[100] =

{

   /* run = 2 */

   {0x0e, 4}, {0x1d, 8}, {0x0e,10}, {0x51,12},

   /* run = 3 */

   {0x0d, 5}, {0x23, 9}, {0x0d,10}, {0x00, 0},

   /* run = 4-26 */

   {0x0c, 5}, {0x22, 9}, {0x52,12}, {0x00, 0},

   {0x0b, 5}, {0x0c,10}, {0x53,12}, {0x00, 0},

   {0x13, 6}, {0x0b,10}, {0x54,12}, {0x00, 0},

   {0x12, 6}, {0x0a,10}, {0x00, 0}, {0x00, 0},

   {0x11, 6}, {0x09,10}, {0x00, 0}, {0x00, 0},

   {0x10, 6}, {0x08,10}, {0x00, 0}, {0x00, 0},

   {0x16, 7}, {0x55,12}, {0x00, 0}, {0x00, 0},

   {0x15, 7}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x14, 7}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x1c, 8}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x1b, 8}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x21, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x20, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x1f, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x1e, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x1d, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x1c, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x1b, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x1a, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x22,11}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x23,11}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x56,12}, {0x00, 0}, {0x00, 0}, {0x00, 0},

   {0x57,12}, {0x00, 0}, {0x00, 0}, {0x00, 0}

};

/*

* Auxilary table to store limit information for coeffTab1

*/

static const uint16 coeffTab1Limits[25] =

{

   4,3,3,3,3,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1

};

static const structVLC coeffTab2[6] =

{

   /* run = 0 */

   {0x07, 4}, {0x19, 9}, {0x05,11},

   /* run = 1 */

   {0x0f, 6}, {0x04,11}, {0x00, 0}

};

static const structVLC coeffTab3[40] =

{

   {0x0e, 6}, {0x0d, 6}, {0x0c, 6},

   {0x13, 7}, {0x12, 7}, {0x11, 7}, {0x10, 7},

   {0x1a, 8}, {0x19, 8}, {0x18, 8}, {0x17, 8},

   {0x16, 8}, {0x15, 8}, {0x14, 8}, {0x13, 8},

   {0x18, 9}, {0x17, 9}, {0x16, 9}, {0x15, 9},

   {0x14, 9}, {0x13, 9}, {0x12, 9}, {0x11, 9},

   {0x07,10}, {0x06,10}, {0x05,10}, {0x04,10},

   {0x24,11}, {0x25,11}, {0x26,11}, {0x27,11},

   {0x58,12}, {0x59,12}, {0x5a,12}, {0x5b,12},

   {0x5c,12}, {0x5d,12}, {0x5e,12}, {0x5f,12},

   {0x00, 0}

};

/*---------------------------------------------------------------------------

*

*  Function: vlcCodeCoefficient

*

*  Input:    last = indication, if this is the last coefficient to be coded

*            run = number of zeros after previously coded coefficient

*            level = absolute value of coefficient to be coded

*            sign = positive / negative indication

*            stream = target bit buffer

*

*  Return:   V_TRUE if LAST,RUN,LEVEL combination can be encoded with

*            help of standard specified codes (optimal)

*

*  Purpose:  To provide look-up table based encoding for LAST,RUN,LEVEL

*            information

*

**---------------------------------------------------------------------------

*/

vbool vlcCodeCoefficient( const sint32 last,

                          const sint32 run,

                          const sint32 level,

                          const sint32 sign,

                          BitStreamType * const stream )

{

   sint32 index = 0;

   sint32 value;

   sint32 bitCount;

   if( !last && ( run < 2 ) && ( level < 13 ) )

   {

      if( run == 0 )

      {

         index = level - 1;

      }

      else if( run == 1 )

      {

         if( level > 6 )

         {

            return V_FALSE;

         }

         index = 12 + level - 1;

      }

      bitCount = coeffTab0[index].bitCount + 1;

      value = ( ( coeffTab0[index].bitPattern << 1 ) | sign);

      bitstreamPut(bitCount,value,stream);

      return V_TRUE;

   }

   else if( !last && ( run >= 2 ) && ( run < 27 ) )

   {

      if( level > coeffTab1Limits[ run - 2 ] )

      {

         return V_FALSE;

      }

      index = ( ( run - 2 ) * 4 ) + level - 1;

      bitCount = coeffTab1[index].bitCount + 1;

      value = ( (coeffTab1[index].bitPattern << 1 ) | sign);

      bitstreamPut(bitCount,value,stream);

      return V_TRUE;

   }

   else if( last && ( run < 2 ) && ( level < 4 ) )

   {

      if( run == 0 )

      {

         index = level - 1;

      }

      else if( run == 1 )

      {

         if( level > 2 )

         {

            return V_FALSE;

         }

         index = 3 + level - 1;

      }

      bitCount = coeffTab2[index].bitCount + 1;

      value = ( ( coeffTab2[index].bitPattern << 1 ) | sign );

      bitstreamPut(bitCount,value,stream);

      return V_TRUE;

   }

   else if( last && ( run >= 2 ) && ( run < 41 ) && ( level == 1 ) )

   {

      bitCount = coeffTab3[run-2].bitCount + 1;

      value = ( ( coeffTab3[run-2].bitPattern << 1 ) | sign);

      bitstreamPut(bitCount,value,stream);

      return V_TRUE;

   }

   return V_FALSE;

}