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

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

Audio

开发平台：

Visual C++

rdoq_cavlc.c：源码内容
  1. /*!
  2. *************************************************************************************
  3. * file rdoq_cavlc.c
  4. *
  5. * brief
  6. *    Rate Distortion Optimized Quantization based on VCEG-AH21 related to CAVLC
  7. *************************************************************************************
  8. */
  10. #include "contributors.h"
  12. #include <math.h>
  13. #include <float.h>
  15. #include "global.h"
  16. #include "image.h"
  17. #include "fmo.h"
  18. #include "macroblock.h"
  19. #include "mb_access.h"
  20. #include "ratectl.h"
  21. #include "rdoq.h"
  23. extern const int estErr4x4[6][4][4];
  24. extern const int estErr8x8[6][8][8];
  26. extern const byte SNGL_SCAN[16][2]; // need to revisit
  27. extern const byte FIELD_SCAN[16][2]; 
  29. /*!
  30. ************************************************************************
  31. * brief
  32. *    estimate VLC for Coeff Level
  33. ************************************************************************
  34. */
  35. int estSyntaxElement_Level_VLC1(SyntaxElement *se)
  36. {
  37.   int level  = se->value1;
  38.   int sign   = (level < 0 ? 1 : 0);
  39.   int levabs = iabs(level);
  41.   if (levabs < 8)
  42.   {
  43.     se->len = levabs * 2 + sign - 1;
  44.   }
  45.   else if (levabs < 16)
  46.   {
  47.     // escape code1
  48.     se->len = 19;
  49.   }
  50.   else
  51.   {
  52.     // escape code2
  53.     se->len = 28;
  54.   }
  56.   return (se->len);
  57. }
  61. /*!
  62. ************************************************************************
  63. * brief
  64. *    estimate VLC for Coeff Level
  65. ************************************************************************
  66. */
  67. int estSyntaxElement_Level_VLCN(SyntaxElement *se, int vlc)//, DataPartition *this_dataPart)
  68. {
  69.   int level = se->value1;
  70.   int levabs = iabs(level) - 1;  
  72.   int shift = vlc - 1;
  73.   int escape = (15 << shift);
  75.   if (levabs < escape)
  76.   {
  77.     se->len = ((levabs) >> shift) + 1 + vlc;
  78.   }
  79.   else
  80.   {
  81.     se->len = 28;
  82.   }
  84.   return (se->len);
  85. }
  87. int cmp(const void *arg1, const void *arg2)
  88. {
  89.   return (((levelDataStruct *)arg2)->levelDouble - ((levelDataStruct *)arg1)->levelDouble);
  90. }
  92. /*!
  93. ************************************************************************
  94. * brief
  95. *    estimate CAVLC bits
  96. ************************************************************************
  97. */
  98. int est_CAVLC_bits (levelDataStruct *levelData, int level_to_enc[16], int sign_to_enc[16], int nnz, int block_type)
  99. {
  100.   int           no_bits    = 0;
  101.   SyntaxElement se;
  103.   int coeff_ctr, scan_pos = 0;
  104.   int k, level = 1, run = -1, vlcnum;
  105.   int numcoeff = 0, lastcoeff = 0, numtrailingones = 0; 
  106.   int numones = 0, totzeros = 0, zerosleft, numcoef;
  107.   int numcoeff_vlc;
  108.   int level_two_or_higher;
  109.   int max_coeff_num = 0, cdc = (block_type == CHROMA_DC ? 1 : 0);
  110.   int yuv = img->yuv_format - 1;
  111.   static const int incVlc[] = {0, 3, 6, 12, 24, 48, 32768};  // maximum vlc = 6
  113.   int  pLevel[16] = {0};
  114.   int  pRun[16] = {0};
  116.   static const int Token_lentab[3][4][17] = 
  117.   {
  118.     {
  119.       { 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
  120.       { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
  121.       { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
  122.       { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}
  123.     },
  124.     {                                                  
  125.       { 2, 6, 6, 7, 8, 8, 9,11,11,12,12,12,13,13,13,14,14},
  126.       { 0, 2, 5, 6, 6, 7, 8, 9,11,11,12,12,13,13,14,14,14},
  127.       { 0, 0, 3, 6, 6, 7, 8, 9,11,11,12,12,13,13,13,14,14},
  128.       { 0, 0, 0, 4, 4, 5, 6, 6, 7, 9,11,11,12,13,13,13,14}
  129.     },
  130.     {                                                  
  131.       { 4, 6, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,10},
  132.       { 0, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9,10,10,10},
  133.       { 0, 0, 4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,10},
  134.       { 0, 0, 0, 4, 4, 4, 4, 4, 5, 6, 7, 8, 8, 9,10,10,10}
  135.     }
  136.   };
  138.   static const int Totalzeros_lentab[TOTRUN_NUM][16] = 
  139.   {
  140.     { 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},  
  141.     { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},  
  142.     { 4,3,3,3,4,4,3,3,4,5,5,6,5,6},  
  143.     { 5,3,4,4,3,3,3,4,3,4,5,5,5},  
  144.     { 4,4,4,3,3,3,3,3,4,5,4,5},  
  145.     { 6,5,3,3,3,3,3,3,4,3,6},  
  146.     { 6,5,3,3,3,2,3,4,3,6},  
  147.     { 6,4,5,3,2,2,3,3,6},  
  148.     { 6,6,4,2,2,3,2,5},  
  149.     { 5,5,3,2,2,2,4},  
  150.     { 4,4,3,3,1,3},  
  151.     { 4,4,2,1,3},  
  152.     { 3,3,1,2},  
  153.     { 2,2,1},  
  154.     { 1,1},  
  155.   };
  156.   static const int Run_lentab[TOTRUN_NUM][16] = 
  157.   {
  158.     {1,1},
  159.     {1,2,2},
  160.     {2,2,2,2},
  161.     {2,2,2,3,3},
  162.     {2,2,3,3,3,3},
  163.     {2,3,3,3,3,3,3},
  164.     {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
  165.   };
  166.   static const int Token_lentab_cdc[3][4][17] =
  167.   {
  168.     //YUV420
  169.    {{ 2, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  170.     { 0, 1, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  171.     { 0, 0, 3, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  172.     { 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
  173.     //YUV422
  174.    {{ 1, 7, 7, 9, 9,10,11,12,13, 0, 0, 0, 0, 0, 0, 0, 0},
  175.     { 0, 2, 7, 7, 9,10,11,12,12, 0, 0, 0, 0, 0, 0, 0, 0},
  176.     { 0, 0, 3, 7, 7, 9,10,11,12, 0, 0, 0, 0, 0, 0, 0, 0},
  177.     { 0, 0, 0, 5, 6, 7, 7,10,11, 0, 0, 0, 0, 0, 0, 0, 0}},
  178.     //YUV444
  179.    {{ 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
  180.     { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
  181.     { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
  182.     { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}}
  183.   };
  184.   static const int Totalzeros_lentab_cdc[3][TOTRUN_NUM][16] =
  185.   {
  186.     //YUV420
  187.    {{ 1,2,3,3},
  188.     { 1,2,2},
  189.     { 1,1}},
  190.     //YUV422
  191.    {{ 1,3,3,4,4,4,5,5},
  192.     { 3,2,3,3,3,3,3},
  193.     { 3,3,2,2,3,3},
  194.     { 3,2,2,2,3},
  195.     { 2,2,2,2},
  196.     { 2,2,1},
  197.     { 1,1}},
  198.     //YUV444
  199.    {{ 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
  200.     { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
  201.     { 4,3,3,3,4,4,3,3,4,5,5,6,5,6},
  202.     { 5,3,4,4,3,3,3,4,3,4,5,5,5},
  203.     { 4,4,4,3,3,3,3,3,4,5,4,5},
  204.     { 6,5,3,3,3,3,3,3,4,3,6},
  205.     { 6,5,3,3,3,2,3,4,3,6},
  206.     { 6,4,5,3,2,2,3,3,6},
  207.     { 6,6,4,2,2,3,2,5},
  208.     { 5,5,3,2,2,2,4},
  209.     { 4,4,3,3,1,3},
  210.     { 4,4,2,1,3},
  211.     { 3,3,1,2},
  212.     { 2,2,1},
  213.     { 1,1}}
  214.   };
  217.   max_coeff_num = ( (block_type == CHROMA_DC) ? img->num_cdc_coeff : 
  218.   ( (block_type == LUMA_INTRA16x16AC || block_type == CB_INTRA16x16AC || block_type == CR_INTRA16x16AC || block_type == CHROMA_AC) ? 15 : 16) );
  220.   //convert zigzag scan to (run, level) pairs
  221.   for (coeff_ctr = 0; coeff_ctr < max_coeff_num; coeff_ctr++)
  222.   {
  223.     run++;
  224.     level = level_to_enc[coeff_ctr];
  225.     if (level != 0)
  226.     {
  227.       pLevel[scan_pos] = isignab(level, sign_to_enc[coeff_ctr]);
  228.       pRun  [scan_pos] = run;
  229.       ++scan_pos;
  230.       run = -1;                     // reset zero level counter
  231.     }
  232.   }
  234.   level = 1;
  235.   for(k = 0; (k < max_coeff_num) && level != 0; k++)    
  236.   {
  237.     level = pLevel[k]; // level
  238.     run   = pRun[k];   // run
  240.     if (level)
  241.     {
  242.       totzeros += run; // lets add run always (even if zero) to avoid conditional
  243.       if (iabs(level) == 1)
  244.       {
  245.         numones ++;
  246.         numtrailingones ++;
  247.         numtrailingones = imin(numtrailingones, 3); // clip to 3
  248.       }
  249.       else
  250.       {
  251.         numtrailingones = 0;
  252.       }
  253.       numcoeff ++;
  254.       lastcoeff = k;
  255.     }
  256.   }
  258.   if (!cdc)
  259.   {
  260.     if (nnz < 2)
  261.     {
  262.       numcoeff_vlc = 0;
  263.     }
  264.     else if (nnz < 4)
  265.     {
  266.       numcoeff_vlc = 1;
  267.     }
  268.     else if (nnz < 8)
  269.     {
  270.       numcoeff_vlc = 2;
  271.     }
  272.     else 
  273.     {
  274.       numcoeff_vlc = 3;
  275.     }
  276.   }
  277.   else
  278.   {
  279.     // chroma DC (has its own VLC)
  280.     // numcoeff_vlc not relevant
  281.     numcoeff_vlc = 0;
  282.   }
  284.   se.value1 = numcoeff;
  285.   se.value2 = numtrailingones;
  286.   se.len    = numcoeff_vlc; /* use len to pass vlcnum */
  288.   if (!cdc)
  289.   {
  290.     if (se.len == 3)
  291.       no_bits += 6;  // 4 + 2 bit FLC
  292.     else
  293.       no_bits += Token_lentab[se.len][se.value2][se.value1];
  294.   }
  295.   else
  296.     no_bits += Token_lentab_cdc[yuv][se.value2][se.value1];  
  298.   if (!numcoeff)
  299.     return no_bits;
  300.   else
  301.   {
  302.     if (numtrailingones)
  303.       no_bits += numtrailingones;
  305.     // encode levels
  306.     level_two_or_higher = (numcoeff > 3 && numtrailingones == 3) ? 0 : 1;
  308.     vlcnum = (numcoeff > 10 && numtrailingones < 3) ? 1 : 0;
  310.     for (k = lastcoeff - numtrailingones; k >= 0; k--)
  311.     {
  312.       level = pLevel[k]; // level
  314.       se.value1 = level;
  316.       if (level_two_or_higher)
  317.       {
  318.         level_two_or_higher = 0;
  319.         if (se.value1 > 0)
  320.           se.value1 --;
  321.         else
  322.           se.value1 ++;
  323.       }
  325.       //    encode level
  326.       if (vlcnum == 0)
  327.         estSyntaxElement_Level_VLC1(&se);
  328.       else
  329.         estSyntaxElement_Level_VLCN(&se, vlcnum);
  331.       // update VLC table
  332.       if (iabs(level) > incVlc[vlcnum])
  333.         vlcnum++;
  335.       if ((k == lastcoeff - numtrailingones) && iabs(level) > 3)
  336.         vlcnum = 2;
  338.       no_bits  += se.len;
  339.     }
  341.     // encode total zeroes
  342.     if (numcoeff < max_coeff_num)
  343.     {
  344.       se.value1 = totzeros;
  346.       vlcnum = numcoeff-1;
  348.       se.len = vlcnum;
  350.       if (!cdc)
  351.         no_bits += Totalzeros_lentab[se.len][se.value1];
  352.       else
  353.         no_bits += Totalzeros_lentab_cdc[yuv][se.len][se.value1];
  354.     }
  356.     // encode run before each coefficient
  357.     zerosleft = totzeros;
  358.     numcoef = numcoeff;
  359.     for (k = lastcoeff; k >= 0; k--)
  360.     {
  361.       run = pRun[k]; // run
  363.       se.value1 = run;
  365.       // for last coeff, run is remaining totzeros
  366.       // when zerosleft is zero, remaining coeffs have 0 run
  367.       if ((!zerosleft) || (numcoeff <= 1 ))
  368.         break;
  370.       if (numcoef > 1 && zerosleft) 
  371.       {
  372.         vlcnum = imin(zerosleft - 1, RUNBEFORE_NUM_M1);
  373.         se.len = vlcnum;
  374.         no_bits += Run_lentab[se.len][se.value1];
  375.         zerosleft -= run;
  376.         numcoef --;
  377.       }
  378.     }
  379.   }
  381.   return no_bits;
  382. }
  385. /*!
  386. ****************************************************************************
  387. * brief
  388. *    estimate run and level for CAVLC 
  389. ****************************************************************************
  390. */
  391. void est_RunLevel_CAVLC(levelDataStruct *levelData, int *levelTrellis, int block_type, 
  392.                         int b8, int b4, int coeff_num, double lambda)
  393. {
  394.   int k, lastnonzero = -1, coeff_ctr;
  395.   int level_to_enc[16] = {0}, sign_to_enc[16] = {0};
  396.   int cstat, bestcstat = 0; 
  397.   int nz_coeff=0;
  398.   double lagr, lagrAcc = 0, minlagr = 0;
  400.   int subblock_x = ((b8&0x1)==0)?(((b4&0x1)==0)?0:1):(((b4&0x1)==0)?2:3); 
  401.   // horiz. position for coeff_count context  
  402.   int subblock_y = (b8<2)?((b4<2)?0:1):((b4<2)?2:3); 
  403.   // vert.  position for coeff_count context      
  404.   int nnz; 
  405.   levelDataStruct *dataLevel = &levelData[0];
  407.   if (block_type != CHROMA_AC)
  408.     nnz = predict_nnz(&img->mb_data[img->current_mb_nr], LUMA, subblock_x,subblock_y); 
  409.   else
  410.     nnz = predict_nnz_chroma(&img->mb_data[img->current_mb_nr], img->subblock_x, img->subblock_y+4);
  412.   for (coeff_ctr=0;coeff_ctr < coeff_num;coeff_ctr++)
  413.   {  
  414.     levelTrellis[coeff_ctr] = 0;
  416.     for(k=0; k < dataLevel->noLevels; k++)
  417.     {
  418.       dataLevel->errLevel[k] /= 32768;
  419.     }
  421.     lagrAcc += dataLevel->errLevel[dataLevel->noLevels - 1];
  423.     level_to_enc[coeff_ctr] = dataLevel->pre_level;
  424.     sign_to_enc[coeff_ctr] = dataLevel->sign;
  426.     if(dataLevel->noLevels > 1)
  427.     {
  428.       dataLevel->coeff_ctr = coeff_ctr;
  429.       lastnonzero = coeff_ctr;
  430.     }
  431.     else
  432.       dataLevel->coeff_ctr = -1;
  433.     dataLevel++;
  434.   }
  436.   if(lastnonzero != -1)
  437.   {
  438.     //sort the coefficients based on their absolute value
  439.     qsort(levelData, lastnonzero + 1, sizeof(levelDataStruct), cmp);
  441.     dataLevel = &levelData[lastnonzero];
  443.     for(coeff_ctr = lastnonzero; coeff_ctr >= 0; coeff_ctr--) // go over all coeff
  444.     {
  445.       if(dataLevel->noLevels == 1)
  446.       {
  447.         dataLevel--;
  448.         continue;
  449.       }
  451.       lagrAcc -= dataLevel->errLevel[dataLevel->noLevels-1];
  452.       for(cstat=0; cstat<dataLevel->noLevels; cstat++) // go over all states of cur coeff k
  453.       {
  454.         level_to_enc[dataLevel->coeff_ctr] = dataLevel->level[cstat];
  455.         lagr = lagrAcc + dataLevel->errLevel[cstat];
  457.         lagr += lambda * est_CAVLC_bits(levelData, level_to_enc, sign_to_enc, nnz, block_type);
  459.         if(cstat==0 || lagr<minlagr)
  460.         {
  461.           minlagr = lagr;
  462.           bestcstat = cstat;
  463.         }
  464.       }
  465.       lagrAcc += dataLevel->errLevel[bestcstat];
  466.       level_to_enc[dataLevel->coeff_ctr] = dataLevel->level[bestcstat];
  467.       dataLevel--;
  468.     }
  470.     for(coeff_ctr = 0; coeff_ctr <= lastnonzero; coeff_ctr++)
  471.     {
  472.       levelTrellis[coeff_ctr] = level_to_enc[coeff_ctr];
  473.       if (level_to_enc[coeff_ctr] != 0)
  474.         nz_coeff++;
  475.     }
  476.   }
  478.   img->nz_coeff [img->current_mb_nr ][subblock_x][subblock_y] = nz_coeff;
  479. }
  481. /*!
  482. ****************************************************************************
  483. * brief
  484. *    Initialize levelData 
  485. ****************************************************************************
  486. */
  487. void init_trellis_data_4x4_CAVLC(int (*tblock)[16], int block_x, int qp_per, int qp_rem, int **levelscale, int **leveloffset, 
  488.                                  const byte *p_scan, Macroblock *currMB, levelDataStruct *dataLevel, int type)
  489. {
  490.   int i, j, coeff_ctr; 
  491.   static int *m7;
  492.   int end_coeff_ctr = ( ( type == LUMA_4x4 ) ? 16 : 15 );
  493.   int q_bits = Q_BITS + qp_per; 
  494.   int q_offset = ( 1 << (q_bits - 1) );
  495.   int level, lowerInt, k;
  496.   double err, estErr;
  499.   for (coeff_ctr = 0; coeff_ctr < end_coeff_ctr; coeff_ctr++)
  500.   {
  501.     i = *p_scan++;  // horizontal position
  502.     j = *p_scan++;  // vertical position
  504.     m7 = &tblock[j][block_x + i];
  506.     if (*m7 == 0)
  507.     {
  508.       dataLevel->levelDouble = 0;
  509.       dataLevel->level[0] = 0;
  510.       dataLevel->noLevels = 1;
  511.       err = 0.0;
  512.       dataLevel->errLevel[0] = 0.0;
  513.       dataLevel->pre_level = 0;
  514.       dataLevel->sign = 0;
  515.     }
  516.     else
  517.     {
  518.       estErr = ((double) estErr4x4[qp_rem][j][i]) / norm_factor_4x4;
  520.       dataLevel->levelDouble = iabs(*m7 * levelscale[j][i]);
  521.       level = (dataLevel->levelDouble >> q_bits);
  523.       lowerInt = (((int)dataLevel->levelDouble - (level << q_bits)) < q_offset )? 1 : 0;
  524.       
  525.       dataLevel->level[0] = 0;
  526.       if (level == 0 && lowerInt == 1)
  527.       {
  528.         dataLevel->noLevels = 1;
  529.       }
  530.       else if (level == 0 && lowerInt == 0)
  531.       {
  532.         dataLevel->level[1] = 1;
  533.         dataLevel->noLevels = 2;
  534.       }
  535.       else if (level > 0 && lowerInt == 1)
  536.       {
  537.         dataLevel->level[1] = level;
  538.         dataLevel->noLevels = 2;
  539.       }
  540.       else
  541.       {
  542.         dataLevel->level[1] = level;
  543.         dataLevel->level[2] = level + 1;
  544.         dataLevel->noLevels = 3;
  545.       }
  547.       for (k = 0; k < dataLevel->noLevels; k++)
  548.       {
  549.         err = (double)(dataLevel->level[k] << q_bits) - (double)dataLevel->levelDouble;
  550.         dataLevel->errLevel[k] = (err * err * estErr); 
  551.       }
  553.       if(dataLevel->noLevels == 1)
  554.         dataLevel->pre_level = 0;
  555.       else
  556.         dataLevel->pre_level = (iabs (*m7) * levelscale[j][i] + leveloffset[j][i]) >> q_bits;
  557.       dataLevel->sign = isign(*m7);
  558.     }
  559.     dataLevel++;
  560.   }
  561. }
  563. /*!
  564. ****************************************************************************
  565. * brief
  566. *    Initialize levelData for Luma DC
  567. ****************************************************************************
  568. */
  569. void init_trellis_data_DC_CAVLC(int (*tblock)[4], int qp_per, int qp_rem, 
  570.                          int levelscale, int leveloffset, const byte *p_scan, Macroblock *currMB,  
  571.                          levelDataStruct *dataLevel, int type)
  572. {
  573.   int i, j, coeff_ctr, end_coeff_ctr = 16;
  574.   int q_bits   = Q_BITS + qp_per + 1; 
  575.   int q_offset = ( 1 << (q_bits - 1) );
  576.   int level, lowerInt, k;
  577.   int *m7;
  578.   double err, estErr = (double) estErr4x4[qp_rem][0][0] / norm_factor_4x4; // note that we could also use int64
  580.   for (coeff_ctr = 0; coeff_ctr < end_coeff_ctr; coeff_ctr++)
  581.   {
  582.     i = *p_scan++;  // horizontal position
  583.     j = *p_scan++;  // vertical position
  584.     m7 = &tblock[j][i];
  586.     if (*m7 == 0)
  587.     {
  588.       dataLevel->levelDouble = 0;
  589.       dataLevel->level[0] = 0;
  590.       dataLevel->noLevels = 1;
  591.       err = 0.0;
  592.       dataLevel->errLevel[0] = 0.0;
  593.       dataLevel->pre_level = 0;
  594.       dataLevel->sign = 0;
  595.     }
  596.     else
  597.     {
  598.       dataLevel->levelDouble = iabs(*m7 * levelscale);
  599.       level = (dataLevel->levelDouble >> q_bits);
  601.       lowerInt=( ((int)dataLevel->levelDouble - (level<<q_bits)) < q_offset )? 1 : 0;
  603.       dataLevel->level[0] = 0;    
  604.       if (level == 0 && lowerInt == 1)
  605.       {
  606.         dataLevel->noLevels = 1;
  607.       }
  608.       else if (level == 0 && lowerInt == 0)
  609.       {
  610.         dataLevel->level[1] = 1;
  611.         dataLevel->noLevels = 2;
  612.       }
  613.       else if (level > 0 && lowerInt == 1)
  614.       {
  615.         dataLevel->level[1] = level;
  616.         dataLevel->noLevels = 2;
  617.       }
  618.       else
  619.       {
  620.         dataLevel->level[1] = level;
  621.         dataLevel->level[2] = level + 1;
  622.         dataLevel->noLevels = 3;
  623.       }
  625.       for (k = 0; k < dataLevel->noLevels; k++)
  626.       {
  627.         err = (double)(dataLevel->level[k] << q_bits) - (double)dataLevel->levelDouble;
  628.         dataLevel->errLevel[k] = (err * err * estErr); 
  629.       }
  631.       if(dataLevel->noLevels == 1)
  632.         dataLevel->pre_level = 0;
  633.       else
  634.         dataLevel->pre_level = (iabs (*m7) * levelscale + leveloffset) >> q_bits;
  635.       dataLevel->sign = isign(*m7);
  636.     }
  637.     dataLevel++;
  638.   }
  639. }
  641. /*!
  642. ****************************************************************************
  643. * brief
  644. *    Initialize levelData 
  645. ****************************************************************************
  646. */
  647. void init_trellis_data_8x8_CAVLC(int (*tblock)[16], int block_x, int qp_per, int qp_rem, int **levelscale, int **leveloffset, 
  648.                                  const byte *p_scan, Macroblock *currMB, levelDataStruct levelData[4][16])
  649. {
  650.   int i, j, block, coeff_ctr;
  651.   static int *m7;
  652.   int q_bits   = Q_BITS_8 + qp_per;
  653.   int q_offset = ( 1 << (q_bits - 1) );
  654.   double err, estErr;
  655.   int level, lowerInt, k;
  656.   
  657.   levelDataStruct *dataLevel = &levelData[0][0];  
  659.   for (coeff_ctr = 0; coeff_ctr < 16; coeff_ctr++)
  660.   {
  661.     for (block = 0; block < 4; block++)
  662.     {
  663.       i = *p_scan++;  // horizontal position
  664.       j = *p_scan++;  // vertical position
  666.       m7 = &tblock[j][block_x + i];
  668.       dataLevel = &levelData[block][coeff_ctr];
  669.       if (*m7 == 0)
  670.       {
  671.         dataLevel->levelDouble = 0;
  672.         dataLevel->level[0] = 0;
  673.         dataLevel->noLevels = 1;
  674.         err = 0.0;
  675.         dataLevel->errLevel[0] = 0.0;
  676.         dataLevel->pre_level = 0;
  677.         dataLevel->sign = 0;
  678.       }
  679.       else
  680.       {
  681.         estErr = (double) estErr8x8[qp_rem][j][i] / norm_factor_8x8;
  683.         dataLevel->levelDouble = iabs(*m7 * levelscale[j][i]);
  684.         level = (dataLevel->levelDouble >> q_bits);
  686.         lowerInt = (((int)dataLevel->levelDouble - (level << q_bits)) < q_offset ) ? 1 : 0;
  688.         dataLevel->level[0] = 0;
  689.         if (level == 0 && lowerInt == 1)
  690.         {
  691.           dataLevel->noLevels = 1;
  692.         }
  693.         else if (level == 0 && lowerInt == 0)
  694.         {
  695.           dataLevel->level[1] = 1;
  696.           dataLevel->noLevels = 2;
  697.         }
  698.         else if (level > 0 && lowerInt == 1)
  699.         {
  700.           if (level > 1)
  701.           {
  702.             dataLevel->level[1] = level - 1;
  703.             dataLevel->level[2] = level;
  704.             dataLevel->noLevels = 3;
  705.           }
  706.           else
  707.           {
  708.             dataLevel->level[1] = level;
  709.             dataLevel->noLevels = 2;
  710.           }
  711.         }
  712.         else
  713.         {
  714.           dataLevel->level[1] = level;
  715.           dataLevel->level[2] = level + 1;
  716.           dataLevel->noLevels = 3;
  717.         }
  719.         for (k = 0; k < dataLevel->noLevels; k++)
  720.         {
  721.           err = (double)(dataLevel->level[k] << q_bits) - (double)dataLevel->levelDouble;
  722.           dataLevel->errLevel[k] = err * err * estErr; 
  723.         }
  725.         if(dataLevel->noLevels == 1)
  726.           dataLevel->pre_level = 0;
  727.         else
  728.           dataLevel->pre_level = (iabs (*m7) * levelscale[j][i] + leveloffset[j][i]) >> q_bits;
  729.         dataLevel->sign = isign(*m7);
  730.       }
  731.     }
  732.   }
  733. }