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

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

Audio

开发平台：

Visual C++

vlc.c：源码内容
  2. /*!
  3.  ***************************************************************************
  4.  * file vlc.c
  5.  *
  6.  * brief
  7.  *    (CA)VLC coding functions
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *    - Inge Lille-Langoy               <inge.lille-langoy@telenor.com>
  12.  *    - Detlev Marpe                    <marpe@hhi.de>
  13.  *    - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  14.  ***************************************************************************
  15.  */
  17. #include "contributors.h"
  19. #include <math.h>
  21. #include "global.h"
  22. #include "enc_statistics.h"
  23. #include "vlc.h"
  25. #if TRACE
  26. #define SYMTRACESTRING(s) strncpy(sym.tracestring,s,TRACESTRING_SIZE)
  27. #else
  28. #define SYMTRACESTRING(s) // do nothing
  29. #endif
  31. //! gives codeword number from CBP value, both for intra and inter
  32. static const unsigned char NCBP[2][48][2]=
  33. {
  34.   {  // 0      1        2       3       4       5       6       7       8       9      10      11
  35.     { 1, 0},{10, 1},{11, 2},{ 6, 5},{12, 3},{ 7, 6},{14,14},{ 2,10},{13, 4},{15,15},{ 8, 7},{ 3,11},
  36.     { 9, 8},{ 4,12},{ 5,13},{ 0, 9},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},
  37.     { 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},
  38.     { 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0},{ 0, 0}
  39.   },
  40.   {
  41.     { 3, 0},{29, 2},{30, 3},{17, 7},{31, 4},{18, 8},{37,17},{ 8,13},{32, 5},{38,18},{19, 9},{ 9,14},
  42.     {20,10},{10,15},{11,16},{ 2,11},{16, 1},{33,32},{34,33},{21,36},{35,34},{22,37},{39,44},{ 4,40},
  43.     {36,35},{40,45},{23,38},{ 5,41},{24,39},{ 6,42},{ 7,43},{ 1,19},{41, 6},{42,24},{43,25},{25,20},
  44.     {44,26},{26,21},{46,46},{12,28},{45,27},{47,47},{27,22},{13,29},{28,23},{14,30},{15,31},{ 0,12}
  45.   }
  46. };
  49. /*!
  50.  *************************************************************************************
  51.  * brief
  52.  *    ue_v, writes an ue(v) syntax element, returns the length in bits
  53.  *
  54.  * param tracestring
  55.  *    the string for the trace file
  56.  * param value
  57.  *    the value to be coded
  58.  *  param bitstream
  59.  *    the target bitstream the value should be coded into
  60.  *
  61.  * return
  62.  *    Number of bits used by the coded syntax element
  63.  *
  64.  *  note
  65.  *    This function writes always the bit buffer for the progressive scan flag, and
  66.  *    should not be used (or should be modified appropriately) for the interlace crap
  67.  *    When used in the context of the Parameter Sets, this is obviously not a
  68.  *    problem.
  69.  *
  70.  *************************************************************************************
  71.  */
  72. int ue_v (char *tracestring, int value, Bitstream *bitstream)
  73. {
  74.   SyntaxElement symbol, *sym=&symbol;
  75.   sym->value1 = value;
  76.   sym->value2 = 0;
  78.   //assert (bitstream->streamBuffer != NULL);
  80.   ue_linfo(sym->value1,sym->value2,&(sym->len),&(sym->inf));
  81.   symbol2uvlc(sym);
  83.   writeUVLC2buffer (sym, bitstream);
  85. #if TRACE
  86.   strncpy(sym->tracestring,tracestring,TRACESTRING_SIZE);
  87.   trace2out (sym);
  88. #endif
  90.   return (sym->len);
  91. }
  94. /*!
  95.  *************************************************************************************
  96.  * brief
  97.  *    se_v, writes an se(v) syntax element, returns the length in bits
  98.  *
  99.  * param tracestring
  100.  *    the string for the trace file
  101.  * param value
  102.  *    the value to be coded
  103.  *  param bitstream
  104.  *    the target bitstream the value should be coded into
  105.  *
  106.  * return
  107.  *    Number of bits used by the coded syntax element
  108.  *
  109.  *  note
  110.  *    This function writes always the bit buffer for the progressive scan flag, and
  111.  *    should not be used (or should be modified appropriately) for the interlace crap
  112.  *    When used in the context of the Parameter Sets, this is obviously not a
  113.  *    problem.
  114.  *
  115.  *************************************************************************************
  116.  */
  117. int se_v (char *tracestring, int value, Bitstream *bitstream)
  118. {
  119.   SyntaxElement symbol, *sym=&symbol;
  120.   sym->value1 = value;
  121.   sym->value2 = 0;
  123.   //assert (bitstream->streamBuffer != NULL);
  125.   se_linfo(sym->value1,sym->value2,&(sym->len),&(sym->inf));
  126.   symbol2uvlc(sym);
  128.   writeUVLC2buffer (sym, bitstream);
  130. #if TRACE
  131.   strncpy(sym->tracestring,tracestring,TRACESTRING_SIZE);
  132.   trace2out (sym);
  133. #endif
  135.   return (sym->len);
  136. }
  139. /*!
  140.  *************************************************************************************
  141.  * brief
  142.  *    u_1, writes a flag (u(1) syntax element, returns the length in bits,
  143.  *    always 1
  144.  *
  145.  * param tracestring
  146.  *    the string for the trace file
  147.  * param value
  148.  *    the value to be coded
  149.  *  param bitstream
  150.  *    the target bitstream the value should be coded into
  151.  *
  152.  * return
  153.  *    Number of bits used by the coded syntax element (always 1)
  154.  *
  155.  *  note
  156.  *    This function writes always the bit buffer for the progressive scan flag, and
  157.  *    should not be used (or should be modified appropriately) for the interlace crap
  158.  *    When used in the context of the Parameter Sets, this is obviously not a
  159.  *    problem.
  160.  *
  161.  *************************************************************************************
  162.  */
  163. Boolean u_1 (char *tracestring, int value, Bitstream *bitstream)
  164. {
  165.   SyntaxElement symbol, *sym=&symbol;
  167.   sym->bitpattern = value;
  168.   sym->value1 = value;
  169.   sym->len = 1;
  171.   //assert (bitstream->streamBuffer != NULL);
  173.   writeUVLC2buffer(sym, bitstream);
  175. #if TRACE
  176.   strncpy(sym->tracestring,tracestring,TRACESTRING_SIZE);
  177.   trace2out (sym);
  178. #endif
  180.   return ((Boolean) sym->len);
  181. }
  184. /*!
  185.  *************************************************************************************
  186.  * brief
  187.  *    u_v, writes a n bit fixed length syntax element, returns the length in bits,
  188.  *
  189.  * param n
  190.  *    length in bits
  191.  * param tracestring
  192.  *    the string for the trace file
  193.  * param value
  194.  *    the value to be coded
  195.  *  param bitstream
  196.  *    the target bitstream the value should be coded into
  197.  *
  198.  * return
  199.  *    Number of bits used by the coded syntax element
  200.  *
  201.  *  note
  202.  *    This function writes always the bit buffer for the progressive scan flag, and
  203.  *    should not be used (or should be modified appropriately) for the interlace crap
  204.  *    When used in the context of the Parameter Sets, this is obviously not a
  205.  *    problem.
  206.  *
  207.  *************************************************************************************
  208.  */
  210. int u_v (int n, char *tracestring, int value, Bitstream *bitstream)
  211. {
  212.   SyntaxElement symbol, *sym=&symbol;
  214.   sym->bitpattern = value;
  215.   sym->value1 = value;
  216.   sym->len = n;  
  218.   //assert (bitstream->streamBuffer != NULL);
  220.   writeUVLC2buffer(sym, bitstream);
  222. #if TRACE
  223.   strncpy(sym->tracestring,tracestring,TRACESTRING_SIZE);
  224.   trace2out (sym);
  225. #endif
  227.   return (sym->len);
  228. }
  231. /*!
  232.  ************************************************************************
  233.  * brief
  234.  *    mapping for ue(v) syntax elements
  235.  * param ue
  236.  *    value to be mapped
  237.  * param dummy
  238.  *    dummy parameter
  239.  * param info
  240.  *    returns mapped value
  241.  * param len
  242.  *    returns mapped value length
  243.  ************************************************************************
  244.  */
  245. void ue_linfo(int ue, int dummy, int *len,int *info)
  246. {
  247.   int i, nn =(ue+1)>>1;
  249.   for (i=0; i < 33 && nn != 0; i++)
  250.   {
  251.     nn >>= 1;
  252.   }
  253.   *len  = (i << 1) + 1;
  254.   *info = ue + 1 - (1 << i);
  255. }
  258. /*!
  259.  ************************************************************************
  260.  * brief
  261.  *    mapping for se(v) syntax elements
  262.  * param se
  263.  *    value to be mapped
  264.  * param dummy
  265.  *    dummy parameter
  266.  * param len
  267.  *    returns mapped value length
  268.  * param info
  269.  *    returns mapped value
  270.  ************************************************************************
  271.  */
  272. void se_linfo(int se, int dummy, int *len,int *info)
  273. {  
  274.   int sign = (se <= 0) ? 1 : 0;
  275.   int n = iabs(se) << 1;   //  n+1 is the number in the code table.  Based on this we find length and info
  276.   int nn = (n >> 1);
  277.   int i;
  278.   for (i = 0; i < 33 && nn != 0; i++)
  279.   {
  280.     nn >>= 1;
  281.   }
  282.   *len  = (i << 1) + 1;
  283.   *info = n - (1 << i) + sign;
  284. }
  287. /*!
  288.  ************************************************************************
  289.  * par Input:
  290.  *    Number in the code table
  291.  * par Output:
  292.  *    length and info
  293.  ************************************************************************
  294.  */
  295. void cbp_linfo_intra(int cbp, int dummy, int *len,int *info)
  296. {
  297.   ue_linfo(NCBP[((img->yuv_format!=0)&&(img->yuv_format!=3))][cbp][0], dummy, len, info);
  298. }
  301. /*!
  302.  ************************************************************************
  303.  * par Input:
  304.  *    Number in the code table
  305.  * par Output:
  306.  *    length and info
  307.  ************************************************************************
  308.  */
  309. void cbp_linfo_inter(int cbp, int dummy, int *len,int *info)
  310. {
  311.   ue_linfo(NCBP[((img->yuv_format!=0)&&(img->yuv_format!=3))][cbp][1], dummy, len, info);
  312. }
  315. /*!
  316.  ************************************************************************
  317.  * brief
  318.  *    2x2 transform of chroma DC
  319.  * par Input:
  320.  *    level and run for coefficients
  321.  * par Output:
  322.  *    length and info
  323.  * note
  324.  *    see ITU document for bit assignment
  325.  ************************************************************************
  326.  */
  327. void levrun_linfo_c2x2(int level,int run,int *len,int *info)
  328. {
  329.   static const int NTAB[2][2]=
  330.   {
  331.     {1,5},
  332.     {3,0}
  333.   };
  334.   static const int LEVRUN[4]=
  335.   {
  336.     2,1,0,0
  337.   };
  339.   int levabs,i,n,sign = 0,nn;
  341.   if (level == 0) //  check if the coefficient sign EOB (level=0)
  342.   {
  343.     *len=1;
  344.     return;
  345.   }
  347.   if (level <= 0)
  348.   {
  349.     sign=1;
  350.   }
  352.   levabs = iabs(level);
  354.   if (levabs <= LEVRUN[run])
  355.   {
  356.     n = NTAB[levabs - 1][run] + 1;
  357.   }
  358.   else
  359.   {
  360.     n = (levabs - LEVRUN[run]) * 8 + run * 2;
  361.   }
  363.   nn = n >> 1;
  365.   for (i=0; i < 16 && nn != 0; i++)
  366.   {
  367.     nn >>= 1;
  368.   }
  369.   *len  = (i << 1) + 1;
  370.   *info = n - (1 << i) + sign;
  371. }
  374. /*!
  375.  ************************************************************************
  376.  * brief
  377.  *    Single scan coefficients
  378.  * par Input:
  379.  *    level and run for coefficients
  380.  * par Output:
  381.  *    length and info
  382.  * note
  383.  *    see ITU document for bit assignment
  384.  ************************************************************************
  385.  */
  386. void levrun_linfo_inter(int level,int run,int *len,int *info)
  387. {
  388.   static const byte LEVRUN[16]=
  389.   {
  390.     4,2,2,1,1,1,1,1,1,1,0,0,0,0,0,0
  391.   };
  392.   static const byte NTAB[4][10]=
  393.   {
  394.     { 1, 3, 5, 9,11,13,21,23,25,27},
  395.     { 7,17,19, 0, 0, 0, 0, 0, 0, 0},
  396.     {15, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  397.     {29, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  398.   };
  400.   static int levabs,i,n,sign,nn;
  402.   if (level == 0)           //  check for EOB
  403.   {
  404.     *len=1;
  405.     return;
  406.   }
  408.   sign   = (level <= 0) ? 1 : 0;
  409.   levabs = iabs(level);
  411.   n = (levabs <= LEVRUN[run]) ? NTAB[levabs - 1][run] + 1 : (levabs - LEVRUN[run]) * 32 + run * 2;
  413.   nn = n >> 1;
  415.   for (i=0; i < 16 && nn != 0; i++)
  416.   {
  417.     nn >>= 1;
  418.   }
  419.   *len  = (i << 1) + 1;
  420.   *info = n - (1 << i) + sign;
  422. }
  425. /*!
  426.  ************************************************************************
  427.  * brief
  428.  *    Makes code word and passes it back
  429.  *    A code word has the following format: 0 0 0 ... 1 Xn ...X2 X1 X0.
  430.  *
  431.  * par Input:
  432.  *    Info   : Xn..X2 X1 X0                                             n
  433.  *    Length : Total number of bits in the codeword
  434.  ************************************************************************
  435.  */
  436.  // NOTE this function is called with sym->inf > (1<<(sym->len/2)).  The upper bits of inf are junk
  437. int symbol2uvlc(SyntaxElement *sym)
  438. {
  439.   int suffix_len = sym->len >> 1;
  440.   //assert (suffix_len < 32);
  441.   suffix_len = (1 << suffix_len);
  442.   sym->bitpattern = suffix_len | (sym->inf & (suffix_len - 1));
  443.   return 0;
  444. }
  446. /*!
  447. ************************************************************************
  448. * brief
  449. *    generates UVLC code and passes the codeword to the buffer
  450. ************************************************************************
  451. */
  452. void writeSE_UVLC(SyntaxElement *se, DataPartition *dp)
  453. {
  454.   ue_linfo (se->value1,se->value2,&(se->len),&(se->inf));
  455.   symbol2uvlc(se);
  457.   writeUVLC2buffer(se, dp->bitstream);
  459.   if(se->type != SE_HEADER)
  460.     dp->bitstream->write_flag = 1;
  462. #if TRACE
  463.   if(dp->bitstream->trace_enabled)
  464.     trace2out (se);
  465. #endif
  466. }
  468. /*!
  469. ************************************************************************
  470. * brief
  471. *    generates UVLC code and passes the codeword to the buffer
  472. ************************************************************************
  473. */
  474. void writeSE_SVLC(SyntaxElement *se, DataPartition *dp)
  475. {
  476.   se_linfo (se->value1,se->value2,&(se->len),&(se->inf));
  477.   symbol2uvlc(se);
  479.   writeUVLC2buffer(se, dp->bitstream);
  481.   if(se->type != SE_HEADER)
  482.     dp->bitstream->write_flag = 1;
  484. #if TRACE
  485.   if(dp->bitstream->trace_enabled)
  486.     trace2out (se);
  487. #endif
  488. }
  490. /*!
  491. ************************************************************************
  492. * brief
  493. *    generates UVLC code and passes the codeword to the buffer
  494. ************************************************************************
  495. */
  496. void writeCBP_VLC (Macroblock* currMB, SyntaxElement *se, DataPartition *dp)
  497. {
  498.   if (IS_OLDINTRA (currMB) || currMB->mb_type == SI4MB ||  currMB->mb_type == I8MB)
  499.   {
  500.     cbp_linfo_intra (se->value1,se->value2,&(se->len),&(se->inf));
  501.   }
  502.   else
  503.   {
  504.     cbp_linfo_inter (se->value1,se->value2,&(se->len),&(se->inf));
  505.   }
  506.   symbol2uvlc(se);
  508.   writeUVLC2buffer(se, dp->bitstream);
  510.   if(se->type != SE_HEADER)
  511.     dp->bitstream->write_flag = 1;
  513. #if TRACE
  514.   if(dp->bitstream->trace_enabled)
  515.     trace2out (se);
  516. #endif
  517. }
  520. /*!
  521.  ************************************************************************
  522.  * brief
  523.  *    generates code and passes the codeword to the buffer
  524.  ************************************************************************
  525.  */
  526. void writeIntraPredMode_CAVLC(SyntaxElement *se, DataPartition *dp)
  527. {
  529.   if (se->value1 == -1)
  530.   {
  531.     se->len = 1;
  532.     se->inf = 1;
  533.   }
  534.   else
  535.   {
  536.     se->len = 4;
  537.     se->inf = se->value1;
  538.   }
  540.   se->bitpattern = se->inf;
  541.   writeUVLC2buffer(se, dp->bitstream);
  543.   if(se->type != SE_HEADER)
  544.     dp->bitstream->write_flag = 1;
  546. #if TRACE
  547.   if(dp->bitstream->trace_enabled)
  548.     trace2out (se);
  549. #endif
  551.   return;
  552. }
  555. /*!
  556.  ************************************************************************
  557.  * brief
  558.  *    generates UVLC code and passes the codeword to the buffer
  559.  * author
  560.  *  Tian Dong
  561.  ************************************************************************
  562.  */
  563. int writeSyntaxElement2Buf_UVLC(SyntaxElement *se, Bitstream* this_streamBuffer )
  564. {
  566.   se->mapping(se->value1,se->value2,&(se->len),&(se->inf));
  568.   symbol2uvlc(se);
  570.   writeUVLC2buffer(se, this_streamBuffer );
  572. #if TRACE
  573.   if(se->type <= 1)
  574.     trace2out (se);
  575. #endif
  577.   return (se->len);
  578. }
  581. /*!
  582.  ************************************************************************
  583.  * brief
  584.  *    writes UVLC code to the appropriate buffer
  585.  ************************************************************************
  586.  */
  587. void  writeUVLC2buffer(SyntaxElement *se, Bitstream *currStream)
  588. {
  589.   unsigned int mask = 1 << (se->len - 1);
  590.   int i;  
  591.   //byte *streamBuffer = &currStream->streamBuffer[currStream->byte_pos];
  592.   //assert ((se->len-1) < 32);
  594.   // Add the new bits to the bitstream.
  595.   // Write out a byte if it is full
  596.   for (i = 0; i < se->len; i++)
  597.   {
  598.     currStream->byte_buf <<= 1;
  599.     
  600.     if (se->bitpattern & mask)
  601.       currStream->byte_buf |= 1;
  603.     mask >>= 1;
  604.     
  605.     if ((--currStream->bits_to_go) == 0)
  606.     {
  607.       currStream->bits_to_go = 8;      
  608.       currStream->streamBuffer[currStream->byte_pos++] = currStream->byte_buf;
  609.       //currStream->byte_pos++;
  610.       //*(streamBuffer++) = currStream->byte_buf;
  611.       currStream->byte_buf = 0;      
  612.     }
  613.   }
  614. }
  617. /*!
  618.  ************************************************************************
  619.  * brief
  620.  *    generates UVLC code and passes the codeword to the buffer
  621.  * author
  622.  *  Tian Dong
  623.  ************************************************************************
  624.  */
  625. int writeSyntaxElement2Buf_Fixed(SyntaxElement *se, Bitstream* this_streamBuffer )
  626. {
  627.   writeUVLC2buffer(se, this_streamBuffer );
  629. #if TRACE
  630.   if(se->type <= 1)
  631.     trace2out (se);
  632. #endif
  633.   return (se->len);
  634. }
  636. /*!
  637. ************************************************************************
  638. * brief
  639. *    generates UVLC code and passes the codeword to the buffer
  640. * author
  641. *  Tian Dong
  642. ************************************************************************
  643. */
  644. void writeSE_Flag(SyntaxElement *se, DataPartition *dp )
  645. {
  646.   se->len        = 1;
  647.   se->bitpattern = (se->value1 & 1);
  649.   writeUVLC2buffer(se, dp->bitstream );
  651. #if TRACE
  652.   if(dp->bitstream->trace_enabled)
  653.     trace2out (se);
  654. #endif
  655. }
  657. /*!
  658. ************************************************************************
  659. * brief
  660. *    generates UVLC code and passes the codeword to the buffer
  661. * author
  662. *  Tian Dong
  663. ************************************************************************
  664. */
  665. void writeSE_invFlag(SyntaxElement *se, DataPartition *dp )
  666. {
  667.   se->len        = 1;
  668.   se->bitpattern = 1 - (se->value1 & 1);
  670.   writeUVLC2buffer(se, dp->bitstream );
  672. #if TRACE
  673.   if(dp->bitstream->trace_enabled)
  674.     trace2out (se);
  675. #endif
  676. }
  678. /*!
  679. ************************************************************************
  680. * brief
  681. *    generates UVLC code and passes the codeword to the buffer
  682. * author
  683. *  Tian Dong
  684. ************************************************************************
  685. */
  686. void writeSE_Dummy(SyntaxElement *se, DataPartition *dp )
  687. {
  688.   se->len = 0;
  689. }
  692. /*!
  693. ************************************************************************
  694. * brief
  695. *    generates UVLC code and passes the codeword to the buffer
  696. * author
  697. *  Tian Dong
  698. ************************************************************************
  699. */
  700. void writeSE_Fix(SyntaxElement *se, Bitstream *bitstream )
  701. {
  702.   writeUVLC2buffer(se, bitstream);
  704. #if TRACE
  705.   if(bitstream->trace_enabled)
  706.     trace2out (se);
  707. #endif
  708. }
  711. /*!
  712.  ************************************************************************
  713.  * brief
  714.  *    Makes code word and passes it back
  715.  *
  716.  * par Input:
  717.  *    Info   : Xn..X2 X1 X0                                             n
  718.  *    Length : Total number of bits in the codeword
  719.  ************************************************************************
  720.  */
  722. int symbol2vlc(SyntaxElement *sym)
  723. {
  724.   int info_len = sym->len;
  726.   // Convert info into a bitpattern int
  727.   sym->bitpattern = 0;
  729.   // vlc coding
  730.   while(--info_len >= 0)
  731.   {
  732.     sym->bitpattern <<= 1;
  733.     sym->bitpattern |= (0x01 & (sym->inf >> info_len));
  734.   }
  735.   return 0;
  736. }
  739. /*!
  740.  ************************************************************************
  741.  * brief
  742.  *    generates VLC code and passes the codeword to the buffer
  743.  ************************************************************************
  744.  */
  745. int writeSyntaxElement_VLC(SyntaxElement *se, DataPartition *dp)
  746. {
  747.   se->inf = se->value1;
  748.   se->len = se->value2;
  749.   symbol2vlc(se);
  751.   writeUVLC2buffer(se, dp->bitstream);
  753.   if(se->type != SE_HEADER)
  754.     dp->bitstream->write_flag = 1;
  756. #if TRACE
  757.   if(dp->bitstream->trace_enabled)
  758.     trace2out (se);
  759. #endif
  761.   return (se->len);
  762. }
  765. /*!
  766.  ************************************************************************
  767.  * brief
  768.  *    write VLC for NumCoeff and TrailingOnes
  769.  ************************************************************************
  770.  */
  772. int writeSyntaxElement_NumCoeffTrailingOnes(SyntaxElement *se, DataPartition *dp)
  773. {
  774.   static const int lentab[3][4][17] =
  775.   {
  776.     {   // 0702
  777.       { 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
  778.       { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
  779.       { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
  780.       { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16},
  781.     },
  782.     {
  783.       { 2, 6, 6, 7, 8, 8, 9,11,11,12,12,12,13,13,13,14,14},
  784.       { 0, 2, 5, 6, 6, 7, 8, 9,11,11,12,12,13,13,14,14,14},
  785.       { 0, 0, 3, 6, 6, 7, 8, 9,11,11,12,12,13,13,13,14,14},
  786.       { 0, 0, 0, 4, 4, 5, 6, 6, 7, 9,11,11,12,13,13,13,14},
  787.     },
  788.     {
  789.       { 4, 6, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,10},
  790.       { 0, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9,10,10,10},
  791.       { 0, 0, 4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,10},
  792.       { 0, 0, 0, 4, 4, 4, 4, 4, 5, 6, 7, 8, 8, 9,10,10,10},
  793.     },
  795.   };
  797.   static const int codtab[3][4][17] =
  798.   {
  799.     {
  800.       { 1, 5, 7, 7, 7, 7,15,11, 8,15,11,15,11,15,11, 7,4},
  801.       { 0, 1, 4, 6, 6, 6, 6,14,10,14,10,14,10, 1,14,10,6},
  802.       { 0, 0, 1, 5, 5, 5, 5, 5,13, 9,13, 9,13, 9,13, 9,5},
  803.       { 0, 0, 0, 3, 3, 4, 4, 4, 4, 4,12,12, 8,12, 8,12,8},
  804.     },
  805.     {
  806.       { 3,11, 7, 7, 7, 4, 7,15,11,15,11, 8,15,11, 7, 9,7},
  807.       { 0, 2, 7,10, 6, 6, 6, 6,14,10,14,10,14,10,11, 8,6},
  808.       { 0, 0, 3, 9, 5, 5, 5, 5,13, 9,13, 9,13, 9, 6,10,5},
  809.       { 0, 0, 0, 5, 4, 6, 8, 4, 4, 4,12, 8,12,12, 8, 1,4},
  810.     },
  811.     {
  812.       {15,15,11, 8,15,11, 9, 8,15,11,15,11, 8,13, 9, 5,1},
  813.       { 0,14,15,12,10, 8,14,10,14,14,10,14,10, 7,12, 8,4},
  814.       { 0, 0,13,14,11, 9,13, 9,13,10,13, 9,13, 9,11, 7,3},
  815.       { 0, 0, 0,12,11,10, 9, 8,13,12,12,12, 8,12,10, 6,2},
  816.     },
  817.   };
  818.   int vlcnum = se->len;
  820.   // se->value1 : numcoeff
  821.   // se->value2 : numtrailingones
  823.   if (vlcnum == 3)
  824.   {
  825.     se->len = 6;  // 4 + 2 bit FLC
  826.     if (se->value1 > 0)
  827.     {
  828.       se->inf = ((se->value1-1) << 2) | se->value2;
  829.     }
  830.     else
  831.     {
  832.       se->inf = 3;
  833.     }
  834.   }
  835.   else
  836.   {
  837.     se->len = lentab[vlcnum][se->value2][se->value1];
  838.     se->inf = codtab[vlcnum][se->value2][se->value1];
  839.   }
  841.   if (se->len == 0)
  842.   {
  843.     printf("ERROR: (numcoeff,trailingones) not valid: vlc=%d (%d, %d)n",
  844.       vlcnum, se->value1, se->value2);
  845.     exit(-1);
  846.   }
  848.   symbol2vlc(se);
  850.   writeUVLC2buffer(se, dp->bitstream);
  852.   if(se->type != SE_HEADER)
  853.     dp->bitstream->write_flag = 1;
  855. #if TRACE
  856.   if(dp->bitstream->trace_enabled)
  857.     trace2out (se);
  858. #endif
  860.   return (se->len);
  861. }
  864. /*!
  865.  ************************************************************************
  866.  * brief
  867.  *    write VLC for NumCoeff and TrailingOnes for Chroma DC
  868.  ************************************************************************
  869.  */
  870. int writeSyntaxElement_NumCoeffTrailingOnesChromaDC(SyntaxElement *se, DataPartition *dp)
  871. {
  872.   static const int lentab[3][4][17] =
  873.   {
  874.     //YUV420
  875.    {{ 2, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  876.     { 0, 1, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  877.     { 0, 0, 3, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  878.     { 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
  879.     //YUV422
  880.    {{ 1, 7, 7, 9, 9,10,11,12,13, 0, 0, 0, 0, 0, 0, 0, 0},
  881.     { 0, 2, 7, 7, 9,10,11,12,12, 0, 0, 0, 0, 0, 0, 0, 0},
  882.     { 0, 0, 3, 7, 7, 9,10,11,12, 0, 0, 0, 0, 0, 0, 0, 0},
  883.     { 0, 0, 0, 5, 6, 7, 7,10,11, 0, 0, 0, 0, 0, 0, 0, 0}},
  884.     //YUV444
  885.    {{ 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
  886.     { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
  887.     { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
  888.     { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}}
  889.   };
  891.   static const int codtab[3][4][17] =
  892.   {
  893.     //YUV420
  894.    {{ 1, 7, 4, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  895.     { 0, 1, 6, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  896.     { 0, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  897.     { 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
  898.     //YUV422
  899.    {{ 1,15,14, 7, 6, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0},
  900.     { 0, 1,13,12, 5, 6, 6, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0},
  901.     { 0, 0, 1,11,10, 4, 5, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0},
  902.     { 0, 0, 0, 1, 1, 9, 8, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0}},
  903.     //YUV444
  904.    {{ 1, 5, 7, 7, 7, 7,15,11, 8,15,11,15,11,15,11, 7, 4},
  905.     { 0, 1, 4, 6, 6, 6, 6,14,10,14,10,14,10, 1,14,10, 6},
  906.     { 0, 0, 1, 5, 5, 5, 5, 5,13, 9,13, 9,13, 9,13, 9, 5},
  907.     { 0, 0, 0, 3, 3, 4, 4, 4, 4, 4,12,12, 8,12, 8,12, 8}}
  909.   };
  910.   int yuv = img->yuv_format - 1;
  912.   // se->value1 : numcoeff
  913.   // se->value2 : numtrailingones
  914.   se->len = lentab[yuv][se->value2][se->value1];
  915.   se->inf = codtab[yuv][se->value2][se->value1];
  917.   if (se->len == 0)
  918.   {
  919.     printf("ERROR: (numcoeff,trailingones) not valid: (%d, %d)n",
  920.       se->value1, se->value2);
  921.     exit(-1);
  922.   }
  924.   symbol2vlc(se);
  926.   writeUVLC2buffer(se, dp->bitstream);
  928.   if(se->type != SE_HEADER)
  929.     dp->bitstream->write_flag = 1;
  931. #if TRACE
  932.   if(dp->bitstream->trace_enabled)
  933.     trace2out (se);
  934. #endif
  936.   return (se->len);
  937. }
  940. /*!
  941.  ************************************************************************
  942.  * brief
  943.  *    write VLC for TotalZeros
  944.  ************************************************************************
  945.  */
  946. int writeSyntaxElement_TotalZeros(SyntaxElement *se, DataPartition *dp)
  947. {
  948.   static const int lentab[TOTRUN_NUM][16] =
  949.   {
  950.     { 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
  951.     { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
  952.     { 4,3,3,3,4,4,3,3,4,5,5,6,5,6},
  953.     { 5,3,4,4,3,3,3,4,3,4,5,5,5},
  954.     { 4,4,4,3,3,3,3,3,4,5,4,5},
  955.     { 6,5,3,3,3,3,3,3,4,3,6},
  956.     { 6,5,3,3,3,2,3,4,3,6},
  957.     { 6,4,5,3,2,2,3,3,6},
  958.     { 6,6,4,2,2,3,2,5},
  959.     { 5,5,3,2,2,2,4},
  960.     { 4,4,3,3,1,3},
  961.     { 4,4,2,1,3},
  962.     { 3,3,1,2},
  963.     { 2,2,1},
  964.     { 1,1},
  965.   };
  967.   static const int codtab[TOTRUN_NUM][16] =
  968.   {
  969.     {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
  970.     {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
  971.     {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
  972.     {3,7,5,4,6,5,4,3,3,2,2,1,0},
  973.     {5,4,3,7,6,5,4,3,2,1,1,0},
  974.     {1,1,7,6,5,4,3,2,1,1,0},
  975.     {1,1,5,4,3,3,2,1,1,0},
  976.     {1,1,1,3,3,2,2,1,0},
  977.     {1,0,1,3,2,1,1,1,},
  978.     {1,0,1,3,2,1,1,},
  979.     {0,1,1,2,1,3},
  980.     {0,1,1,1,1},
  981.     {0,1,1,1},
  982.     {0,1,1},
  983.     {0,1},
  984.   };
  985.   int vlcnum = se->len;
  987.   // se->value1 : TotalZeros
  988.   se->len = lentab[vlcnum][se->value1];
  989.   se->inf = codtab[vlcnum][se->value1];
  991.   if (se->len == 0)
  992.   {
  993.     printf("ERROR: (TotalZeros) not valid: (%d)n",se->value1);
  994.     exit(-1);
  995.   }
  997.   symbol2vlc(se);
  999.   writeUVLC2buffer(se, dp->bitstream);
  1001.   if(se->type != SE_HEADER)
  1002.     dp->bitstream->write_flag = 1;
  1004. #if TRACE
  1005.   if(dp->bitstream->trace_enabled)
  1006.     trace2out (se);
  1007. #endif
  1009.   return (se->len);
  1010. }
  1013. /*!
  1014.  ************************************************************************
  1015.  * brief
  1016.  *    write VLC for TotalZeros for Chroma DC
  1017.  ************************************************************************
  1018.  */
  1019. int writeSyntaxElement_TotalZerosChromaDC(SyntaxElement *se, DataPartition *dp)
  1020. {
  1021.   static const int lentab[3][TOTRUN_NUM][16] =
  1022.   {
  1023.     //YUV420
  1024.    {{ 1,2,3,3},
  1025.     { 1,2,2},
  1026.     { 1,1}},
  1027.     //YUV422
  1028.    {{ 1,3,3,4,4,4,5,5},
  1029.     { 3,2,3,3,3,3,3},
  1030.     { 3,3,2,2,3,3},
  1031.     { 3,2,2,2,3},
  1032.     { 2,2,2,2},
  1033.     { 2,2,1},
  1034.     { 1,1}},
  1035.     //YUV444
  1036.    {{ 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
  1037.     { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
  1038.     { 4,3,3,3,4,4,3,3,4,5,5,6,5,6},
  1039.     { 5,3,4,4,3,3,3,4,3,4,5,5,5},
  1040.     { 4,4,4,3,3,3,3,3,4,5,4,5},
  1041.     { 6,5,3,3,3,3,3,3,4,3,6},
  1042.     { 6,5,3,3,3,2,3,4,3,6},
  1043.     { 6,4,5,3,2,2,3,3,6},
  1044.     { 6,6,4,2,2,3,2,5},
  1045.     { 5,5,3,2,2,2,4},
  1046.     { 4,4,3,3,1,3},
  1047.     { 4,4,2,1,3},
  1048.     { 3,3,1,2},
  1049.     { 2,2,1},
  1050.     { 1,1}}
  1051.   };
  1053.   static const int codtab[3][TOTRUN_NUM][16] =
  1054.   {
  1055.     //YUV420
  1056.    {{ 1,1,1,0},
  1057.     { 1,1,0},
  1058.     { 1,0}},
  1059.     //YUV422
  1060.    {{ 1,2,3,2,3,1,1,0},
  1061.     { 0,1,1,4,5,6,7},
  1062.     { 0,1,1,2,6,7},
  1063.     { 6,0,1,2,7},
  1064.     { 0,1,2,3},
  1065.     { 0,1,1},
  1066.     { 0,1}},
  1067.     //YUV444
  1068.    {{1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
  1069.     {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
  1070.     {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
  1071.     {3,7,5,4,6,5,4,3,3,2,2,1,0},
  1072.     {5,4,3,7,6,5,4,3,2,1,1,0},
  1073.     {1,1,7,6,5,4,3,2,1,1,0},
  1074.     {1,1,5,4,3,3,2,1,1,0},
  1075.     {1,1,1,3,3,2,2,1,0},
  1076.     {1,0,1,3,2,1,1,1,},
  1077.     {1,0,1,3,2,1,1,},
  1078.     {0,1,1,2,1,3},
  1079.     {0,1,1,1,1},
  1080.     {0,1,1,1},
  1081.     {0,1,1},
  1082.     {0,1}}
  1083.   };
  1084.   int vlcnum = se->len;
  1085.   int yuv = img->yuv_format - 1;  
  1087.   // se->value1 : TotalZeros
  1088.   se->len = lentab[yuv][vlcnum][se->value1];
  1089.   se->inf = codtab[yuv][vlcnum][se->value1];
  1091.   if (se->len == 0)
  1092.   {
  1093.     printf("ERROR: (TotalZeros) not valid: (%d)n",se->value1);
  1094.     exit(-1);
  1095.   }
  1097.   symbol2vlc(se);
  1099.   writeUVLC2buffer(se, dp->bitstream);
  1101.   if(se->type != SE_HEADER)
  1102.     dp->bitstream->write_flag = 1;
  1104. #if TRACE
  1105.   if(dp->bitstream->trace_enabled)
  1106.     trace2out (se);
  1107. #endif
  1109.   return (se->len);
  1110. }
  1113. /*!
  1114.  ************************************************************************
  1115.  * brief
  1116.  *    write VLC for Run Before Next Coefficient, VLC0
  1117.  ************************************************************************
  1118.  */
  1119. int writeSyntaxElement_Run(SyntaxElement *se, DataPartition *dp)
  1120. {
  1121.   static const int lentab[TOTRUN_NUM][16] =
  1122.   {
  1123.     {1,1},
  1124.     {1,2,2},
  1125.     {2,2,2,2},
  1126.     {2,2,2,3,3},
  1127.     {2,2,3,3,3,3},
  1128.     {2,3,3,3,3,3,3},
  1129.     {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
  1130.   };
  1132.   static const int codtab[TOTRUN_NUM][16] =
  1133.   {
  1134.     {1,0},
  1135.     {1,1,0},
  1136.     {3,2,1,0},
  1137.     {3,2,1,1,0},
  1138.     {3,2,3,2,1,0},
  1139.     {3,0,1,3,2,5,4},
  1140.     {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
  1141.   };
  1142.   int vlcnum = se->len;
  1144.   // se->value1 : run
  1145.   se->len = lentab[vlcnum][se->value1];
  1146.   se->inf = codtab[vlcnum][se->value1];
  1148.   if (se->len == 0)
  1149.   {
  1150.     printf("ERROR: (run) not valid: (%d)n",se->value1);
  1151.     exit(-1);
  1152.   }
  1154.   symbol2vlc(se);
  1156.   writeUVLC2buffer(se, dp->bitstream);
  1158.   if(se->type != SE_HEADER)
  1159.     dp->bitstream->write_flag = 1;
  1161. #if TRACE
  1162.   if(dp->bitstream->trace_enabled)
  1163.     trace2out (se);
  1164. #endif
  1166.   return (se->len);
  1167. }
  1170. /*!
  1171.  ************************************************************************
  1172.  * brief
  1173.  *    write VLC for Coeff Level (VLC1)
  1174.  ************************************************************************
  1175.  */
  1176. int writeSyntaxElement_Level_VLC1(SyntaxElement *se, DataPartition *dp, int profile_idc)
  1177. {
  1178.   int level  = se->value1;
  1179.   int sign   = (level < 0 ? 1 : 0);
  1180.   int levabs = iabs(level);
  1182.   if (levabs < 8)
  1183.   {
  1184.     se->len = levabs * 2 + sign - 1;
  1185.     se->inf = 1;
  1186.   }
  1187.   else if (levabs < 16) 
  1188.   {
  1189.     // escape code1
  1190.     se->len = 19;
  1191.     se->inf = 16 | ((levabs << 1) - 16) | sign;
  1192.   }
  1193.   else
  1194.   {
  1195.     int iMask = 4096, numPrefix = 0;
  1196.     int levabsm16 = levabs + 2032;
  1198.     // escape code2
  1199.     if ((levabsm16) >= 4096)
  1200.     {
  1201.       numPrefix++;
  1202.       while ((levabsm16) >= (4096 << numPrefix))
  1203.       {
  1204.         numPrefix++;
  1205.       }
  1206.     }
  1207.    
  1208.     iMask <<= numPrefix;
  1209.     se->inf = iMask | ((levabsm16 << 1) - iMask) | sign;
  1211.     /* Assert to make sure that the code fits in the VLC */
  1212.     /* make sure that we are in High Profile to represent level_prefix > 15 */
  1213.     if (numPrefix > 0 && !IS_FREXT_PROFILE( profile_idc ))
  1214.     {
  1215.       //error( "level_prefix must be <= 15 except in High Profilen",  1000 );
  1216.       se->len = 0x0000FFFF; // This can be some other big number
  1217.       return (se->len);
  1218.     }
  1219.     
  1220.     se->len = 28 + (numPrefix << 1);
  1221.   }
  1224.   symbol2vlc(se);
  1226.   writeUVLC2buffer(se, dp->bitstream);
  1228.   if(se->type != SE_HEADER)
  1229.     dp->bitstream->write_flag = 1;
  1231. #if TRACE
  1232.   if(dp->bitstream->trace_enabled)
  1233.     trace2out (se);
  1234. #endif
  1236.   return (se->len);
  1237. }
  1240. /*!
  1241.  ************************************************************************
  1242.  * brief
  1243.  *    write VLC for Coeff Level
  1244.  ************************************************************************
  1245.  */
  1246. int writeSyntaxElement_Level_VLCN(SyntaxElement *se, int vlc, DataPartition *dp, int profile_idc)
  1247. {  
  1248.   int level  = se->value1;
  1249.   int sign   = (level < 0 ? 1 : 0);
  1250.   int levabs = iabs(level) - 1;  
  1252.   int shift = vlc - 1;        
  1253.   int escape = (15 << shift);
  1255.   if (levabs < escape)
  1256.   {
  1257.     int sufmask   = ~((0xffffffff) << shift);
  1258.     int suffix    = (levabs) & sufmask;
  1260.     se->len = ((levabs) >> shift) + 1 + vlc;
  1261.     se->inf = (2 << shift) | (suffix << 1) | sign;
  1262.   }
  1263.   else
  1264.   {
  1265.     int iMask = 4096;
  1266.     int levabsesc = levabs - escape + 2048;
  1267.     int numPrefix = 0;
  1269.     if ((levabsesc) >= 4096)
  1270.     {
  1271.       numPrefix++;
  1272.       while ((levabsesc) >= (4096 << numPrefix))
  1273.       {
  1274.         numPrefix++;
  1275.       }
  1276.     }
  1278.     iMask <<= numPrefix;
  1279.     se->inf = iMask | ((levabsesc << 1) - iMask) | sign;
  1281.     /* Assert to make sure that the code fits in the VLC */
  1282.     /* make sure that we are in High Profile to represent level_prefix > 15 */
  1283.     if (numPrefix > 0 &&  !IS_FREXT_PROFILE( profile_idc ))
  1284.     {
  1285.       //error( "level_prefix must be <= 15 except in High Profilen",  1000 );
  1286.       se->len = 0x0000FFFF; // This can be some other big number
  1287.       return (se->len);
  1288.     }
  1289.     se->len = 28 + (numPrefix << 1);
  1290.   }
  1292.   symbol2vlc(se);
  1294.   writeUVLC2buffer(se, dp->bitstream);
  1296.   if(se->type != SE_HEADER)
  1297.     dp->bitstream->write_flag = 1;
  1299. #if TRACE
  1300.   if(dp->bitstream->trace_enabled)
  1301.     trace2out (se);
  1302. #endif
  1304.   return (se->len);
  1305. }
  1308. #if TRACE
  1309. int bitcounter = 0;
  1311. /*!
  1312.  ************************************************************************
  1313.  * brief
  1314.  *    Write out a trace string on the trace file
  1315.  ************************************************************************
  1316.  */
  1317. void trace2out(SyntaxElement *sym)
  1318. {
  1319.   static
  1320.   int i, chars;
  1322.   if (p_trace != NULL)
  1323.   {
  1324.     putc('@', p_trace);
  1325.     chars = fprintf(p_trace, "%i", bitcounter);
  1326.     while(chars++ < 6)
  1327.       putc(' ',p_trace);
  1329.     chars += fprintf(p_trace, "%s", sym->tracestring);
  1330.     while(chars++ < 55)
  1331.       putc(' ',p_trace);
  1333.     // align bit pattern
  1334.     if(sym->len<15)
  1335.     {
  1336.       for(i=0 ; i<15-sym->len ; i++)
  1337.         fputc(' ', p_trace);
  1338.     }
  1340.     // print bit pattern
  1341.     bitcounter += sym->len;
  1342.     for(i=1 ; i<=sym->len ; i++)
  1343.     {
  1344.       if((sym->bitpattern >> (sym->len-i)) & 0x1)
  1345.         fputc('1', p_trace);
  1346.       else
  1347.         fputc('0', p_trace);
  1348.     }
  1349.     fprintf(p_trace, " (%3d) n",sym->value1);
  1350.   }
  1351.   fflush (p_trace);
  1352. }
  1354. void trace2out_cabac(SyntaxElement *sym)
  1355. {
  1356.   int chars;
  1358.   if (p_trace != NULL)
  1359.   {
  1360.     putc('@', p_trace);
  1361.     chars = fprintf(p_trace, "%i", bitcounter);
  1362.     while(chars++ < 6)
  1363.       putc(' ',p_trace);
  1365.     chars += fprintf(p_trace, "%s", sym->tracestring);
  1366.     while(chars++ < 70)
  1367.       putc(' ',p_trace);
  1369.     fprintf(p_trace, " (%3d) n",sym->value1);
  1370.   }
  1371.   fflush (p_trace);
  1372.   bitcounter += sym->len;
  1373. }
  1374. #endif
  1377. /*!
  1378.  ************************************************************************
  1379.  * brief
  1380.  *    puts the less than 8 bits in the byte buffer of the Bitstream into
  1381.  *    the streamBuffer.
  1382.  *
  1383.  * param
  1384.  *   currStream: the Bitstream the alignment should be established
  1385.  *
  1386.  ************************************************************************
  1387.  */
  1388. void writeVlcByteAlign(Bitstream* currStream, StatParameters *cur_stats)
  1389. {
  1390.   if (currStream->bits_to_go < 8)
  1391.   { // trailing bits to process
  1392.     currStream->byte_buf = (currStream->byte_buf << currStream->bits_to_go) | (0xff >> (8 - currStream->bits_to_go));
  1393.     currStream->streamBuffer[currStream->byte_pos++] = currStream->byte_buf;
  1394.     cur_stats->bit_use_stuffingBits[img->type] += currStream->bits_to_go;    
  1395.     currStream->bits_to_go = 8;
  1396.   }
  1397. }