vlc.c
上传用户:hjq518
上传日期:2021-12-09
资源大小:5084k
文件大小:38k
源码类别:

Audio

开发平台:

Visual C++

  1. /*!
  2.  ************************************************************************
  3.  * file vlc.c
  4.  *
  5.  * brief
  6.  *    VLC support functions
  7.  *
  8.  * author
  9.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  10.  *    - Inge Lille-Lang鴜               <inge.lille-langoy@telenor.com>
  11.  *    - Detlev Marpe                    <marpe@hhi.de>
  12.  *    - Gabi Blaettermann
  13.  ************************************************************************
  14.  */
  15. #include "contributors.h"
  16. #include "global.h"
  17. #include "vlc.h"
  18. #include "elements.h"
  19. // A little trick to avoid those horrible #if TRACE all over the source code
  20. #if TRACE
  21. #define SYMTRACESTRING(s) strncpy(symbol.tracestring,s,TRACESTRING_SIZE)
  22. #else
  23. #define SYMTRACESTRING(s) // do nothing
  24. #endif
  25. void tracebits(const char *trace_str,  int len,  int info,int value1);
  26. int UsedBits;      // for internal statistics, is adjusted by se_v, ue_v, u_1
  27. // Note that all NA values are filled with 0
  28. //! gives CBP value from codeword number, both for intra and inter
  29. static const unsigned char NCBP[2][48][2]=
  30. {
  31.   {  // 0      1        2       3       4       5       6       7       8       9      10      11
  32.     {15, 0},{ 0, 1},{ 7, 2},{11, 4},{13, 8},{14, 3},{ 3, 5},{ 5,10},{10,12},{12,15},{ 1, 7},{ 2,11},
  33.     { 4,13},{ 8,14},{ 6, 6},{ 9, 9},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},
  34.     { 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},
  35.     { 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0}
  36.   },
  37.   {
  38.     {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.     {39,47},{43, 7},{45,11},{46,13},{16,14},{ 3, 6},{ 5, 9},{10,31},{12,35},{19,37},{21,42},{26,44},
  40.     {28,33},{35,34},{37,36},{42,40},{44,39},{ 1,43},{ 2,45},{ 4,46},{ 8,17},{17,18},{18,20},{20,24},
  41.     {24,19},{ 6,21},{ 9,26},{22,28},{25,23},{32,27},{33,29},{34,30},{36,22},{40,25},{38,38},{41,41}
  42.   }
  43. };
  44. //! for the linfo_levrun_inter routine
  45. const byte NTAB1[4][8][2] =
  46. {
  47.   {{1,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}},
  48.   {{1,1},{1,2},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}},
  49.   {{2,0},{1,3},{1,4},{1,5},{0,0},{0,0},{0,0},{0,0}},
  50.   {{3,0},{2,1},{2,2},{1,6},{1,7},{1,8},{1,9},{4,0}},
  51. };
  52. const byte LEVRUN1[16]=
  53. {
  54.   4,2,2,1,1,1,1,1,1,1,0,0,0,0,0,0,
  55. };
  56. const byte NTAB2[4][8][2] =
  57. {
  58.   {{1,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}},
  59.   {{1,1},{2,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}},
  60.   {{1,2},{3,0},{4,0},{5,0},{0,0},{0,0},{0,0},{0,0}},
  61.   {{1,3},{1,4},{2,1},{3,1},{6,0},{7,0},{8,0},{9,0}},
  62. };
  63. //! for the linfo_levrun__c2x2 routine
  64. const byte LEVRUN3[4] =
  65. {
  66.   2,1,0,0
  67. };
  68. const byte NTAB3[2][2][2] =
  69. {
  70.   {{1,0},{0,0}},
  71.   {{2,0},{1,1}},
  72. };
  73. /*!
  74.  *************************************************************************************
  75.  * brief
  76.  *    ue_v, reads an ue(v) syntax element, the length in bits is stored in
  77.  *    the global UsedBits variable
  78.  *
  79.  * param tracestring
  80.  *    the string for the trace file
  81.  *
  82.  * param bitstream
  83.  *    the stream to be read from
  84.  *
  85.  * return
  86.  *    the value of the coded syntax element
  87.  *
  88.  *************************************************************************************
  89.  */
  90. int ue_v (char *tracestring, Bitstream *bitstream)
  91. {
  92.   SyntaxElement symbol;
  93.   assert (bitstream->streamBuffer != NULL);
  94.   symbol.type = SE_HEADER;
  95.   symbol.mapping = linfo_ue;   // Mapping rule
  96.   SYMTRACESTRING(tracestring);
  97.   readSyntaxElement_VLC (&symbol, bitstream);
  98.   UsedBits+=symbol.len;
  99.   return symbol.value1;
  100. }
  101. /*!
  102.  *************************************************************************************
  103.  * brief
  104.  *    ue_v, reads an se(v) syntax element, the length in bits is stored in
  105.  *    the global UsedBits variable
  106.  *
  107.  * param tracestring
  108.  *    the string for the trace file
  109.  *
  110.  * param bitstream
  111.  *    the stream to be read from
  112.  *
  113.  * return
  114.  *    the value of the coded syntax element
  115.  *
  116.  *************************************************************************************
  117.  */
  118. int se_v (char *tracestring, Bitstream *bitstream)
  119. {
  120.   SyntaxElement symbol;
  121.   assert (bitstream->streamBuffer != NULL);
  122.   symbol.type = SE_HEADER;
  123.   symbol.mapping = linfo_se;   // Mapping rule: signed integer
  124.   SYMTRACESTRING(tracestring);
  125.   readSyntaxElement_VLC (&symbol, bitstream);
  126.   UsedBits+=symbol.len;
  127.   return symbol.value1;
  128. }
  129. /*!
  130.  *************************************************************************************
  131.  * brief
  132.  *    ue_v, reads an u(v) syntax element, the length in bits is stored in
  133.  *    the global UsedBits variable
  134.  *
  135.  * param LenInBits
  136.  *    length of the syntax element
  137.  *
  138.  * param tracestring
  139.  *    the string for the trace file
  140.  *
  141.  * param bitstream
  142.  *    the stream to be read from
  143.  *
  144.  * return
  145.  *    the value of the coded syntax element
  146.  *
  147.  *************************************************************************************
  148.  */
  149. int u_v (int LenInBits, char*tracestring, Bitstream *bitstream)
  150. {
  151.   SyntaxElement symbol;
  152.   symbol.inf = 0;
  153.   assert (bitstream->streamBuffer != NULL);
  154.   symbol.type = SE_HEADER;
  155.   symbol.mapping = linfo_ue;   // Mapping rule
  156.   symbol.len = LenInBits;
  157.   SYMTRACESTRING(tracestring);
  158.   readSyntaxElement_FLC (&symbol, bitstream);
  159.   UsedBits+=symbol.len;
  160.   return symbol.inf;
  161. }
  162. /*!
  163.  *************************************************************************************
  164.  * brief
  165.  *    i_v, reads an i(v) syntax element, the length in bits is stored in
  166.  *    the global UsedBits variable
  167.  *
  168.  * param LenInBits
  169.  *    length of the syntax element
  170.  *
  171.  * param tracestring
  172.  *    the string for the trace file
  173.  *
  174.  * param bitstream
  175.  *    the stream to be read from
  176.  *
  177.  * return
  178.  *    the value of the coded syntax element
  179.  *
  180.  *************************************************************************************
  181.  */
  182. int i_v (int LenInBits, char*tracestring, Bitstream *bitstream)
  183. {
  184.   SyntaxElement symbol;
  185.   symbol.inf = 0;
  186.   assert (bitstream->streamBuffer != NULL);
  187.   symbol.type = SE_HEADER;
  188.   symbol.mapping = linfo_ue;   // Mapping rule
  189.   symbol.len = LenInBits;
  190.   SYMTRACESTRING(tracestring);
  191.   readSyntaxElement_FLC (&symbol, bitstream);
  192.   UsedBits+=symbol.len;
  193.   // can be negative
  194.   symbol.inf = -( symbol.inf & (1 << (LenInBits - 1)) ) | symbol.inf;
  195.   return symbol.inf;
  196. }
  197. /*!
  198.  *************************************************************************************
  199.  * brief
  200.  *    ue_v, reads an u(1) syntax element, the length in bits is stored in
  201.  *    the global UsedBits variable
  202.  *
  203.  * param tracestring
  204.  *    the string for the trace file
  205.  *
  206.  * param bitstream
  207.  *    the stream to be read from
  208.  *
  209.  * return
  210.  *    the value of the coded syntax element
  211.  *
  212.  *************************************************************************************
  213.  */
  214. Boolean u_1 (char *tracestring, Bitstream *bitstream)
  215. {
  216.   return (Boolean) u_v (1, tracestring, bitstream);
  217. }
  218. /*!
  219.  ************************************************************************
  220.  * brief
  221.  *    mapping rule for ue(v) syntax elements
  222.  * par Input:
  223.  *    lenght and info
  224.  * par Output:
  225.  *    number in the code table
  226.  ************************************************************************
  227.  */
  228. void linfo_ue(int len, int info, int *value1, int *dummy)
  229. {
  230.   assert ((len >> 1) < 32);
  231.   *value1 = (1 << (len >> 1)) + info - 1;
  232. }
  233. /*!
  234.  ************************************************************************
  235.  * brief
  236.  *    mapping rule for se(v) syntax elements
  237.  * par Input:
  238.  *    lenght and info
  239.  * par Output:
  240.  *    signed mvd
  241.  ************************************************************************
  242.  */
  243. void linfo_se(int len,  int info, int *value1, int *dummy)
  244. {
  245.   int n;
  246.   assert ((len >> 1) < 32);
  247.   n = (1 << (len >> 1)) + info - 1;
  248.   *value1 = (n + 1) >> 1;
  249.   if((n & 0x01) == 0)                           // lsb is signed bit
  250.     *value1 = -*value1;
  251. }
  252. /*!
  253.  ************************************************************************
  254.  * par Input:
  255.  *    length and info
  256.  * par Output:
  257.  *    cbp (intra)
  258.  ************************************************************************
  259.  */
  260. void linfo_cbp_intra(int len,int info,int *cbp, int *dummy)
  261. {
  262.   int cbp_idx;
  263.   linfo_ue(len, info, &cbp_idx, dummy);
  264.   if((active_sps->chroma_format_idc==0)||(active_sps->chroma_format_idc==3))
  265.     *cbp=NCBP[0][cbp_idx][0];
  266.   else
  267.     *cbp=NCBP[1][cbp_idx][0];
  268. }
  269. /*!
  270.  ************************************************************************
  271.  * par Input:
  272.  *    length and info
  273.  * par Output:
  274.  *    cbp (inter)
  275.  ************************************************************************
  276.  */
  277. void linfo_cbp_inter(int len,int info,int *cbp, int *dummy)
  278. {
  279.   int cbp_idx;
  280.   linfo_ue(len, info, &cbp_idx, dummy);
  281.   if((active_sps->chroma_format_idc==0)||(active_sps->chroma_format_idc==3))
  282.     *cbp=NCBP[0][cbp_idx][1];
  283.   else
  284.     *cbp=NCBP[1][cbp_idx][1];
  285. }
  286. /*!
  287.  ************************************************************************
  288.  * par Input:
  289.  *    length and info
  290.  * par Output:
  291.  *    level, run
  292.  ************************************************************************
  293.  */
  294. void linfo_levrun_inter(int len, int info, int *level, int *irun)
  295. {
  296.   int l2;
  297.   int inf;
  298.   assert (((len >> 1) - 5) < 32);
  299.   
  300.   if (len <= 9)
  301.   {
  302.     l2     = imax(0,(len >> 1)-1);
  303.     inf    = info >> 1;
  304.     *level = NTAB1[l2][inf][0];
  305.     *irun  = NTAB1[l2][inf][1];
  306.     if ((info & 0x01) == 1)
  307.       *level = -*level;                   // make sign
  308.   }
  309.   else                                  // if len > 9, skip using the array
  310.   {
  311.     *irun  = (info & 0x1e) >> 1;
  312.     *level = LEVRUN1[*irun] + (info >> 5) + ( 1 << ((len >> 1) - 5));
  313.     if ((info & 0x01) == 1)
  314.       *level = -*level;
  315.   }
  316.   
  317.   if (len == 1) // EOB
  318.     *level = 0;
  319. }
  320. /*!
  321.  ************************************************************************
  322.  * par Input:
  323.  *    length and info
  324.  * par Output:
  325.  *    level, run
  326.  ************************************************************************
  327.  */
  328. void linfo_levrun_c2x2(int len, int info, int *level, int *irun)
  329. {
  330.   int l2;
  331.   int inf;
  332.   if (len<=5)
  333.   {
  334.     l2     = imax(0, (len >> 1) - 1);
  335.     inf    = info >> 1;
  336.     *level = NTAB3[l2][inf][0];
  337.     *irun  = NTAB3[l2][inf][1];
  338.     if ((info & 0x01) == 1)
  339.       *level = -*level;                 // make sign
  340.   }
  341.   else                                  // if len > 5, skip using the array
  342.   {
  343.     *irun  = (info & 0x06) >> 1;
  344.     *level = LEVRUN3[*irun] + (info >> 3) + (1 << ((len >> 1) - 3));
  345.     if ((info & 0x01) == 1)
  346.       *level = -*level;
  347.   }
  348.   if (len == 1) // EOB
  349.     *level = 0;
  350. }
  351. /*!
  352.  ************************************************************************
  353.  * brief
  354.  *    read next UVLC codeword from UVLC-partition and
  355.  *    map it to the corresponding syntax element
  356.  ************************************************************************
  357.  */
  358. int readSyntaxElement_VLC(SyntaxElement *sym, Bitstream *currStream)
  359. {
  360.   int frame_bitoffset        = currStream->frame_bitoffset;
  361.   int BitstreamLengthInBytes = currStream->bitstream_length;
  362.   byte *buf                  = currStream->streamBuffer;
  363.   sym->len =  GetVLCSymbol (buf, frame_bitoffset, &(sym->inf), BitstreamLengthInBytes);
  364.   if (sym->len == -1)
  365.     return -1;
  366.   currStream->frame_bitoffset += sym->len;
  367.   sym->mapping(sym->len,sym->inf,&(sym->value1),&(sym->value2));
  368. #if TRACE
  369.   tracebits(sym->tracestring, sym->len, sym->inf, sym->value1);
  370. #endif
  371.   return 1;
  372. }
  373. /*!
  374.  ************************************************************************
  375.  * brief
  376.  *    read next UVLC codeword from UVLC-partition and
  377.  *    map it to the corresponding syntax element
  378.  ************************************************************************
  379.  */
  380. int readSyntaxElement_UVLC(SyntaxElement *sym, ImageParameters *img, struct datapartition *dP)
  381. {
  382.   return (readSyntaxElement_VLC(sym, dP->bitstream));
  383. }
  384. /*!
  385.  ************************************************************************
  386.  * brief
  387.  *    read next VLC codeword for 4x4 Intra Prediction Mode and
  388.  *    map it to the corresponding Intra Prediction Direction
  389.  ************************************************************************
  390.  */
  391. int readSyntaxElement_Intra4x4PredictionMode(SyntaxElement *sym, ImageParameters *img, Bitstream   *currStream)
  392. {
  393.   int         *frame_bitoffset       = &currStream->frame_bitoffset;
  394.   sym->len = GetVLCSymbol_IntraMode (currStream->streamBuffer, *frame_bitoffset, &(sym->inf), currStream->bitstream_length);
  395.   if (sym->len == -1)
  396.     return -1;
  397.   *frame_bitoffset += sym->len;
  398.   sym->value1       = (sym->len == 1) ? -1 : sym->inf;
  399. #if TRACE
  400.   tracebits2(sym->tracestring, sym->len, sym->value1);
  401. #endif
  402.   return 1;
  403. }
  404. int GetVLCSymbol_IntraMode (byte buffer[],int totbitoffset,int *info, int bytecount)
  405. {
  406.   register int inf;
  407.   long byteoffset = (totbitoffset >> 3);        // byte from start of buffer
  408.   int bitoffset   = (7 - (totbitoffset & 0x07)); // bit from start of byte
  409.   byte *cur_byte  = &(buffer[byteoffset]);
  410.   int ctr_bit     = (*cur_byte & (0x01 << bitoffset));      // control bit for current bit posision
  411.   int bitcounter  = 1;
  412.   int len         = 0;
  413.   //First bit
  414.   if (ctr_bit)
  415.   {
  416.     *info = 0;
  417.     return bitcounter;
  418.   }
  419.   else
  420.     len = 3;
  421.   if (byteoffset + ((len + 7) >> 3) > bytecount)
  422.     return -1;
  423.   // make infoword
  424.   inf = 0;                          // shortest possible code is 1, then info is always 0    
  425.   while (len--)
  426.   {
  427.     bitcounter++;
  428.     bitoffset --;
  429.     bitoffset &= 0x07;
  430.     cur_byte  += (bitoffset == 7);
  431.     inf <<= 1;
  432.     inf |= ((*cur_byte)>> (bitoffset)) & 0x01;
  433.   }
  434.   *info = inf;
  435.   return bitcounter;           // return absolute offset in bit from start of frame
  436. }
  437. /*!
  438.  ************************************************************************
  439.  * brief
  440.  *    test if bit buffer contains only stop bit
  441.  *
  442.  * param buffer
  443.  *    buffer containing VLC-coded data bits
  444.  * param totbitoffset
  445.  *    bit offset from start of partition
  446.  * param bytecount
  447.  *    buffer length
  448.  * return
  449.  *    true if more bits available
  450.  ************************************************************************
  451.  */
  452. int more_rbsp_data (byte buffer[],int totbitoffset,int bytecount)
  453. {
  454.   int bitoffset   = (7 - (totbitoffset & 0x07));      // bit from start of byte
  455.   long byteoffset = (totbitoffset >> 3);      // byte from start of buffer
  456.   byte *cur_byte  = &(buffer[byteoffset]);
  457.   int ctr_bit     = 0;      // control bit for current bit posision
  458.   int cnt         = 0;
  459.   assert (byteoffset<bytecount);
  460.   // there is more until we're in the last byte
  461.   if (byteoffset < (bytecount - 1)) return TRUE;
  462.   // read one bit
  463.   ctr_bit = ((*cur_byte)>> (bitoffset--)) & 0x01;
  464.   // a stop bit has to be one
  465.   if (ctr_bit==0) return TRUE;  
  466.   while (bitoffset>=0 && !cnt)
  467.   {
  468.     cnt |= ((*cur_byte)>> (bitoffset--)) & 0x01;   // set up control bit
  469.   }
  470.   return (cnt);
  471. }
  472. /*!
  473.  ************************************************************************
  474.  * brief
  475.  *    Check if there are symbols for the next MB
  476.  ************************************************************************
  477.  */
  478. int uvlc_startcode_follows(Slice *currSlice, int dummy)
  479. {
  480.   int dp_Nr = assignSE2partition[currSlice->dp_mode][SE_MBTYPE];
  481.   DataPartition *dP = &(currSlice->partArr[dp_Nr]);
  482.   Bitstream   *currStream = dP->bitstream;
  483.   byte *buf  = currStream->streamBuffer;
  484.   //KS: new function test for End of Buffer
  485.   return (!(more_rbsp_data(buf, currStream->frame_bitoffset,currStream->bitstream_length)));
  486. }
  487. /*!
  488.  ************************************************************************
  489.  * brief
  490.  *  read one exp-golomb VLC symbol
  491.  *
  492.  * param buffer
  493.  *    containing VLC-coded data bits
  494.  * param totbitoffset
  495.  *    bit offset from start of partition
  496.  * param  info
  497.  *    returns the value of the symbol
  498.  * param bytecount
  499.  *    buffer length
  500.  * return
  501.  *    bits read
  502.  ************************************************************************
  503.  */
  504. int GetVLCSymbol (byte buffer[],int totbitoffset,int *info, int bytecount)
  505. {
  506.   register int inf;
  507.   long byteoffset = (totbitoffset >> 3);         // byte from start of buffer
  508.   int  bitoffset  = (7 - (totbitoffset & 0x07)); // bit from start of byte
  509.   int  bitcounter = 1;
  510.   int  len        = 0;
  511.   byte *cur_byte = &(buffer[byteoffset]);
  512.   int  ctr_bit    = ((*cur_byte) >> (bitoffset)) & 0x01;  // control bit for current bit posision
  513.   while (ctr_bit == 0)
  514.   {                 // find leading 1 bit
  515.     len++;
  516.     bitcounter++;
  517.     bitoffset--;
  518.     bitoffset &= 0x07;
  519.     cur_byte  += (bitoffset == 7);
  520.     byteoffset+= (bitoffset == 7);      
  521.     ctr_bit    = ((*cur_byte) >> (bitoffset)) & 0x01;
  522.   }
  523.   if (byteoffset + ((len + 7) >> 3) > bytecount)
  524.     return -1;
  525.   // make infoword
  526.   inf = 0;                          // shortest possible code is 1, then info is always 0    
  527.   while (len--)
  528.   {
  529.     bitoffset --;    
  530.     bitoffset &= 0x07;
  531.     cur_byte  += (bitoffset == 7);
  532.     bitcounter++;
  533.     inf <<= 1;    
  534.     inf |= ((*cur_byte) >> (bitoffset)) & 0x01;
  535.   }
  536.   *info = inf;
  537.   return bitcounter;           // return absolute offset in bit from start of frame
  538. }
  539. extern void tracebits2(const char *trace_str,  int len,  int info) ;
  540. /*!
  541.  ************************************************************************
  542.  * brief
  543.  *    code from bitstream (2d tables)
  544.  ************************************************************************
  545.  */
  546. int code_from_bitstream_2d(SyntaxElement *sym,
  547.                            Bitstream *currStream,
  548.                            const int *lentab,
  549.                            const int *codtab,
  550.                            int tabwidth,
  551.                            int tabheight,
  552.                            int *code)
  553. {
  554.   int frame_bitoffset        = currStream->frame_bitoffset;
  555.   int BitstreamLengthInBytes = currStream->bitstream_length - (frame_bitoffset >> 3);
  556.   byte *buf                  = &currStream->streamBuffer[frame_bitoffset>>3];
  557.   int current_bit_pos        = 7 - (frame_bitoffset & 0x07);
  558.   int i, j;
  559.   const int *len = &lentab[0], *cod = &codtab[0];
  560.   // this VLC decoding method is not optimized for speed
  561.   for (j = 0; j < tabheight; j++) 
  562.   {
  563.     for (i = 0; i < tabwidth; i++)
  564.     {
  565.       //if ((*len == 0) || (ShowBits(buf, frame_bitoffset, BitstreamLengthInBytes, *len) != *cod))
  566.       if ((*len == 0) || (ShowBitsThres(buf, current_bit_pos, BitstreamLengthInBytes, *len, *cod) != *cod))
  567.       {
  568.         len++;
  569.         cod++;
  570.       }
  571.       else
  572.       {
  573.         sym->value1 = i;
  574.         sym->value2 = j;        
  575.         sym->len = *len;
  576.         currStream->frame_bitoffset += *len; // move bitstream pointer
  577.         *code = *cod;                        // found code and return
  578.         return 0;
  579.       }
  580.     }
  581.   }
  582.   return -1;  // failed to find code
  583. }
  584. /*!
  585.  ************************************************************************
  586.  * brief
  587.  *    read FLC codeword from UVLC-partition
  588.  ************************************************************************
  589.  */
  590. int readSyntaxElement_FLC(SyntaxElement *sym, Bitstream *currStream)
  591. {
  592.   int frame_bitoffset        = currStream->frame_bitoffset;
  593.   int BitstreamLengthInBytes = currStream->bitstream_length;
  594.   byte *buf                  = currStream->streamBuffer;
  595.   if ((GetBits(buf, frame_bitoffset, &(sym->inf), BitstreamLengthInBytes, sym->len)) < 0)
  596.     return -1;
  597.   sym->value1 = sym->inf;
  598.   currStream->frame_bitoffset += sym->len; // move bitstream pointer
  599. #if TRACE
  600.   tracebits2(sym->tracestring, sym->len, sym->inf);
  601. #endif
  602.   return 1;
  603. }
  604. /*!
  605.  ************************************************************************
  606.  * brief
  607.  *    read NumCoeff/TrailingOnes codeword from UVLC-partition
  608.  ************************************************************************
  609.  */
  610. int readSyntaxElement_NumCoeffTrailingOnes(SyntaxElement *sym,  
  611.                                            Bitstream *currStream,
  612.                                            char *type)
  613. {
  614.   int frame_bitoffset        = currStream->frame_bitoffset;
  615.   int BitstreamLengthInBytes = currStream->bitstream_length;
  616.   byte *buf                  = currStream->streamBuffer;
  617.   static const int lentab[3][4][17] =
  618.   {
  619.     {   // 0702
  620.       { 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
  621.       { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
  622.       { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
  623.       { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16},
  624.     },
  625.     {
  626.       { 2, 6, 6, 7, 8, 8, 9,11,11,12,12,12,13,13,13,14,14},
  627.       { 0, 2, 5, 6, 6, 7, 8, 9,11,11,12,12,13,13,14,14,14},
  628.       { 0, 0, 3, 6, 6, 7, 8, 9,11,11,12,12,13,13,13,14,14},
  629.       { 0, 0, 0, 4, 4, 5, 6, 6, 7, 9,11,11,12,13,13,13,14},
  630.     },
  631.     {
  632.       { 4, 6, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,10},
  633.       { 0, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9,10,10,10},
  634.       { 0, 0, 4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,10},
  635.       { 0, 0, 0, 4, 4, 4, 4, 4, 5, 6, 7, 8, 8, 9,10,10,10},
  636.     },
  637.   };
  638.   static const int codtab[3][4][17] =
  639.   {
  640.     {
  641.       { 1, 5, 7, 7, 7, 7,15,11, 8,15,11,15,11,15,11, 7,4},
  642.       { 0, 1, 4, 6, 6, 6, 6,14,10,14,10,14,10, 1,14,10,6},
  643.       { 0, 0, 1, 5, 5, 5, 5, 5,13, 9,13, 9,13, 9,13, 9,5},
  644.       { 0, 0, 0, 3, 3, 4, 4, 4, 4, 4,12,12, 8,12, 8,12,8},
  645.     },
  646.     {
  647.       { 3,11, 7, 7, 7, 4, 7,15,11,15,11, 8,15,11, 7, 9,7},
  648.       { 0, 2, 7,10, 6, 6, 6, 6,14,10,14,10,14,10,11, 8,6},
  649.       { 0, 0, 3, 9, 5, 5, 5, 5,13, 9,13, 9,13, 9, 6,10,5},
  650.       { 0, 0, 0, 5, 4, 6, 8, 4, 4, 4,12, 8,12,12, 8, 1,4},
  651.     },
  652.     {
  653.       {15,15,11, 8,15,11, 9, 8,15,11,15,11, 8,13, 9, 5,1},
  654.       { 0,14,15,12,10, 8,14,10,14,14,10,14,10, 7,12, 8,4},
  655.       { 0, 0,13,14,11, 9,13, 9,13,10,13, 9,13, 9,11, 7,3},
  656.       { 0, 0, 0,12,11,10, 9, 8,13,12,12,12, 8,12,10, 6,2},
  657.     },
  658.   };
  659.   int retval = 0, code;
  660.   int vlcnum = sym->value1;
  661.   // vlcnum is the index of Table used to code coeff_token
  662.   // vlcnum==3 means (8<=nC) which uses 6bit FLC
  663.   if (vlcnum == 3)
  664.   {
  665.     // read 6 bit FLC
  666.     code = ShowBits(buf, frame_bitoffset, BitstreamLengthInBytes, 6);
  667.     currStream->frame_bitoffset += 6;
  668.     sym->value2 = (code & 3);
  669.     sym->value1 = (code >> 2);
  670.     if (!sym->value1 && sym->value2 == 3)
  671.     {
  672.       // #c = 0, #t1 = 3 =>  #c = 0
  673.       sym->value2 = 0;
  674.     }
  675.     else
  676.       sym->value1++;
  677.     sym->len = 6;
  678.   }
  679.   else
  680.   {
  681.     //retval = code_from_bitstream_2d(sym, currStream, &lentab[vlcnum][0][0], &codtab[vlcnum][0][0], 17, 4, &code);    
  682.     retval = code_from_bitstream_2d(sym, currStream, lentab[vlcnum][0], codtab[vlcnum][0], 17, 4, &code);
  683.     if (retval)
  684.     {
  685.       printf("ERROR: failed to find NumCoeff/TrailingOnesn");
  686.       exit(-1);
  687.     }
  688.   }
  689. #if TRACE
  690.   snprintf(sym->tracestring,
  691.     TRACESTRING_SIZE, "%s # c & tr.1s vlc=%d #c=%d #t1=%d",
  692.            type, vlcnum, sym->value1, sym->value2);
  693.   tracebits2(sym->tracestring, sym->len, code);
  694. #endif
  695.   return retval;
  696. }
  697. /*!
  698.  ************************************************************************
  699.  * brief
  700.  *    read NumCoeff/TrailingOnes codeword from UVLC-partition ChromaDC
  701.  ************************************************************************
  702.  */
  703. int readSyntaxElement_NumCoeffTrailingOnesChromaDC(SyntaxElement *sym,  Bitstream *currStream)
  704. {
  705.   static const int lentab[3][4][17] =
  706.   {
  707.     //YUV420
  708.    {{ 2, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  709.     { 0, 1, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  710.     { 0, 0, 3, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  711.     { 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
  712.     //YUV422
  713.    {{ 1, 7, 7, 9, 9,10,11,12,13, 0, 0, 0, 0, 0, 0, 0, 0},
  714.     { 0, 2, 7, 7, 9,10,11,12,12, 0, 0, 0, 0, 0, 0, 0, 0},
  715.     { 0, 0, 3, 7, 7, 9,10,11,12, 0, 0, 0, 0, 0, 0, 0, 0},
  716.     { 0, 0, 0, 5, 6, 7, 7,10,11, 0, 0, 0, 0, 0, 0, 0, 0}},
  717.     //YUV444
  718.    {{ 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
  719.     { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
  720.     { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
  721.     { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}}
  722.   };
  723.   static const int codtab[3][4][17] =
  724.   {
  725.     //YUV420
  726.    {{ 1, 7, 4, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  727.     { 0, 1, 6, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  728.     { 0, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  729.     { 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
  730.     //YUV422
  731.    {{ 1,15,14, 7, 6, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0},
  732.     { 0, 1,13,12, 5, 6, 6, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0},
  733.     { 0, 0, 1,11,10, 4, 5, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0},
  734.     { 0, 0, 0, 1, 1, 9, 8, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0}},
  735.     //YUV444
  736.    {{ 1, 5, 7, 7, 7, 7,15,11, 8,15,11,15,11,15,11, 7, 4},
  737.     { 0, 1, 4, 6, 6, 6, 6,14,10,14,10,14,10, 1,14,10, 6},
  738.     { 0, 0, 1, 5, 5, 5, 5, 5,13, 9,13, 9,13, 9,13, 9, 5},
  739.     { 0, 0, 0, 3, 3, 4, 4, 4, 4, 4,12,12, 8,12, 8,12, 8}}
  740.   };
  741.    
  742.   int code;
  743.   int yuv = active_sps->chroma_format_idc - 1;
  744.   int retval = code_from_bitstream_2d(sym, currStream, &lentab[yuv][0][0], &codtab[yuv][0][0], 17, 4, &code);
  745.   if (retval)
  746.   {
  747.     printf("ERROR: failed to find NumCoeff/TrailingOnes ChromaDCn");
  748.     exit(-1);
  749.   }
  750. #if TRACE
  751.     snprintf(sym->tracestring,
  752.       TRACESTRING_SIZE, "ChrDC # c & tr.1s  #c=%d #t1=%d",
  753.               sym->value1, sym->value2);
  754.     tracebits2(sym->tracestring, sym->len, code);
  755. #endif
  756.   return retval;
  757. }
  758. /*!
  759.  ************************************************************************
  760.  * brief
  761.  *    read Level VLC0 codeword from UVLC-partition
  762.  ************************************************************************
  763.  */
  764. int readSyntaxElement_Level_VLC0(SyntaxElement *sym, Bitstream *currStream)
  765. {
  766.   int frame_bitoffset        = currStream->frame_bitoffset;
  767.   int BitstreamLengthInBytes = currStream->bitstream_length;
  768.   byte *buf                  = currStream->streamBuffer;
  769.   int len = 0, sign=0, level=0, code = 1;
  770.   int offset, addbit;
  771.   while (!ShowBits(buf, frame_bitoffset+len, BitstreamLengthInBytes, 1))
  772.     len++;
  773.   len++;
  774.   frame_bitoffset += len;
  775.   if (len < 15)
  776.   {
  777.     sign  = (len - 1) & 1;
  778.     level = ((len - 1) >> 1) + 1;
  779.   }
  780.   else if (len == 15)
  781.   {
  782.     // escape code
  783.     code <<= 4;
  784.     code |= ShowBits(buf, frame_bitoffset, BitstreamLengthInBytes, 4);
  785.     len  += 4;
  786.     frame_bitoffset += 4;
  787.     sign = (code & 0x01);
  788.     level = ((code >> 1) & 0x07) + 8;
  789.   }
  790.   else if (len >= 16)
  791.   {
  792.     // escape code
  793.     addbit = (len - 16);
  794.     len   -= 4;
  795.     code   = ShowBits(buf, frame_bitoffset, BitstreamLengthInBytes, len);
  796.     sign   = (code & 0x01);
  797.     frame_bitoffset += len;    
  798.     offset = (2048 << addbit) - 2032;
  799.     level = (code >> 1) + offset;
  800.     code |= (1 << (len)); // for display purpose only
  801.     len += addbit + 16;
  802.  }
  803.   sym->inf = (sign) ? -level : level ;
  804.   sym->len = len;
  805. #if TRACE
  806.   tracebits2(sym->tracestring, sym->len, code);
  807. #endif
  808.   currStream->frame_bitoffset = frame_bitoffset;
  809.   return 0;
  810. }
  811. /*!
  812.  ************************************************************************
  813.  * brief
  814.  *    read Level VLC codeword from UVLC-partition
  815.  ************************************************************************
  816.  */
  817. int readSyntaxElement_Level_VLCN(SyntaxElement *sym, int vlc, Bitstream *currStream)
  818. {
  819.   int frame_bitoffset        = currStream->frame_bitoffset;
  820.   int BitstreamLengthInBytes = currStream->bitstream_length;
  821.   byte *buf                  = currStream->streamBuffer;
  822.   int levabs, sign;
  823.   int len = 0;
  824.   int code = 1, sb;
  825.   int numPrefix = 0;
  826.   int shift = vlc - 1;
  827.   int escape = (15 << shift) + 1;
  828.   int addbit, offset;
  829.   // read pre zeros
  830.   while (!ShowBits(buf, frame_bitoffset + numPrefix, BitstreamLengthInBytes, 1))
  831.     numPrefix++;
  832.   len = numPrefix + 1;
  833.   if (numPrefix < 15)
  834.   {
  835.     levabs = (numPrefix << shift) + 1;
  836.     // read (vlc-1) bits -> suffix
  837.     if (shift)
  838.     {
  839.       sb =  ShowBits(buf, frame_bitoffset + len, BitstreamLengthInBytes, shift);
  840.       code = (code << (shift) )| sb;
  841.       levabs += sb;
  842.       len += (shift);
  843.     }
  844.     // read 1 bit -> sign
  845.     sign = ShowBits(buf, frame_bitoffset + len, BitstreamLengthInBytes, 1);
  846.     code = (code << 1)| sign;
  847.     len ++;
  848.   }
  849.   else // escape
  850.   {
  851.     addbit = numPrefix - 15;
  852.     sb = ShowBits(buf, frame_bitoffset + len, BitstreamLengthInBytes, (11 + addbit));
  853.     code = (code << (11 + addbit) )| sb;
  854.     len   += (11 + addbit);
  855.     offset = (2048 << addbit) + escape - 2048;
  856.     levabs = sb + offset;
  857.     
  858.     // read 1 bit -> sign
  859.     sign = ShowBits(buf, frame_bitoffset + len, BitstreamLengthInBytes, 1);
  860.     code = (code << 1)| sign;
  861.     len++;
  862.   }
  863.   sym->inf = (sign)? -levabs : levabs;
  864.   sym->len = len;
  865.   currStream->frame_bitoffset = frame_bitoffset+len;
  866. #if TRACE
  867.   tracebits2(sym->tracestring, sym->len, code);
  868. #endif
  869.   return 0;
  870. }
  871. /*!
  872.  ************************************************************************
  873.  * brief
  874.  *    read Total Zeros codeword from UVLC-partition
  875.  ************************************************************************
  876.  */
  877. int readSyntaxElement_TotalZeros(SyntaxElement *sym,  Bitstream *currStream)
  878. {
  879.   static const int lentab[TOTRUN_NUM][16] =
  880.   {
  881.     { 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
  882.     { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
  883.     { 4,3,3,3,4,4,3,3,4,5,5,6,5,6},
  884.     { 5,3,4,4,3,3,3,4,3,4,5,5,5},
  885.     { 4,4,4,3,3,3,3,3,4,5,4,5},
  886.     { 6,5,3,3,3,3,3,3,4,3,6},
  887.     { 6,5,3,3,3,2,3,4,3,6},
  888.     { 6,4,5,3,2,2,3,3,6},
  889.     { 6,6,4,2,2,3,2,5},
  890.     { 5,5,3,2,2,2,4},
  891.     { 4,4,3,3,1,3},
  892.     { 4,4,2,1,3},
  893.     { 3,3,1,2},
  894.     { 2,2,1},
  895.     { 1,1},
  896.   };
  897.   static const int codtab[TOTRUN_NUM][16] =
  898.   {
  899.     {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
  900.     {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
  901.     {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
  902.     {3,7,5,4,6,5,4,3,3,2,2,1,0},
  903.     {5,4,3,7,6,5,4,3,2,1,1,0},
  904.     {1,1,7,6,5,4,3,2,1,1,0},
  905.     {1,1,5,4,3,3,2,1,1,0},
  906.     {1,1,1,3,3,2,2,1,0},
  907.     {1,0,1,3,2,1,1,1,},
  908.     {1,0,1,3,2,1,1,},
  909.     {0,1,1,2,1,3},
  910.     {0,1,1,1,1},
  911.     {0,1,1,1},
  912.     {0,1,1},
  913.     {0,1},
  914.   };
  915.   int code;
  916.   int vlcnum = sym->value1;
  917.   int retval = code_from_bitstream_2d(sym, currStream, &lentab[vlcnum][0], &codtab[vlcnum][0], 16, 1, &code);
  918.   if (retval)
  919.   {
  920.     printf("ERROR: failed to find Total Zeros !cdcn");
  921.     exit(-1);
  922.   }
  923. #if TRACE
  924.     tracebits2(sym->tracestring, sym->len, code);
  925. #endif
  926.   return retval;
  927. }
  928. /*!
  929.  ************************************************************************
  930.  * brief
  931.  *    read Total Zeros Chroma DC codeword from UVLC-partition
  932.  ************************************************************************
  933.  */
  934. int readSyntaxElement_TotalZerosChromaDC(SyntaxElement *sym,  Bitstream *currStream)
  935. {
  936.   static const int lentab[3][TOTRUN_NUM][16] =
  937.   {
  938.     //YUV420
  939.    {{ 1,2,3,3},
  940.     { 1,2,2},
  941.     { 1,1}},
  942.     //YUV422
  943.    {{ 1,3,3,4,4,4,5,5},
  944.     { 3,2,3,3,3,3,3},
  945.     { 3,3,2,2,3,3},
  946.     { 3,2,2,2,3},
  947.     { 2,2,2,2},
  948.     { 2,2,1},
  949.     { 1,1}},
  950.     //YUV444
  951.    {{ 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
  952.     { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
  953.     { 4,3,3,3,4,4,3,3,4,5,5,6,5,6},
  954.     { 5,3,4,4,3,3,3,4,3,4,5,5,5},
  955.     { 4,4,4,3,3,3,3,3,4,5,4,5},
  956.     { 6,5,3,3,3,3,3,3,4,3,6},
  957.     { 6,5,3,3,3,2,3,4,3,6},
  958.     { 6,4,5,3,2,2,3,3,6},
  959.     { 6,6,4,2,2,3,2,5},
  960.     { 5,5,3,2,2,2,4},
  961.     { 4,4,3,3,1,3},
  962.     { 4,4,2,1,3},
  963.     { 3,3,1,2},
  964.     { 2,2,1},
  965.     { 1,1}}
  966.   };
  967.   static const int codtab[3][TOTRUN_NUM][16] =
  968.   {
  969.     //YUV420
  970.    {{ 1,1,1,0},
  971.     { 1,1,0},
  972.     { 1,0}},
  973.     //YUV422
  974.    {{ 1,2,3,2,3,1,1,0},
  975.     { 0,1,1,4,5,6,7},
  976.     { 0,1,1,2,6,7},
  977.     { 6,0,1,2,7},
  978.     { 0,1,2,3},
  979.     { 0,1,1},
  980.     { 0,1}},
  981.     //YUV444
  982.    {{1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
  983.     {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
  984.     {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
  985.     {3,7,5,4,6,5,4,3,3,2,2,1,0},
  986.     {5,4,3,7,6,5,4,3,2,1,1,0},
  987.     {1,1,7,6,5,4,3,2,1,1,0},
  988.     {1,1,5,4,3,3,2,1,1,0},
  989.     {1,1,1,3,3,2,2,1,0},
  990.     {1,0,1,3,2,1,1,1,},
  991.     {1,0,1,3,2,1,1,},
  992.     {0,1,1,2,1,3},
  993.     {0,1,1,1,1},
  994.     {0,1,1,1},
  995.     {0,1,1},
  996.     {0,1}}
  997.   };
  998.   int code;
  999.   int yuv = active_sps->chroma_format_idc - 1;
  1000.   int vlcnum = sym->value1;
  1001.   int retval = code_from_bitstream_2d(sym, currStream, &lentab[yuv][vlcnum][0], &codtab[yuv][vlcnum][0], 16, 1, &code);
  1002.   if (retval)
  1003.   {
  1004.     printf("ERROR: failed to find Total Zerosn");
  1005.     exit(-1);
  1006.   }
  1007. #if TRACE
  1008.   tracebits2(sym->tracestring, sym->len, code);
  1009. #endif
  1010.   return retval;
  1011. }
  1012. /*!
  1013.  ************************************************************************
  1014.  * brief
  1015.  *    read  Run codeword from UVLC-partition
  1016.  ************************************************************************
  1017.  */
  1018. int readSyntaxElement_Run(SyntaxElement *sym, Bitstream *currStream)
  1019. {
  1020.   static const int lentab[TOTRUN_NUM][16] =
  1021.   {
  1022.     {1,1},
  1023.     {1,2,2},
  1024.     {2,2,2,2},
  1025.     {2,2,2,3,3},
  1026.     {2,2,3,3,3,3},
  1027.     {2,3,3,3,3,3,3},
  1028.     {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
  1029.   };
  1030.   static const int codtab[TOTRUN_NUM][16] =
  1031.   {
  1032.     {1,0},
  1033.     {1,1,0},
  1034.     {3,2,1,0},
  1035.     {3,2,1,1,0},
  1036.     {3,2,3,2,1,0},
  1037.     {3,0,1,3,2,5,4},
  1038.     {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
  1039.   };
  1040.   int code;
  1041.   int vlcnum = sym->value1;
  1042.   int retval = code_from_bitstream_2d(sym, currStream, &lentab[vlcnum][0], &codtab[vlcnum][0], 16, 1, &code);
  1043.   if (retval)
  1044.   {
  1045.     printf("ERROR: failed to find Runn");
  1046.     exit(-1);
  1047.   }
  1048. #if TRACE
  1049.     tracebits2(sym->tracestring, sym->len, code);
  1050. #endif
  1051.   return retval;
  1052. }
  1053. /*!
  1054.  ************************************************************************
  1055.  * brief
  1056.  *  Reads bits from the bitstream buffer
  1057.  *
  1058.  * param buffer
  1059.  *    containing VLC-coded data bits
  1060.  * param totbitoffset
  1061.  *    bit offset from start of partition
  1062.  * param info
  1063.  *    returns value of the read bits
  1064.  * param bytecount
  1065.  *    total bytes in bitstream
  1066.  * param numbits
  1067.  *    number of bits to read
  1068.  *
  1069.  ************************************************************************
  1070.  */
  1071. int GetBits (byte buffer[],int totbitoffset,int *info, int bytecount,
  1072.              int numbits)
  1073. {
  1074.   register int inf;
  1075.   int  bitoffset  = (totbitoffset & 0x07); // bit from start of byte
  1076.   long byteoffset = (totbitoffset >> 3);       // byte from start of buffer
  1077.   int  bitcounter = numbits;
  1078.   static byte *curbyte;
  1079.   if ((byteoffset) + ((numbits + bitoffset)>> 3)  > bytecount)
  1080.     return -1;
  1081.   curbyte = &(buffer[byteoffset]);
  1082.   bitoffset = 7 - bitoffset;
  1083.   inf=0;
  1084.   while (numbits--)
  1085.   {
  1086.     inf <<=1;    
  1087.     inf |= ((*curbyte)>> (bitoffset--)) & 0x01;    
  1088.     //curbyte   += (bitoffset >> 3) & 0x01;
  1089.     curbyte   -= (bitoffset >> 3);
  1090.     bitoffset &= 0x07;
  1091.     //curbyte   += (bitoffset == 7);    
  1092.   }
  1093.   *info = inf;
  1094.   return bitcounter;           // return absolute offset in bit from start of frame
  1095. }
  1096. /*!
  1097.  ************************************************************************
  1098.  * brief
  1099.  *  Reads bits from the bitstream buffer
  1100.  *
  1101.  * param buffer
  1102.  *    buffer containing VLC-coded data bits
  1103.  * param totbitoffset
  1104.  *    bit offset from start of partition
  1105.  * param bytecount
  1106.  *    total bytes in bitstream
  1107.  * param numbits
  1108.  *    number of bits to read
  1109.  *
  1110.  ************************************************************************
  1111.  */
  1112. int ShowBits (byte buffer[],int totbitoffset,int bytecount, int numbits)
  1113. {
  1114.   register int inf;
  1115.   int  bitoffset  = (totbitoffset & 0x07); // bit from start of byte
  1116.   long byteoffset = (totbitoffset >> 3);       // byte from start of buffer
  1117.   static byte *curbyte;
  1118.   
  1119.   if ((byteoffset) + ((numbits + bitoffset)>> 3)  > bytecount)
  1120.     return -1;
  1121.   curbyte = &(buffer[byteoffset]);
  1122.   bitoffset = 7 - bitoffset;
  1123.   inf=0;
  1124.   while (numbits--)
  1125.   {
  1126.     inf <<=1;    
  1127.     inf |= ((*curbyte)>> (bitoffset--)) & 0x01;
  1128.     //curbyte   += (bitoffset >> 3) & 0x01;
  1129.     curbyte   -= (bitoffset >> 3);
  1130.     bitoffset &= 0x07;
  1131.     //curbyte   += (bitoffset == 7);    
  1132.   }
  1133.   return inf;           // return absolute offset in bit from start of frame
  1134. }
  1135. /*!
  1136.  ************************************************************************
  1137.  * brief
  1138.  *  Reads bits from the bitstream buffer (Threshold based)
  1139.  *
  1140.  * param curbyte
  1141.  *    current byte position in buffer
  1142.  * param bitoffset
  1143.  *    bit offset at current position
  1144.  * param bytecount
  1145.  *    total bytes in bitstream
  1146.  * param numbits
  1147.  *    number of bits to read
  1148.  * param code
  1149.  *    threshold parameter 
  1150.  *
  1151.  ************************************************************************
  1152.  */
  1153. int ShowBitsThres (byte *curbyte, int bitoffset, int bytecount, int numbits, int code)
  1154. {
  1155.   register int inf;  
  1156.      
  1157.   if (((numbits + 7)>> 3) > bytecount)
  1158.     return -1;
  1159.   else
  1160.   {
  1161.     inf=0;
  1162. #if 0
  1163.     while (numbits--)
  1164.     {
  1165.       inf <<=1;
  1166.       inf |= ((*curbyte)>> (bitoffset--)) & 0x01;
  1167.       if ( inf > code)
  1168.       {
  1169.         return -1;
  1170.       }
  1171.       //curbyte   += (bitoffset >> 3) & 0x01;
  1172.       curbyte   -= (bitoffset >> 3);
  1173.       bitoffset &= 0x07;
  1174.       //curbyte   += (bitoffset == 7);    
  1175.     }
  1176. #else
  1177.     while (numbits--)
  1178.     {
  1179.       inf <<=1;
  1180.       inf |= ((*curbyte)>> (bitoffset--)) & 0x01;
  1181.       if ( (inf << numbits) > code)
  1182.       {
  1183.         return -1;
  1184.       }
  1185.       //curbyte   += (bitoffset >> 3) & 0x01; // the mask does not seem to be needed since value can be 0 or -1 only.
  1186.       curbyte   -= (bitoffset >> 3);
  1187.       bitoffset &= 0x07;
  1188.       //curbyte   += (bitoffset == 7);    
  1189.     }
  1190. #endif
  1191.     return inf;           // return absolute offset in bit from start of frame
  1192.   }
  1193. }
  1194. /*!
  1195.  ************************************************************************
  1196.  * brief
  1197.  *    peek at the next 2 UVLC codeword from UVLC-partition to determine
  1198.  *    if a skipped MB is field/frame
  1199.  ************************************************************************
  1200.  */
  1201. int peekSyntaxElement_UVLC(SyntaxElement *sym, ImageParameters *img, struct datapartition *dP)
  1202. {
  1203.   Bitstream   *currStream    = dP->bitstream;
  1204.   int frame_bitoffset        = currStream->frame_bitoffset;
  1205.   int BitstreamLengthInBytes = currStream->bitstream_length;
  1206.   byte *buf                  = currStream->streamBuffer;
  1207.   sym->len =  GetVLCSymbol (buf, frame_bitoffset, &(sym->inf), BitstreamLengthInBytes);
  1208.   if (sym->len == -1)
  1209.     return -1;
  1210.   frame_bitoffset += sym->len;
  1211.   sym->mapping(sym->len, sym->inf, &(sym->value1), &(sym->value2));
  1212. #if TRACE
  1213.   tracebits(sym->tracestring, sym->len, sym->inf, sym->value1);
  1214. #endif
  1215.   return 1;
  1216. }