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

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

Audio

开发平台：

Visual C++

rdoq_cabac.c：源码内容
  1. /*!
  2.  *************************************************************************************
  3.  * file rdoq_cabac.c
  4.  *
  5.  * brief
  6.  *    Rate Distortion Optimized Quantization based on VCEG-AH21 related to CABAC
  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. const int entropyBits[128]= 
  24. {
  25.      895,    943,    994,   1048,   1105,   1165,   1228,   1294, 
  26.     1364,   1439,   1517,   1599,   1686,   1778,   1875,   1978, 
  27.     2086,   2200,   2321,   2448,   2583,   2725,   2876,   3034, 
  28.     3202,   3380,   3568,   3767,   3977,   4199,   4435,   4684, 
  29.     4948,   5228,   5525,   5840,   6173,   6527,   6903,   7303, 
  30.     7727,   8178,   8658,   9169,   9714,  10294,  10914,  11575, 
  31.    12282,  13038,  13849,  14717,  15650,  16653,  17734,  18899, 
  32.    20159,  21523,  23005,  24617,  26378,  28306,  30426,  32768, 
  33.    32768,  35232,  37696,  40159,  42623,  45087,  47551,  50015, 
  34.    52479,  54942,  57406,  59870,  62334,  64798,  67262,  69725, 
  35.    72189,  74653,  77117,  79581,  82044,  84508,  86972,  89436, 
  36.    91900,  94363,  96827,  99291, 101755, 104219, 106683, 109146, 
  37.   111610, 114074, 116538, 119002, 121465, 123929, 126393, 128857, 
  38.   131321, 133785, 136248, 138712, 141176, 143640, 146104, 148568, 
  39.   151031, 153495, 155959, 158423, 160887, 163351, 165814, 168278, 
  40.   170742, 173207, 175669, 178134, 180598, 183061, 185525, 187989
  41. };
  43. extern const int maxpos       [];
  44. extern const int type2ctx_bcbp[];
  45. extern const int type2ctx_map [];
  46. extern const int type2ctx_last[]; 
  47. extern const int type2ctx_one []; // 7
  48. extern const int type2ctx_abs []; // 7
  49. extern const int max_c2       []; // 9
  51. extern const int  pos2ctx_map8x8 [];
  52. extern const int  pos2ctx_map8x4 [];
  53. extern const int  pos2ctx_map4x4 [];
  54. extern const int  pos2ctx_map2x4c[];
  55. extern const int  pos2ctx_map4x4c[];
  56. extern const int* pos2ctx_map    [];
  58. extern const int  pos2ctx_last8x8 [];
  59. extern const int  pos2ctx_last8x4 [];
  60. extern const int  pos2ctx_last4x4 [];
  61. extern const int  pos2ctx_last2x4c[];
  62. extern const int  pos2ctx_last4x4c[];
  63. extern const int* pos2ctx_last    [];
  65. extern const int estErr4x4[6][4][4];
  66. extern const int estErr8x8[6][8][8];
  69. int precalcUnaryLevelTab[128][MAX_PREC_COEFF];
  70. estBitsCabacStruct estBitsCabac[NUM_BLOCK_TYPES];
  72. void precalculate_unary_exp_golomb_level()
  73. {
  74.   int state, ctx_state0, ctx_state1, estBits0, estBits1, symbol;
  76.   for (state=0; state<=63; state++)
  77.   {
  78.     // symbol 0 is MPS
  79.     ctx_state0=64+state;
  80.     estBits0=entropyBits[127-ctx_state0];
  81.     ctx_state1=63-state;
  82.     estBits1=entropyBits[127-ctx_state1];
  84.     for (symbol=0; symbol<MAX_PREC_COEFF; symbol++)
  85.     {
  86.       precalcUnaryLevelTab[ctx_state0][symbol]=est_unary_exp_golomb_level_bits(symbol, estBits0, estBits1);
  88.       // symbol 0 is LPS
  89.       precalcUnaryLevelTab[ctx_state1][symbol]=est_unary_exp_golomb_level_bits(symbol, estBits1, estBits0);
  90.     }
  91.   }
  92. }
  94. int est_unary_exp_golomb_level_bits(unsigned int symbol, int bits0, int bits1)
  95. {
  96.   unsigned int l,k;
  97.   unsigned int exp_start = 13; // 15-2 : 0,1 level decision always sent
  98.   int estBits;
  100.   if (symbol==0)
  101.   {
  102.     return (bits0);
  103.   }
  104.   else
  105.   {
  106.     estBits=bits1;
  107.     l=symbol;
  108.     k=1;
  109.     while (((--l)>0) && (++k <= exp_start))
  110.     {
  111.       estBits += bits1;
  112.     }
  113.     if (symbol < exp_start)
  114.     {
  115.       estBits += bits0;
  116.     }
  117.     else 
  118.     {
  119.       estBits += est_exp_golomb_encode_eq_prob(symbol-exp_start);
  120.     }
  121.   }
  122.   return(estBits);
  123. }
  125. /*!
  126. ****************************************************************************
  127. * brief
  128. *    estimate exp golomb bit cost 
  129. ****************************************************************************
  130. */
  131. int est_exp_golomb_encode_eq_prob(unsigned int symbol)
  132. {
  133.   int k = 0, estBits = 0;
  135.   while(1)
  136.   {
  137.     if (symbol >= (unsigned int)(1<<k))   
  138.     {
  139.       estBits++;
  140.       symbol -= (1<<k);
  141.       k++;
  142.     }
  143.     else                  
  144.     {
  145.       estBits += (k + 1);  
  146.       break;
  147.     }
  148.   }
  149.   return(estBits);
  150. }
  152. /*!
  153. ****************************************************************************
  154. * brief
  155. *   estimate bit cost for CBP, significant map and significant coefficients
  156. ****************************************************************************
  157. */
  158. void estRunLevel_CABAC (Macroblock *currMB, int context) // marta - writes CABAC run/level 
  159. {
  160.   DataPartition*  dataPart = &(img->currentSlice->partArr[0]); // assumed that no DP is used (table assignSE2partition_NoDP)
  161.   EncodingEnvironmentPtr eep_dp = &(dataPart->ee_cabac); 
  163.   est_CBP_block_bit  (currMB, eep_dp, context);      
  164.   //===== encode significance map =====
  165.   est_significance_map         (currMB, eep_dp, context);      
  166.   //===== encode significant coefficients =====
  167.   est_significant_coefficients (currMB, eep_dp, context);
  168. }
  170. /*!
  171. ****************************************************************************
  172. * brief
  173. *    estimate bit cost for each CBP bit
  174. ****************************************************************************
  175. */
  176. void est_CBP_block_bit (Macroblock* currMB, EncodingEnvironmentPtr eep_dp, int type)
  177. {
  178.   estBitsCabacStruct *cabacEstBits = &estBitsCabac[type];
  179.   int ctx;
  181.   for (ctx=0; ctx<=3; ctx++)
  182.   {
  183.     cabacEstBits->blockCbpBits[ctx][0]=biari_no_bits(eep_dp, 0, img->currentSlice->tex_ctx->bcbp_contexts[type2ctx_bcbp[type]]+ctx);
  185.     cabacEstBits->blockCbpBits[ctx][1]=biari_no_bits(eep_dp, 1, img->currentSlice->tex_ctx->bcbp_contexts[type2ctx_bcbp[type]]+ctx);
  186.   }
  187. }
  189. /*!
  190. ****************************************************************************
  191. * brief
  192. *    estimate CABAC bit cost for significant coefficient map
  193. ****************************************************************************
  194. */
  195. void est_significance_map(Macroblock* currMB, EncodingEnvironmentPtr eep_dp, int type)
  196. {
  197.   int   k;
  198.   int   k1  = maxpos[type]-1;
  199. #if ENABLE_FIELD_CTX
  200.   int   fld = ( img->structure!=FRAME || currMB->mb_field );
  201. #else
  202.   int   fld = 0;
  203. #endif
  204.   BiContextTypePtr  map_ctx   = img->currentSlice->tex_ctx->map_contexts [fld][type2ctx_map [type]];
  205.   BiContextTypePtr  last_ctx  = img->currentSlice->tex_ctx->last_contexts[fld][type2ctx_last[type]];
  206.   estBitsCabacStruct *cabacEstBits = &estBitsCabac[type];
  209.   for (k = 0; k < k1; k++) // if last coeff is reached, it has to be significant
  210.   {
  211.     cabacEstBits->significantBits[pos2ctx_map[type][k]][0]=biari_no_bits  (eep_dp, 0,  map_ctx+pos2ctx_map     [type][k]);
  213.     cabacEstBits->significantBits[pos2ctx_map[type][k]][1]=biari_no_bits  (eep_dp, 1,  map_ctx+pos2ctx_map     [type][k]);
  215.     cabacEstBits->lastBits[pos2ctx_last[type][k]][0]=biari_no_bits(eep_dp, 0, last_ctx+pos2ctx_last[type][k]);
  217.     cabacEstBits->lastBits[pos2ctx_last[type][k]][1]=biari_no_bits(eep_dp, 1, last_ctx+pos2ctx_last[type][k]);
  218.   }
  219.   // if last coeff is reached, it has to be significant
  220.   cabacEstBits->significantBits[pos2ctx_map[type][k1]][0]=0;
  221.   cabacEstBits->significantBits[pos2ctx_map[type][k1]][1]=0;
  222.   cabacEstBits->lastBits[pos2ctx_last[type][k1]][0]=0;
  223.   cabacEstBits->lastBits[pos2ctx_last[type][k1]][1]=0;
  224. }
  226. /*!
  227. ****************************************************************************
  228. * brief
  229. *    estimate bit cost of significant coefficient
  230. ****************************************************************************
  231. */
  232. void est_significant_coefficients (Macroblock* currMB, EncodingEnvironmentPtr eep_dp,  int type)
  233. {
  234.   int   ctx;
  235.   int maxCtx = imin(4, max_c2[type]);
  236.   estBitsCabacStruct *cabacEstBits = &estBitsCabac[type];
  238.   for (ctx=0; ctx<=4; ctx++){    
  239.     cabacEstBits->greaterOneBits[0][ctx][0]=
  240.       biari_no_bits (eep_dp, 0, img->currentSlice->tex_ctx->one_contexts[type2ctx_one[type]] + ctx);
  242.     cabacEstBits->greaterOneBits[0][ctx][1]=
  243.       biari_no_bits (eep_dp, 1, img->currentSlice->tex_ctx->one_contexts[type2ctx_one[type]] + ctx);
  244.   }
  246.   for (ctx=0; ctx<=maxCtx; ctx++){
  247.     cabacEstBits->greaterOneBits[1][ctx][0]=
  248.       biari_no_bits(eep_dp, 0, img->currentSlice->tex_ctx->abs_contexts[type2ctx_abs[type]] + ctx);
  250.     cabacEstBits->greaterOneState[ctx]=biari_state(eep_dp, 0, img->currentSlice->tex_ctx->abs_contexts[type2ctx_abs[type]] + ctx);
  252.     cabacEstBits->greaterOneBits[1][ctx][1]=
  253.       biari_no_bits(eep_dp, 1, img->currentSlice->tex_ctx->abs_contexts[type2ctx_abs[type]] + ctx);
  254.   }
  255. }
  257. int biari_no_bits(EncodingEnvironmentPtr eep, signed short symbol, BiContextTypePtr bi_ct )
  258. {
  259.   int ctx_state, estBits;
  261.   symbol = (short) (symbol != 0);
  263.   ctx_state = (symbol == bi_ct->MPS) ? 64 + bi_ct->state : 63 - bi_ct->state;
  264.   estBits=entropyBits[127 - ctx_state];
  266.   return(estBits);
  267. }
  269. int biari_state(EncodingEnvironmentPtr eep, signed short symbol, BiContextTypePtr bi_ct )
  270. { 
  271.   int ctx_state;
  273.   symbol = (short) (symbol != 0);
  274.   ctx_state = (symbol == bi_ct->MPS) ? 64 + bi_ct->state : 63 - bi_ct->state;
  276.   return(ctx_state);
  277. }
  279. #define BIT_SET(x,n)  ((int)(((x)&((int64)1<<(n)))>>(n)))
  281. /*!
  282. ****************************************************************************
  283. * brief
  284. *    estimate CABAC CBP bits
  285. ****************************************************************************
  286. */
  287. int est_write_and_store_CBP_block_bit(Macroblock* currMB, int type) 
  288. {
  289.   estBitsCabacStruct *cabacEstBits = &estBitsCabac[type];
  291.   int y_ac        = (type==LUMA_16AC || type==LUMA_8x8 || type==LUMA_8x4 || type==LUMA_4x8 || type==LUMA_4x4
  292.     || type==CB_16AC || type==CB_8x8 || type==CB_8x4 || type==CB_4x8 || type==CB_4x4
  293.     || type==CR_16AC || type==CR_8x8 || type==CR_8x4 || type==CR_4x8 || type==CR_4x4);
  294.   int y_dc        = (type==LUMA_16DC || type==CB_16DC || type==CR_16DC); 
  295.   int u_ac        = (type==CHROMA_AC && !img->is_v_block);
  296.   int v_ac        = (type==CHROMA_AC &&  img->is_v_block);
  297.   int chroma_dc   = (type==CHROMA_DC || type==CHROMA_DC_2x4 || type==CHROMA_DC_4x4);
  298.   int u_dc        = (chroma_dc && !img->is_v_block);
  299.   int v_dc        = (chroma_dc &&  img->is_v_block);
  300.   int j           = ((y_ac || u_ac || v_ac ? img->subblock_y : 0) << 2);
  301.   int i           =  (y_ac || u_ac || v_ac ? img->subblock_x : 0);
  302.   int bit;
  303.   int default_bit =  (IS_INTRA(currMB) ? 1 : 0);
  304.   int upper_bit   = default_bit;
  305.   int left_bit    = default_bit;
  306.   int ctx, estBits = 0;
  308.   int bit_pos_a   = 0;
  309.   int bit_pos_b   = 0;
  311.   PixelPos block_a, block_b;
  313.   if (y_ac || y_dc)
  314.   {
  315.     get4x4Neighbour(currMB, (i << 2) - 1, j   , img->mb_size[IS_LUMA], &block_a);
  316.     get4x4Neighbour(currMB, (i << 2),     j -1, img->mb_size[IS_LUMA], &block_b);
  317.     if (y_ac)
  318.     {
  319.       if (block_a.available)
  320.         bit_pos_a = 4*block_a.y + block_a.x;
  321.       if (block_b.available)
  322.         bit_pos_b = 4*block_b.y + block_b.x;
  323.     }
  324.   }
  325.   else
  326.   {
  327.     get4x4Neighbour(currMB, (i << 2) - 1, j    , img->mb_size[IS_CHROMA], &block_a);
  328.     get4x4Neighbour(currMB, (i << 2),     j - 1, img->mb_size[IS_CHROMA], &block_b);
  329.     if (u_ac||v_ac)
  330.     {
  331.       if (block_a.available)
  332.         bit_pos_a = (block_a.y << 2) + block_a.x;
  333.       if (block_b.available)
  334.         bit_pos_b = (block_b.y << 2) + block_b.x;
  335.     }
  336.   }
  338.   bit = (y_dc ? 0 : y_ac ? 1 : u_dc ? 17 : v_dc ? 18 : u_ac ? 19 : 35);
  340.   if (enc_picture->chroma_format_idc!=YUV444 || IS_INDEPENDENT(params))
  341.   {
  342.     if (type!=LUMA_8x8)
  343.     {
  344.       if (block_b.available)
  345.       {
  346.         if(img->mb_data[block_b.mb_addr].mb_type==IPCM)
  347.           upper_bit = 1;
  348.         else
  349.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[0],bit+bit_pos_b);
  350.       }
  352.       if (block_a.available)
  353.       {
  354.         if(img->mb_data[block_a.mb_addr].mb_type==IPCM)
  355.           left_bit = 1;
  356.         else
  357.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[0],bit+bit_pos_a);
  358.       }
  360.       ctx = 2*upper_bit+left_bit;
  361.       //===== encode symbol =====
  362.       estBits = cabacEstBits->blockCbpBits[ctx][0] - cabacEstBits->blockCbpBits[ctx][1];
  363.     }
  364.   }
  365.   else 
  366.   {
  367.     if (block_b.available)
  368.     {
  369.       if(img->mb_data[block_b.mb_addr].mb_type == IPCM)
  370.         upper_bit=1;
  371.       else
  372.       {
  373.         if(type==LUMA_8x8)
  374.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits_8x8[0], bit + bit_pos_b);
  375.         else if (type==CB_8x8)
  376.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits_8x8[1], bit + bit_pos_b);
  377.         else if (type==CR_8x8)
  378.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits_8x8[2], bit + bit_pos_b);
  379.         else if ((type==CB_4x4)||(type==CB_4x8)||(type==CB_8x4)||(type==CB_16AC)||(type==CB_16DC))
  380.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[1], bit + bit_pos_b);
  381.         else if ((type==CR_4x4)||(type==CR_4x8)||(type==CR_8x4)||(type==CR_16AC)||(type==CR_16DC))
  382.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[2], bit + bit_pos_b);
  383.         else
  384.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[0], bit + bit_pos_b);
  385.       }
  386.     }
  388.     if (block_a.available)
  389.     {
  390.       if(img->mb_data[block_a.mb_addr].mb_type==IPCM)
  391.         left_bit = 1;
  392.       else
  393.       {
  394.         if(type==LUMA_8x8)
  395.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits_8x8[0],bit + bit_pos_a);
  396.         else if (type==CB_8x8)
  397.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits_8x8[1],bit + bit_pos_a);
  398.         else if (type==CR_8x8)
  399.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits_8x8[2],bit + bit_pos_a);
  400.         else if ((type==CB_4x4)||(type==CB_4x8)||(type==CB_8x4)||(type==CB_16AC)||(type==CB_16DC))
  401.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[1],bit + bit_pos_a);
  402.         else if ((type==CR_4x4)||(type==CR_4x8)||(type==CR_8x4)||(type==CR_16AC)||(type==CR_16DC))
  403.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[2],bit + bit_pos_a);
  404.         else
  405.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[0],bit + bit_pos_a);
  406.       }
  407.     }
  409.     ctx = 2*upper_bit+left_bit;
  411.     //===== encode symbol =====
  412.     estBits = cabacEstBits->blockCbpBits[ctx][0] - cabacEstBits->blockCbpBits[ctx][1];
  413.   }
  415.   return(estBits);
  416. }
  417. /*!
  418. ****************************************************************************
  419. * brief
  420. *    Rate distortion optimized trellis quantization
  421. ****************************************************************************
  422. */
  423. void est_writeRunLevel_CABAC(levelDataStruct levelData[], int levelTabMin[], int type, double lambda, int kInit, int kStop, 
  424.                              int noCoeff, int estCBP)
  425. {
  426.   estBitsCabacStruct *cabacEstBits = &estBitsCabac[type];
  427.   int   k, i;
  428.   int   estBits;
  429.   double lagr, lagrMin=0, lagrTabMin, lagrTab;
  430.   int   c1 = 1, c2 = 0, c1Tab[3], c2Tab[3];
  431.   int   iBest, levelTab[64];
  432.   int   ctx, greater_one, last, maxK = maxpos[type];
  433.   double   lagrAcc, lagrLastMin=0, lagrLast;
  434.   int      kBest=0, kStart, first;
  435.   levelDataStruct *dataLevel;
  437.   for (k = 0; k <= maxK; k++)
  438.   {
  439.     levelTabMin[k] = 0;
  440.   }
  442.   if (noCoeff > 0)
  443.   {
  444.     if (noCoeff > 1)
  445.     {
  446.       kStart = kInit; kBest = 0; first = 1; 
  447.       lagrAcc = 0; 
  448.       for (k = kStart; k <= kStop; k++)
  449.       {
  450.         lagrAcc += levelData[k].errLevel[0];
  451.       }
  453.       if (levelData[kStart].noLevels > 2)
  454.       { 
  455.         lagrAcc -= levelData[kStart].errLevel[0];
  456.         lagrLastMin=lambda * (cabacEstBits->lastBits[pos2ctx_last[type][kStart]][1] - cabacEstBits->lastBits[pos2ctx_last[type][kStart]][0]) + lagrAcc;
  458.         kBest = kStart;
  459.         kStart++;
  460.         first = 0;
  461.       }
  463.       for (k = kStart; k <= kStop; k++)
  464.       {
  465.         dataLevel = &levelData[k];
  466.         lagrMin  = dataLevel->errLevel[0] + lambda * cabacEstBits->significantBits[pos2ctx_map[type][k]][0];
  467.         lagrAcc -= dataLevel->errLevel[0];
  469.         if (dataLevel->noLevels > 1)
  470.         { 
  471.           estBits = SIGN_BITS + cabacEstBits->significantBits[pos2ctx_map[type][k]][1]+
  472.             cabacEstBits->greaterOneBits[0][4][0];
  474.           lagrLast = dataLevel->errLevel[1] + lambda * (estBits + cabacEstBits->lastBits[pos2ctx_last[type][k]][1]) + lagrAcc;
  475.           lagr     = dataLevel->errLevel[1] + lambda * (estBits + cabacEstBits->lastBits[pos2ctx_last[type][k]][0]);
  477.           lagrMin = (lagr < lagrMin) ? lagr : lagrMin;
  479.           if (lagrLast < lagrLastMin || first==1)
  480.           {
  481.             kBest = k;
  482.             first = 0;
  483.             lagrLastMin = lagrLast;
  484.           }
  485.         }
  486.         lagrAcc += lagrMin;
  487.       }
  488.       kStart = kBest;
  489.     }
  490.     else
  491.     {
  492.       kStart = kStop;
  493.     }
  495.     lagrTabMin = 0;
  496.     for (k = 0; k <= kStart; k++)
  497.     {
  498.       lagrTabMin += levelData[k].errLevel[0];
  499.     }
  500.     // Initial Lagrangian calculation
  501.     lagrTab=0;
  503.     //////////////////////////
  505.     lagrTabMin += (lambda*estCBP);
  506.     iBest = 0; first = 1;
  507.     for (k = kStart; k >= 0; k--)
  508.     {
  509.       dataLevel = &levelData[k];
  510.       last = (k == kStart);
  512.       if (!last)
  513.       {
  514.         lagrMin = dataLevel->errLevel[0] + lambda * cabacEstBits->significantBits[pos2ctx_map[type][k]][0];
  515.         iBest = 0;
  516.         first = 0;
  517.       }
  519.       for (i = 1; i < dataLevel->noLevels; i++)
  520.       {
  521.         estBits = SIGN_BITS + cabacEstBits->significantBits[pos2ctx_map[type][k]][1];
  522.         estBits += cabacEstBits->lastBits[pos2ctx_last[type][k]][last];
  524.         // greater than 1
  525.         greater_one = (dataLevel->level[i] > 1);
  527.         c1Tab[i] = c1;   
  528.         c2Tab[i] = c2;
  530.         ctx = imin(c1Tab[i], 4);  
  531.         estBits += cabacEstBits->greaterOneBits[0][ctx][greater_one];
  533.         // magnitude if greater than 1
  534.         if (greater_one)
  535.         {
  536.           ctx = imin(c2Tab[i], max_c2[type]);
  537.           if ( (dataLevel->level[i] - 2) < MAX_PREC_COEFF)
  538.           {
  539.             estBits += precalcUnaryLevelTab[cabacEstBits->greaterOneState[ctx]][dataLevel->level[i] - 2];
  540.           }
  541.           else
  542.           {
  543.             estBits += est_unary_exp_golomb_level_encode(dataLevel->level[i] - 2, ctx, type);
  544.           }
  546.           c1Tab[i] = 0;
  547.           c2Tab[i]++;
  548.         }
  549.         else if (c1Tab[i])
  550.         {
  551.           c1Tab[i]++;
  552.         }
  554.         lagr = dataLevel->errLevel[i] + lambda*estBits;
  555.         if (lagr<lagrMin || first==1)
  556.         {
  557.           iBest = i;
  558.           lagrMin=lagr;
  559.           first = 0;
  560.         }
  561.       }
  563.       if (iBest>0)
  564.       {
  565.         c1 = c1Tab[iBest]; 
  566.         c2 = c2Tab[iBest];
  567.       }
  569.       levelTab[k] = dataLevel->level[iBest];
  570.       lagrTab += lagrMin;
  571.     }
  572.     ///////////////////////////////////
  574.     if (lagrTab < lagrTabMin)
  575.     {
  576.       memcpy(levelTabMin, levelTab, (kStart + 1) * sizeof(int));
  577.     }
  578.   }
  579. }
  581. /*!
  582. ****************************************************************************
  583. * brief
  584. *    estimate unary exp golomb bit cost
  585. ****************************************************************************
  586. */
  587. int est_unary_exp_golomb_level_encode(unsigned int symbol, int ctx, int type)
  588. {
  589.   estBitsCabacStruct *cabacEstBits = &estBitsCabac[type];
  590.   unsigned int l = symbol, k = 1;
  591.   unsigned int exp_start = 13; // 15-2 : 0,1 level decision always sent
  592.   int estBits;
  594.   if (symbol==0)
  595.   {
  596.     estBits = cabacEstBits->greaterOneBits[1][ctx][0];
  597.     return (estBits);
  598.   }
  599.   else
  600.   {
  601.     estBits = cabacEstBits->greaterOneBits[1][ctx][1];
  602.     // this could be done using min of the two conditionals * value
  603.     while (((--l)>0) && (++k <= exp_start))
  604.     {
  605.       estBits += cabacEstBits->greaterOneBits[1][ctx][1];
  606.     }
  607.     
  608.     if (symbol < exp_start)
  609.     {
  610.       estBits += cabacEstBits->greaterOneBits[1][ctx][0];
  611.     }
  612.     else 
  613.     {
  614.       estBits+=est_exp_golomb_encode_eq_prob(symbol - exp_start);
  615.     }
  616.   }
  617.   return(estBits);
  618. }
  620. /*!
  621. ****************************************************************************
  622. * brief
  623. *    Initialize levelData 
  624. ****************************************************************************
  625. */
  626. int init_trellis_data_4x4_CABAC(int (*tblock)[16], int block_x, int qp_per, int qp_rem, int **levelscale, int **leveloffset, const byte *p_scan, Macroblock *currMB,  
  627.                       levelDataStruct *dataLevel, int* kStart, int* kStop, int type)
  628. {
  629.   int noCoeff = 0;
  630.   int i, j, coeff_ctr;
  631.   static int *m7;
  632.   int end_coeff_ctr = ( ( type == LUMA_4x4 ) ? 16 : 15 );
  633.   int q_bits = Q_BITS + qp_per; 
  634.   int q_offset = ( 1 << (q_bits - 1) );
  635.   int level, lowerInt, k;
  636.   double err, estErr;
  638.   
  639.   for (coeff_ctr = 0; coeff_ctr < end_coeff_ctr; coeff_ctr++)
  640.   {
  641.     i = *p_scan++;  // horizontal position
  642.     j = *p_scan++;  // vertical position
  644.     m7 = &tblock[j][block_x + i];
  646.     if (*m7 == 0)
  647.     {
  648.       dataLevel->levelDouble = 0;
  649.       dataLevel->level[0] = 0;
  650.       dataLevel->noLevels = 1;
  651.       err = 0.0;
  652.       dataLevel->errLevel[0] = 0.0;
  653.     }
  654.     else
  655.     {
  656.       estErr = ((double) estErr4x4[qp_rem][j][i]) / norm_factor_4x4;
  658.       dataLevel->levelDouble = iabs(*m7 * levelscale[j][i]);
  659.       level = (dataLevel->levelDouble >> q_bits);
  661.       lowerInt = (((int)dataLevel->levelDouble - (level << q_bits)) < q_offset )? 1 : 0;
  663.       dataLevel->level[0] = 0; 
  664.       if (level == 0 && lowerInt == 1)
  665.       {
  666.         dataLevel->noLevels = 1;
  667.       }
  668.       else if (level == 0 && lowerInt == 0)
  669.       {
  670.         dataLevel->level[1] = 1;
  671.         dataLevel->noLevels = 2;
  672.         *kStop = coeff_ctr;
  673.         noCoeff++;
  674.       }
  675.       else if (level > 0 && lowerInt == 1)
  676.       {
  677.         dataLevel->level[1] = level;
  678.         dataLevel->noLevels = 2;
  679.         *kStop = coeff_ctr;
  680.         noCoeff++;
  681.       }
  682.       else
  683.       {
  684.         dataLevel->level[1] = level;
  685.         dataLevel->level[2] = level + 1;
  686.         dataLevel->noLevels = 3;
  687.         *kStop  = coeff_ctr;
  688.         *kStart = coeff_ctr;
  689.         noCoeff++;
  690.       }
  692.       for (k = 0; k < dataLevel->noLevels; k++)
  693.       {
  694.         err = (double)(dataLevel->level[k] << q_bits) - (double)dataLevel->levelDouble;
  695.         dataLevel->errLevel[k] = (err * err * estErr); 
  696.       }
  697.     }
  699.     dataLevel++;
  700.   }
  701.   return (noCoeff);
  702. }
  704. /*
  705. ****************************************************************************
  706. * brief
  707. *    Initialize levelData 
  708. ****************************************************************************
  709. */
  710. int init_trellis_data_8x8_CABAC(int (*tblock)[16], int block_x, int qp_per, int qp_rem, int **levelscale, int **leveloffset, const byte *p_scan, Macroblock *currMB,  
  711.                       levelDataStruct *dataLevel, int* kStart, int* kStop, int symbolmode)
  712. {
  713.   int noCoeff = 0;
  714.   static int *m7;
  715.   int i, j, coeff_ctr, end_coeff_ctr = 64;
  716.   int q_bits = Q_BITS_8 + qp_per;
  717.   int q_offset = ( 1 << (q_bits - 1) );
  718.   double err, estErr; 
  719.   int level, lowerInt, k;
  720.   
  721.   for (coeff_ctr = 0; coeff_ctr < end_coeff_ctr; coeff_ctr++)
  722.   {
  723.     i = *p_scan++;  // horizontal position
  724.     j = *p_scan++;  // vertical position
  725.     
  726.     m7 = &tblock[j][block_x + i];
  728.     if (*m7 == 0)
  729.     {
  730.       dataLevel->levelDouble = 0;
  731.       dataLevel->level[0] = 0;
  732.       dataLevel->noLevels = 1;
  733.       err = 0.0;
  734.       dataLevel->errLevel[0] = 0.0;
  735.     }
  736.     else
  737.     {
  738.       estErr = (double) estErr8x8[qp_rem][j][i] / norm_factor_8x8;
  740.       dataLevel->levelDouble = iabs(*m7 * levelscale[j][i]);
  741.       level = (dataLevel->levelDouble >> q_bits);
  743.       lowerInt = (((int)dataLevel->levelDouble - (level << q_bits)) < q_offset )? 1 : 0;
  745.       dataLevel->level[0] = 0;
  746.       if (level == 0 && lowerInt == 1)
  747.       {
  748.         dataLevel->noLevels = 1;
  749.       }
  750.       else if (level == 0 && lowerInt == 0)
  751.       {
  752.         dataLevel->level[1] = 1;
  753.         dataLevel->noLevels = 2;
  754.         *kStop = coeff_ctr;
  755.         noCoeff++;
  756.       }
  757.       else if (level > 0 && lowerInt == 1)
  758.       {
  759.         dataLevel->level[1] = level;
  760.         dataLevel->noLevels = 2;
  761.         *kStop = coeff_ctr;
  762.         noCoeff++;
  763.       }
  764.       else
  765.       {
  766.         dataLevel->level[1] = level;
  767.         dataLevel->level[2] = level + 1;
  768.         dataLevel->noLevels = 3;
  769.         *kStop  = coeff_ctr;
  770.         *kStart = coeff_ctr;
  771.         noCoeff++;
  772.       }
  774.       for (k = 0; k < dataLevel->noLevels; k++)
  775.       {
  776.         err = (double)(dataLevel->level[k] << q_bits) - (double)dataLevel->levelDouble;
  777.         dataLevel->errLevel[k] = err * err * estErr; 
  778.       }
  779.     }
  780.  
  781.     dataLevel++;
  782.   }
  783.   return (noCoeff);
  784. }
  786. /*!
  787. ****************************************************************************
  788. * brief
  789. *    Initialize levelData for Luma DC
  790. ****************************************************************************
  791. */
  792. int init_trellis_data_DC_CABAC(int (*tblock)[4], int qp_per, int qp_rem, 
  793.                          int levelscale, int leveloffset, const byte *p_scan, Macroblock *currMB,  
  794.                          levelDataStruct *dataLevel, int* kStart, int* kStop)
  795. {
  796.   int noCoeff = 0;
  797.   int i, j, coeff_ctr, end_coeff_ctr = 16;
  798.   int q_bits   = Q_BITS + qp_per + 1; 
  799.   int q_offset = ( 1 << (q_bits - 1) );
  800.   int level, lowerInt, k;
  801.   int *m7;
  802.   double err, estErr = (double) estErr4x4[qp_rem][0][0] / norm_factor_4x4; // note that we could also use int64
  804.   for (coeff_ctr = 0; coeff_ctr < end_coeff_ctr; coeff_ctr++)
  805.   {
  806.     i = *p_scan++;  // horizontal position
  807.     j = *p_scan++;  // vertical position
  808.     m7 = &tblock[j][i];
  810.     if (*m7 == 0)
  811.     {
  812.       dataLevel->levelDouble = 0;
  813.       dataLevel->level[0] = 0;
  814.       dataLevel->noLevels = 1;
  815.       err = 0.0;
  816.       dataLevel->errLevel[0] = 0.0;
  817.     }
  818.     else
  819.     {
  820.       dataLevel->levelDouble = iabs(*m7 * levelscale);
  821.       level = (dataLevel->levelDouble >> q_bits);
  823.       lowerInt=( ((int)dataLevel->levelDouble - (level<<q_bits)) < q_offset )? 1 : 0;
  825.       dataLevel->level[0] = 0;    
  826.       if (level == 0 && lowerInt == 1)
  827.       {
  828.         dataLevel->noLevels = 1;
  829.       }
  830.       else if (level == 0 && lowerInt == 0)
  831.       {
  832.         dataLevel->level[1] = 1;
  833.         dataLevel->noLevels = 2;
  834.         *kStop = coeff_ctr;
  835.         noCoeff++;
  836.       }
  837.       else if (level > 0 && lowerInt == 1)
  838.       {
  839.         dataLevel->level[1] = level;
  840.         dataLevel->noLevels = 2;
  841.         *kStop = coeff_ctr;
  842.         noCoeff++;
  843.       }
  844.       else
  845.       {
  846.         dataLevel->level[1] = level;
  847.         dataLevel->level[2] = level + 1;
  848.         dataLevel->noLevels = 3;
  849.         *kStop  = coeff_ctr;
  850.         *kStart = coeff_ctr;
  851.         noCoeff++;
  852.       }
  854.       for (k = 0; k < dataLevel->noLevels; k++)
  855.       {
  856.         err = (double)(dataLevel->level[k] << q_bits) - (double)dataLevel->levelDouble;
  857.         dataLevel->errLevel[k] = (err * err * estErr); 
  858.       }
  859.     }
  860.     dataLevel++;
  861.   }
  862.   return (noCoeff);
  863. }