开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
vlc.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：38k
源码类别：

Audio

开发平台：

Visual C++

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