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

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

Audio

开发平台：

Visual C++

cabac.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file cabac.c
  5.  *
  6.  * brief
  7.  *    CABAC entropy coding routines
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *    - Detlev Marpe                    <marpe@hhi.de>
  12.  **************************************************************************************
  13.  */
  15. #include "global.h"
  17. #include "cabac.h"
  18. #include "image.h"
  19. #include "mb_access.h"
  21. #if TRACE
  22.   #define CABAC_TRACE if (dp->bitstream->trace_enabled) trace2out_cabac (se)
  23. #else
  24.   #define CABAC_TRACE
  25. #endif
  27. /***********************************************************************
  28.  * L O C A L L Y   D E F I N E D   F U N C T I O N   P R O T O T Y P E S
  29.  ***********************************************************************
  30.  */
  33. void unary_bin_encode(EncodingEnvironmentPtr eep_frame,
  34.                       unsigned int symbol,
  35.                       BiContextTypePtr ctx,
  36.                       int ctx_offset);
  38. void unary_bin_max_encode(EncodingEnvironmentPtr eep_frame,
  39.                           unsigned int symbol,
  40.                           BiContextTypePtr ctx,
  41.                           int ctx_offset,
  42.                           unsigned int max_symbol);
  44. void unary_exp_golomb_level_encode( EncodingEnvironmentPtr eep_dp,
  45.                                     unsigned int symbol,
  46.                                     BiContextTypePtr ctx);
  48. void unary_exp_golomb_mv_encode(EncodingEnvironmentPtr eep_dp,
  49.                                 unsigned int symbol,
  50.                                 BiContextTypePtr ctx,
  51.                                 unsigned int max_bin);
  55. /*!
  56.  ************************************************************************
  57.  * brief
  58.  *    Check for available neighbouring blocks
  59.  *    and set pointers in current macroblock
  60.  ************************************************************************
  61.  */
  62. void CheckAvailabilityOfNeighborsCABAC(Macroblock *currMB)
  63. {
  64.   PixelPos up, left;
  65.   int *mb_size = img->mb_size[IS_LUMA];
  67.   getNeighbour(currMB, -1,  0, mb_size, &left);
  68.   getNeighbour(currMB,  0, -1, mb_size, &up);
  70.   if (up.available)
  71.     currMB->mb_available_up = &img->mb_data[up.mb_addr];
  72.   else
  73.     currMB->mb_available_up = NULL;
  75.   if (left.available)
  76.     currMB->mb_available_left = &img->mb_data[left.mb_addr];
  77.   else
  78.     currMB->mb_available_left = NULL;
  79. }
  81. /*!
  82.  ************************************************************************
  83.  * brief
  84.  *    Allocation of contexts models for the motion info
  85.  *    used for arithmetic encoding
  86.  ************************************************************************
  87.  */
  88. MotionInfoContexts* create_contexts_MotionInfo(void)
  89. {
  90.   MotionInfoContexts* enco_ctx;
  92.   enco_ctx = (MotionInfoContexts*) calloc(1, sizeof(MotionInfoContexts) );
  93.   if( enco_ctx == NULL )
  94.     no_mem_exit("create_contexts_MotionInfo: enco_ctx");
  96.   return enco_ctx;
  97. }
  100. /*!
  101.  ************************************************************************
  102.  * brief
  103.  *    Allocates of contexts models for the texture info
  104.  *    used for arithmetic encoding
  105.  ************************************************************************
  106.  */
  107. TextureInfoContexts* create_contexts_TextureInfo(void)
  108. {
  109.   TextureInfoContexts*  enco_ctx = (TextureInfoContexts*) calloc(1, sizeof(TextureInfoContexts) );
  110.   if( enco_ctx == NULL )
  111.     no_mem_exit("create_contexts_TextureInfo: enco_ctx");
  113.   return enco_ctx;
  114. }
  119. /*!
  120.  ************************************************************************
  121.  * brief
  122.  *    Frees the memory of the contexts models
  123.  *    used for arithmetic encoding of the motion info.
  124.  ************************************************************************
  125.  */
  126. void delete_contexts_MotionInfo(MotionInfoContexts *enco_ctx)
  127. {
  128.   if( enco_ctx == NULL )
  129.     return;
  131.   free( enco_ctx );
  132. }
  134. /*!
  135.  ************************************************************************
  136.  * brief
  137.  *    Frees the memory of the contexts models
  138.  *    used for arithmetic encoding of the texture info.
  139.  ************************************************************************
  140.  */
  141. void delete_contexts_TextureInfo(TextureInfoContexts *enco_ctx)
  142. {
  143.   if( enco_ctx == NULL )
  144.     return;
  146.   free( enco_ctx );
  147. }
  150. /*!
  151.  ***************************************************************************
  152.  * brief
  153.  *    This function is used to arithmetically encode the field
  154.  *    mode info of a given MB  in the case of mb-based frame/field decision
  155.  ***************************************************************************
  156.  */
  157. void writeFieldModeInfo_CABAC(SyntaxElement *se, DataPartition *dp)
  158. {
  159.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  160.   int curr_len = arienco_bits_written(eep_dp);
  161.   MotionInfoContexts *ctx     = (img->currentSlice)->mot_ctx;
  162.   Macroblock         *currMB  = &img->mb_data[img->current_mb_nr];
  163.   int                mb_field = se->value1;
  165.   int a = currMB->mbAvailA ? img->mb_data[currMB->mbAddrA].mb_field : 0;
  166.   int b = currMB->mbAvailB ? img->mb_data[currMB->mbAddrB].mb_field : 0;
  168.   int act_ctx = a + b;
  170.   biari_encode_symbol(eep_dp, (signed short) (mb_field != 0),&ctx->mb_aff_contexts[act_ctx]);
  172.   se->context = act_ctx;
  174.   dp->bitstream->write_flag = 1;
  175.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  176.   CABAC_TRACE;
  177. }
  179. /*!
  180. ***************************************************************************
  181. * brief
  182. *    This function is used to arithmetically encode the mb_skip_flag.
  183. ***************************************************************************
  184. */
  185. void writeMB_skip_flagInfo_CABAC(Macroblock *currMB, SyntaxElement *se, DataPartition *dp)
  186. {
  187.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  188.   int curr_len = arienco_bits_written(eep_dp);
  189.   MotionInfoContexts *ctx = (img->currentSlice)->mot_ctx;
  190.   int        curr_mb_type = se->value1;
  191.   int a = (currMB->mb_available_left != NULL && (currMB->mb_available_left->skip_flag == 0)) ? 1 : 0;
  192.   int b = (currMB->mb_available_up   != NULL && (currMB->mb_available_up  ->skip_flag == 0)) ? 1 : 0;
  193.   int act_ctx = a + b;
  195.   if (img->type == B_SLICE)
  196.   {
  197.     act_ctx += 7;
  199.     if (se->value1==0 && se->value2==0) // DIRECT mode, no coefficients
  200.       biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]);
  201.     else
  202.       biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[2][act_ctx]);
  204.     currMB->skip_flag = (se->value1==0 && se->value2==0) ? 1 : 0;
  205.   }
  206.   else
  207.   {
  208.     if (curr_mb_type==0) // SKIP
  209.       biari_encode_symbol(eep_dp, 1,&ctx->mb_type_contexts[1][act_ctx]);
  210.     else
  211.       biari_encode_symbol(eep_dp, 0,&ctx->mb_type_contexts[1][act_ctx]);
  213.     currMB->skip_flag = (curr_mb_type==0) ? 1 : 0;
  214.   }
  215.   se->context = act_ctx;
  216.   se->value1  = 1 - currMB->skip_flag;
  218.   dp->bitstream->write_flag = 1;
  219.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  220.   CABAC_TRACE;
  221. }
  223. /*!
  224. ***************************************************************************
  225. * brief
  226. *    This function is used to arithmetically encode the macroblock
  227. *    intra_pred_size flag info of a given MB.
  228. ***************************************************************************
  229. */
  231. void writeMB_transform_size_CABAC(SyntaxElement *se, DataPartition *dp)
  232. {
  233.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  234.   MotionInfoContexts *ctx         = (img->currentSlice)->mot_ctx;
  235.   Macroblock         *currMB      = &img->mb_data[img->current_mb_nr];
  237.   int curr_len = arienco_bits_written(eep_dp);
  238.   int act_sym = currMB->luma_transform_size_8x8_flag;
  241.   int b = (currMB->mb_available_up == NULL) ? 0 : currMB->mb_available_up->luma_transform_size_8x8_flag;
  242.   int a = (currMB->mb_available_left == NULL) ? 0 :currMB->mb_available_left->luma_transform_size_8x8_flag;
  243.   int act_ctx     = a + b;
  245.   se->context = act_ctx; // store context
  246.   biari_encode_symbol(eep_dp, (signed short) (act_sym != 0), ctx->transform_size_contexts + act_ctx );
  248.   dp->bitstream->write_flag = 1;
  249.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  250.   CABAC_TRACE;
  251. }
  253. /*!
  254.  ***************************************************************************
  255.  * brief
  256.  *    This function is used to arithmetically encode the macroblock
  257.  *    type info of a given MB.
  258.  ***************************************************************************
  259.  */
  261. void writeMB_typeInfo_CABAC(SyntaxElement *se, DataPartition *dp)
  262. {
  263.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  264.   int curr_len = arienco_bits_written(eep_dp);
  265.   int a, b;
  266.   int act_ctx = 0;
  267.   int act_sym;
  268.   signed short csym;
  269.   int bframe   = (img->type==B_SLICE);
  270.   int mode_sym = 0;
  271.   int mode16x16;
  274.   MotionInfoContexts *ctx         = (img->currentSlice)->mot_ctx;
  275.   Macroblock         *currMB      = &img->mb_data[img->current_mb_nr];
  276.   int                curr_mb_type = se->value1;
  278.   if(img->type == I_SLICE)  // INTRA-frame
  279.   {
  280.     if (currMB->mb_available_up == NULL)
  281.       b = 0;
  282.     else
  283.       b = ((currMB->mb_available_up->mb_type != I4MB &&  currMB->mb_available_up->mb_type != I8MB) ? 1 : 0 );
  285.     if (currMB->mb_available_left == NULL)
  286.       a = 0;
  287.     else
  288.       a = ((currMB->mb_available_left->mb_type != I4MB &&  currMB->mb_available_left->mb_type != I8MB) ? 1 : 0 );
  290.     act_ctx     = a + b;
  291.     act_sym     = curr_mb_type;
  292.     se->context = act_ctx; // store context
  294.     if (act_sym==0) // 4x4 Intra
  295.     {
  296.       biari_encode_symbol(eep_dp, 0, ctx->mb_type_contexts[0] + act_ctx );
  297.     }
  298.     else if( act_sym == 25 ) // PCM-MODE
  299.     {
  300.       biari_encode_symbol(eep_dp, 1, ctx->mb_type_contexts[0] + act_ctx );
  301.       biari_encode_symbol_final(eep_dp, 1);
  302.     }
  303.     else // 16x16 Intra
  304.     {
  305.       biari_encode_symbol(eep_dp, 1, ctx->mb_type_contexts[0] + act_ctx );
  307.       biari_encode_symbol_final(eep_dp, 0);
  309.       mode_sym = act_sym-1; // Values in the range of 0...23
  310.       act_ctx  = 4;
  311.       act_sym  = mode_sym/12;
  312.       biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[0] + act_ctx ); // coding of AC/no AC
  313.       mode_sym = mode_sym % 12;
  314.       act_sym  = mode_sym / 4; // coding of cbp: 0,1,2
  315.       act_ctx  = 5;
  316.       if (act_sym==0)
  317.       {
  318.         biari_encode_symbol(eep_dp, 0, ctx->mb_type_contexts[0] + act_ctx );
  319.       }
  320.       else
  321.       {
  322.         biari_encode_symbol(eep_dp, 1, ctx->mb_type_contexts[0] + act_ctx );
  323.         act_ctx=6;
  324.         biari_encode_symbol(eep_dp, (signed short) (act_sym!=1), ctx->mb_type_contexts[0] + act_ctx );
  325.       }
  326.       mode_sym = mode_sym & 0x03; // coding of I pred-mode: 0,1,2,3
  327.       act_sym  = mode_sym >> 1;
  328.       act_ctx  = 7;
  329.       biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[0] + act_ctx );
  330.       act_ctx  = 8;
  331.       act_sym  = mode_sym & 0x01;
  332.       biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[0] + act_ctx );
  333.     }
  334.   }
  335.   else // INTER
  336.   {
  338.     if (bframe)
  339.     {
  340.       if (currMB->mb_available_up == NULL)
  341.         b = 0;
  342.       else
  343.         b = ((currMB->mb_available_up->mb_type != 0) ? 1 : 0 );
  345.       if (currMB->mb_available_left == NULL)
  346.         a = 0;
  347.       else
  348.         a = ((currMB->mb_available_left->mb_type != 0) ? 1 : 0 );
  349.       act_ctx = a + b;
  350.       se->context = act_ctx; // store context
  351.     }
  352.     act_sym = curr_mb_type;
  354.     if (act_sym>=(mode16x16=(bframe?24:7)))
  355.     {
  356.       mode_sym = act_sym-mode16x16;
  357.       act_sym  = mode16x16; // 16x16 mode info
  358.     }
  360.     if (!bframe)
  361.     {
  362.       switch (act_sym)
  363.       {
  364.       case 0:
  365.         break;
  366.       case 1:
  367.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][4]);
  368.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][5]);
  369.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][6]);
  370.         break;
  371.       case 2:
  372.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][4]);
  373.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][5]);
  374.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][7]);
  375.         break;
  376.       case 3:
  377.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][4]);
  378.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][5]);
  379.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][7]);
  380.         break;
  381.       case 4:
  382.       case 5:
  383.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][4]);
  384.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][5]);
  385.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][6]);
  386.         break;
  387.       case 6:
  388.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][4]);
  389.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][7]);
  390.         break;
  391.       case 7:
  392.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][4]);
  393.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][7]);
  394.         break;
  395.       default:
  396.         printf ("Unsupported MB-MODE in writeMB_typeInfo_CABAC!n");
  397.         exit (1);
  398.       }
  399.     }
  400.     else //===== B-FRAMES =====
  401.     {
  402.       if (act_sym==0)
  403.       {
  404.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[2][act_ctx]);
  405.       }
  406.       else if (act_sym<=2)
  407.       {
  408.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]);
  409.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[2][4]);
  410.         csym = (act_sym-1 != 0);
  411.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  412.       }
  413.       else if (act_sym<=10)
  414.       {
  415.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]);
  416.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][4]);
  417.         biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[2][5]);
  418.         csym=(((act_sym-3)>>2)&0x01) != 0;
  419.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  420.         csym=(((act_sym-3)>>1)&0x01) != 0;
  421.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  422.         csym=((act_sym-3)&0x01) != 0;
  423.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  424.       }
  425.       else if (act_sym==11 || act_sym==22)
  426.       {
  427.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]);
  428.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][4]);
  429.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][5]);
  430.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][6]);
  431.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][6]);
  432.         csym = (act_sym != 11);
  433.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  434.       }
  435.       else
  436.       {
  437.         if (act_sym > 22) act_sym--;
  438.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]);
  439.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][4]);
  440.         biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][5]);
  441.         csym=(((act_sym-12)>>3)&0x01) != 0;
  442.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  443.         csym=(((act_sym-12)>>2)&0x01) != 0;
  444.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  445.         csym=(((act_sym-12)>>1)&0x01) != 0;
  446.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  447.         csym=((act_sym-12)&0x01) != 0;
  448.         biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]);
  449.         if (act_sym >=22) act_sym++;
  450.       }
  451.     }
  453.     if(act_sym==mode16x16) // additional info for 16x16 Intra-mode
  454.     {
  455.       if( mode_sym==24 )
  456.       {
  457.         biari_encode_symbol_final(eep_dp, 1 );
  458.         dp->bitstream->write_flag = 1;
  459.         se->len = (arienco_bits_written(eep_dp) - curr_len);
  460.         CABAC_TRACE;
  461.         return;
  462.       }
  463.       biari_encode_symbol_final(eep_dp, 0 );
  465.       act_ctx = 8;
  466.       act_sym = mode_sym/12;
  467.       biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[1] + act_ctx ); // coding of AC/no AC
  468.       mode_sym = mode_sym % 12;
  470.       act_sym = mode_sym / 4; // coding of cbp: 0,1,2
  471.       act_ctx = 9;
  472.       if (act_sym==0)
  473.       {
  474.         biari_encode_symbol(eep_dp, 0, ctx->mb_type_contexts[1] + act_ctx );
  475.       }
  476.       else
  477.       {
  478.         biari_encode_symbol(eep_dp, 1, ctx->mb_type_contexts[1] + act_ctx );
  479.         biari_encode_symbol(eep_dp, (signed short) (act_sym!=1), ctx->mb_type_contexts[1] + act_ctx );
  480.       }
  482.       mode_sym = mode_sym % 4; // coding of I pred-mode: 0,1,2,3
  483.       act_ctx  = 10;
  484.       act_sym  = mode_sym/2;
  485.       biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[1] + act_ctx );
  486.       act_sym  = mode_sym%2;
  487.       biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[1] + act_ctx );
  488.     }
  489.   }
  490.   dp->bitstream->write_flag = 1;
  491.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  492.   CABAC_TRACE;
  493. }
  496. /*!
  497.  ***************************************************************************
  498.  * brief
  499.  *    This function is used to arithmetically encode the 8x8 block
  500.  *    type info
  501.  ***************************************************************************
  502.  */
  503. void writeB8_typeInfo_CABAC(SyntaxElement *se, DataPartition *dp)
  504. {
  505.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  506.   int curr_len = arienco_bits_written(eep_dp);
  507.   int act_ctx;
  508.   int act_sym;
  509.   signed short csym;
  510.   int bframe=(img->type==B_SLICE);
  512.   BiContextType (*b8_type_contexts)[9] = (img->currentSlice)->mot_ctx->b8_type_contexts;
  514.   act_sym = se->value1;
  515.   act_ctx = 0;
  517.   if (!bframe)
  518.   {
  519.     switch (act_sym)
  520.     {
  521.     case 0:
  522.       biari_encode_symbol (eep_dp, 1, &b8_type_contexts[0][1]);
  523.       break;
  524.     case 1:
  525.       biari_encode_symbol (eep_dp, 0, &b8_type_contexts[0][1]);
  526.       biari_encode_symbol (eep_dp, 0, &b8_type_contexts[0][3]);
  527.       break;
  528.     case 2:
  529.       biari_encode_symbol (eep_dp, 0, &b8_type_contexts[0][1]);
  530.       biari_encode_symbol (eep_dp, 1, &b8_type_contexts[0][3]);
  531.       biari_encode_symbol (eep_dp, 1, &b8_type_contexts[0][4]);
  532.       break;
  533.     case 3:
  534.       biari_encode_symbol (eep_dp, 0, &b8_type_contexts[0][1]);
  535.       biari_encode_symbol (eep_dp, 1, &b8_type_contexts[0][3]);
  536.       biari_encode_symbol (eep_dp, 0, &b8_type_contexts[0][4]);
  537.       break;
  538.     }
  539.   }
  540.   else //===== B-FRAME =====
  541.   {
  542.     if (act_sym==0)
  543.     {
  544.       biari_encode_symbol (eep_dp, 0, &b8_type_contexts[1][0]);
  545.       dp->bitstream->write_flag = 1;
  546.       se->len = (arienco_bits_written(eep_dp) - curr_len);
  547.       CABAC_TRACE;
  548.       return;
  549.     }
  550.     else
  551.     {
  552.       biari_encode_symbol (eep_dp, 1, &b8_type_contexts[1][0]);
  553.       act_sym--;
  554.     }
  556.     if (act_sym < 2)
  557.     {
  558.       biari_encode_symbol (eep_dp, 0, &b8_type_contexts[1][1]);
  559.       biari_encode_symbol (eep_dp, (signed short) (act_sym!=0), &b8_type_contexts[1][3]);
  560.     }
  561.     else if (act_sym < 6)
  562.     {
  563.       biari_encode_symbol (eep_dp, 1, &b8_type_contexts[1][1]);
  564.       biari_encode_symbol (eep_dp, 0, &b8_type_contexts[1][2]);
  565.       csym=(((act_sym - 2) >> 1) & 0x01) != 0;
  566.       biari_encode_symbol (eep_dp, csym, &b8_type_contexts[1][3]);
  567.       csym=((act_sym - 2) & 0x01) != 0;
  568.       biari_encode_symbol (eep_dp, csym, &b8_type_contexts[1][3]);
  569.     }
  570.     else
  571.     {
  572.       biari_encode_symbol (eep_dp, 1, &b8_type_contexts[1][1]);
  573.       biari_encode_symbol (eep_dp, 1, &b8_type_contexts[1][2]);
  574.       csym=(((act_sym - 6)>> 2) & 0x01);
  575.       if (csym)
  576.       {
  577.         biari_encode_symbol (eep_dp, 1, &b8_type_contexts[1][3]);
  578.         csym=((act_sym - 6) & 0x01) != 0;
  579.         biari_encode_symbol (eep_dp, csym, &b8_type_contexts[1][3]);
  580.       }
  581.       else
  582.       {
  583.         biari_encode_symbol (eep_dp, 0, &b8_type_contexts[1][3]);
  584.         csym=(((act_sym - 6) >> 1) & 0x01) != 0;
  585.         biari_encode_symbol (eep_dp, csym, &b8_type_contexts[1][3]);
  586.         csym=((act_sym - 6) & 0x01) != 0;
  587.         biari_encode_symbol (eep_dp, csym, &b8_type_contexts[1][3]);
  588.       }
  589.     }
  590.   }
  592.   dp->bitstream->write_flag = 1;
  593.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  594.   CABAC_TRACE;
  595. }
  597. /*!
  598.  ****************************************************************************
  599.  * brief
  600.  *    This function is used to arithmetically encode a pair of
  601.  *    intra prediction modes of a given MB.
  602.  ****************************************************************************
  603.  */
  604. void writeIntraPredMode_CABAC(SyntaxElement *se, DataPartition *dp)
  605. {
  606.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  607.   int curr_len = arienco_bits_written(eep_dp);
  608.   BiContextType *ipr_contexts = (img->currentSlice)->tex_ctx->ipr_contexts;
  610.   // use_most_probable_mode
  611.   if (se->value1 == -1)
  612.     biari_encode_symbol(eep_dp, 1, ipr_contexts);
  613.   else
  614.   {
  615.     biari_encode_symbol(eep_dp, 0, ipr_contexts);
  617.     // remaining_mode_selector
  618.     biari_encode_symbol(eep_dp,(signed short)( se->value1 & 0x1    ), ipr_contexts+1);
  619.     biari_encode_symbol(eep_dp,(signed short)((se->value1 & 0x2)>>1), ipr_contexts+1);
  620.     biari_encode_symbol(eep_dp,(signed short)((se->value1 & 0x4)>>2), ipr_contexts+1);
  621.   }
  623.   dp->bitstream->write_flag = 1;
  624.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  625.   CABAC_TRACE;
  626. }
  628. /*!
  629.  ****************************************************************************
  630.  * brief
  631.  *    This function is used to arithmetically encode the reference
  632.  *    parameter of a given MB.
  633.  ****************************************************************************
  634.  */
  635. void writeRefFrame_CABAC(SyntaxElement *se, DataPartition *dp)
  636. {
  637.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  638.   int curr_len = arienco_bits_written(eep_dp);
  639.   int   mb_nr = img->current_mb_nr;
  640.   MotionInfoContexts  *ctx    = img->currentSlice->mot_ctx;
  641.   Macroblock          *currMB = &img->mb_data[mb_nr];
  642.   int                 addctx  = 0;
  644.   int   a, b;
  645.   int   act_ctx;
  646.   int   act_sym;
  647.   char** refframe_array = enc_picture->motion.ref_idx[se->value2];
  649.   int bslice = (img->type==B_SLICE);
  651.   int   b8a, b8b;
  653.   PixelPos block_a, block_b;
  654.   int *mb_size = img->mb_size[IS_LUMA];
  656.   get4x4Neighbour(currMB, (img->subblock_x << 2) - 1, (img->subblock_y << 2)    , mb_size, &block_a);
  657.   get4x4Neighbour(currMB, (img->subblock_x << 2),     (img->subblock_y << 2) - 1, mb_size, &block_b);
  659.   b8a=((block_a.x >> 1) & 0x01)+2*((block_a.y >> 1) & 0x01);
  660.   b8b=((block_b.x >> 1) & 0x01)+2*((block_b.y >> 1) & 0x01);
  663.   if (!block_b.available)
  664.     b=0;
  665.   //else if (IS_DIRECT(&img->mb_data[block_b.mb_addr]) || (img->mb_data[block_b.mb_addr].b8mode[b8b]==0 && bslice))
  666.   else if ((IS_DIRECT(&img->mb_data[block_b.mb_addr]) && !giRDOpt_B8OnlyFlag) || (img->mb_data[block_b.mb_addr].b8mode[b8b]==0 && bslice))
  667.     b=0;
  668.   else
  669.   {
  670.     if (img->MbaffFrameFlag && (currMB->mb_field == 0) && (img->mb_data[block_b.mb_addr].mb_field == 1))
  671.       b = (refframe_array[block_b.pos_y][block_b.pos_x] > 1 ? 1 : 0);
  672.     else
  673.       b = (refframe_array[block_b.pos_y][block_b.pos_x] > 0 ? 1 : 0);
  674.   }
  676.   if (!block_a.available)
  677.     a=0;
  678.   // else if (IS_DIRECT(&img->mb_data[block_a.mb_addr]) || (img->mb_data[block_a.mb_addr].b8mode[b8a]==0 && bslice))
  679.   else if ((IS_DIRECT(&img->mb_data[block_a.mb_addr]) && !giRDOpt_B8OnlyFlag) || (img->mb_data[block_a.mb_addr].b8mode[b8a]==0 && bslice))
  680.     a=0;
  681.   else
  682.   {
  683.     if (img->MbaffFrameFlag && (currMB->mb_field == 0) && (img->mb_data[block_a.mb_addr].mb_field == 1))
  684.       a = (refframe_array[block_a.pos_y][block_a.pos_x] > 1 ? 1 : 0);
  685.     else
  686.       a = (refframe_array[block_a.pos_y][block_a.pos_x] > 0 ? 1 : 0);
  687.   }
  689.   act_ctx     = a + 2*b;
  690.   se->context = act_ctx; // store context
  691.   act_sym     = se->value1;
  693.   if (act_sym==0)
  694.   {
  695.     biari_encode_symbol(eep_dp, 0, ctx->ref_no_contexts[addctx] + act_ctx );
  696.   }
  697.   else
  698.   {
  699.     biari_encode_symbol(eep_dp, 1, ctx->ref_no_contexts[addctx] + act_ctx);
  700.     act_sym--;
  701.     act_ctx=4;
  702.     unary_bin_encode(eep_dp, act_sym,ctx->ref_no_contexts[addctx] + act_ctx,1);
  703.   }
  705.   dp->bitstream->write_flag = 1;
  706.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  707.   CABAC_TRACE;
  708. }
  710. /*!
  711.  ****************************************************************************
  712.  * brief
  713.  *    This function is used to arithmetically encode the coded
  714.  *    block pattern of a given delta quant.
  715.  ****************************************************************************
  716.  */
  717. void writeDquant_CABAC(SyntaxElement *se, DataPartition *dp)
  718. {
  719.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  720.   int curr_len = arienco_bits_written(eep_dp);
  722.   MotionInfoContexts *ctx = img->currentSlice->mot_ctx;
  723.   Macroblock *currMB = &img->mb_data[img->current_mb_nr];
  724.  
  725.   int dquant = se->value1;
  726.   int sign    = (dquant <= 0) ? 0 : -1;
  727.   int act_sym = (iabs(dquant) << 1) + sign;
  728.   int act_ctx = ((currMB->prev_dqp != 0) ? 1 : 0);
  730.   if (act_sym==0)
  731.   {
  732.     biari_encode_symbol(eep_dp, 0, ctx->delta_qp_contexts + act_ctx );
  733.   }
  734.   else
  735.   {
  736.     biari_encode_symbol(eep_dp, 1, ctx->delta_qp_contexts + act_ctx);
  737.     act_ctx=2;
  738.     act_sym--;
  739.     unary_bin_encode(eep_dp, act_sym,ctx->delta_qp_contexts+act_ctx,1);
  740.   }
  742.   dp->bitstream->write_flag = 1;
  743.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  744.   CABAC_TRACE;
  745. }
  747. /*!
  748.  ****************************************************************************
  749.  * brief
  750.  *    This function is used to arithmetically encode the motion
  751.  *    vector data of a B-frame MB.
  752.  ****************************************************************************
  753.  */
  754. void writeMVD_CABAC(SyntaxElement *se, DataPartition *dp)
  755. {
  756.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  757.   int curr_len = arienco_bits_written(eep_dp);
  758.   int i = (img->subblock_x << 2);
  759.   int j = (img->subblock_y << 2);
  760.   int a, b;
  761.   int act_ctx;
  762.   int act_sym;
  763.   int mv_pred_res;
  764.   int mv_local_err;
  765.   int mv_sign;
  766.   int list_idx = se->value2 & 0x01;
  767.   int k = (se->value2>>1); // MVD component
  768.   int mb_nr = img->current_mb_nr;
  770.   PixelPos block_a, block_b;
  772.   MotionInfoContexts  *ctx    = img->currentSlice->mot_ctx;
  773.   Macroblock          *currMB = &img->mb_data[mb_nr];
  774.   int *mb_size = img->mb_size[IS_LUMA];
  776.   get4x4Neighbour(currMB, i - 1, j    , mb_size, &block_a);
  777.   get4x4Neighbour(currMB, i    , j - 1, mb_size, &block_b);
  779.   if (block_b.available)
  780.   {
  781.     b = iabs(img->mb_data[block_b.mb_addr].mvd[list_idx][block_b.y][block_b.x][k]);
  782.     if (img->MbaffFrameFlag && (k==1))
  783.     {
  784.       if ((currMB->mb_field==0) && (img->mb_data[block_b.mb_addr].mb_field==1))
  785.         b *= 2;
  786.       else if ((currMB->mb_field==1) && (img->mb_data[block_b.mb_addr].mb_field==0))
  787.         b /= 2;
  788.     }
  789.   }
  790.   else
  791.     b=0;
  793.   if (block_a.available)
  794.   {
  795.     a = iabs(img->mb_data[block_a.mb_addr].mvd[list_idx][block_a.y][block_a.x][k]);
  796.     if (img->MbaffFrameFlag && (k==1))
  797.     {
  798.       if ((currMB->mb_field==0) && (img->mb_data[block_a.mb_addr].mb_field==1))
  799.         a *= 2;
  800.       else if ((currMB->mb_field==1) && (img->mb_data[block_a.mb_addr].mb_field==0))
  801.         a /= 2;
  802.     }
  803.   }
  804.   else
  805.     a = 0;
  807.   if ((mv_local_err=a+b)<3)
  808.     act_ctx = 5*k;
  809.   else
  810.   {
  811.     if (mv_local_err>32)
  812.       act_ctx=5*k+3;
  813.     else
  814.       act_ctx=5*k+2;
  815.   }
  817.   mv_pred_res = se->value1;
  818.   se->context = act_ctx;
  820.   act_sym = iabs(mv_pred_res);
  822.   if (act_sym == 0)
  823.     biari_encode_symbol(eep_dp, 0, &ctx->mv_res_contexts[0][act_ctx] );
  824.   else
  825.   {
  826.     biari_encode_symbol(eep_dp, 1, &ctx->mv_res_contexts[0][act_ctx] );
  827.     act_sym--;
  828.     act_ctx=5*k;
  829.     unary_exp_golomb_mv_encode(eep_dp,act_sym,ctx->mv_res_contexts[1]+act_ctx,3);
  830.     mv_sign = (mv_pred_res<0) ? 1: 0;
  831.     biari_encode_symbol_eq_prob(eep_dp, (signed short) mv_sign);
  832.   }
  834.   dp->bitstream->write_flag = 1;
  835.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  836.   CABAC_TRACE;
  837. }
  840. /*!
  841.  ****************************************************************************
  842.  * brief
  843.  *    This function is used to arithmetically encode the chroma
  844.  *    intra prediction mode of an 8x8 block
  845.  ****************************************************************************
  846.  */
  847. void writeCIPredMode_CABAC(SyntaxElement *se, DataPartition *dp)
  848. {
  849.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  850.   int curr_len = arienco_bits_written(eep_dp);
  851.   TextureInfoContexts *ctx     = img->currentSlice->tex_ctx;
  852.   Macroblock          *currMB  = &img->mb_data[img->current_mb_nr];
  853.   int                 act_sym  = se->value1;
  854.   
  855.   Macroblock          *MbUp   = currMB->mb_available_up;
  856.   Macroblock          *MbLeft = currMB->mb_available_left;
  858.   int b = (MbUp   != NULL) ? (((MbUp->c_ipred_mode != 0) && (MbUp->mb_type != IPCM)) ? 1 : 0) : 0;
  859.   int a = (MbLeft != NULL) ? (((MbLeft->c_ipred_mode != 0) && (MbLeft->mb_type != IPCM)) ? 1 : 0) : 0;
  861.   int act_ctx = a + b;
  863.   if (act_sym==0)
  864.     biari_encode_symbol(eep_dp, 0, ctx->cipr_contexts + act_ctx );
  865.   else
  866.   {
  867.     biari_encode_symbol(eep_dp, 1, ctx->cipr_contexts + act_ctx );
  868.     unary_bin_max_encode(eep_dp,(unsigned int) (act_sym-1),ctx->cipr_contexts+3,0,2);
  869.   }
  871.   dp->bitstream->write_flag = 1;
  872.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  873.   CABAC_TRACE;
  874. }
  877. /*!
  878.  ****************************************************************************
  879.  * brief
  880.  *    This function is used to arithmetically encode the coded
  881.  *    block pattern of an 8x8 block
  882.  ****************************************************************************
  883.  */
  884. void writeCBP_BIT_CABAC (Macroblock* currMB, int b8, int bit, int cbp, int inter, EncodingEnvironmentPtr eep_dp, TextureInfoContexts *ctx)
  885. {
  886.   PixelPos block_a;
  887.   int a = 0, b = 0;
  889.   int mb_x=(b8 & 0x01)<<1;
  890.   int mb_y=(b8 >> 1)<<1;
  892.   if (mb_y == 0)
  893.   {
  894.     if (!((currMB->mb_available_up == NULL) || ((currMB->mb_available_up)->mb_type==IPCM)))
  895.     {
  896.       b = (( ((currMB->mb_available_up)->cbp & (1<<(2+(mb_x>>1)))) == 0) ? 1 : 0);   //VG-ADD
  897.     }
  899.   }
  900.   else
  901.     b = ( ((cbp & (1<<(mb_x >> 1))) == 0) ? 1: 0);
  903.   if (mb_x == 0)
  904.   {
  905.     get4x4Neighbour(currMB, (mb_x << 2) - 1, (mb_y << 2), img->mb_size[IS_LUMA], &block_a);
  907.     if (block_a.available && (!(img->mb_data[block_a.mb_addr].mb_type==IPCM)))
  908.     {
  909.       a = (( (img->mb_data[block_a.mb_addr].cbp & (1<<(2*(block_a.y>>1)+1))) == 0) ? 1 : 0); //VG-ADD
  910.     }    
  911.   }
  912.   else
  913.     a = ( ((cbp & (1<<mb_y)) == 0) ? 1: 0);
  915.   //===== WRITE BIT =====
  916.   biari_encode_symbol (eep_dp, (signed short) bit, ctx->cbp_contexts[0] + a+2*b);
  917. }
  919. /*!
  920. ****************************************************************************
  921. * brief
  922. *    This function is used to arithmetically encode the coded
  923. *    block pattern of a macroblock
  924. ****************************************************************************
  925. */
  926. void writeCBP_CABAC(Macroblock *currMB, SyntaxElement *se, DataPartition *dp)
  927. {
  928.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  929.   int curr_len = arienco_bits_written(eep_dp);
  930.   TextureInfoContexts *ctx = img->currentSlice->tex_ctx;
  932.   int a0 = 0, a1 = 0, b0 = 0, b1 = 0;
  933.   int curr_cbp_ctx, curr_cbp_idx;
  934.   int cbp = se->value1; // symbol to encode
  935.   int cbp_bit;
  936.   int b8;
  938.   for (b8=0; b8<4; b8++)
  939.   {
  940.     curr_cbp_idx = (currMB->b8mode[b8] == IBLOCK ? 0 : 1);
  941.     writeCBP_BIT_CABAC (currMB, b8, cbp&(1<<b8), cbp, curr_cbp_idx, eep_dp, ctx);
  942.   }
  944.   if ((img->yuv_format != YUV400) && (img->yuv_format != YUV444) )
  945.   {
  946.     // coding of chroma part
  947.     if (currMB->mb_available_up != NULL)
  948.     {
  949.       if((currMB->mb_available_up)->mb_type == IPCM || ((currMB->mb_available_up)->cbp > 15))
  950.         b0 = 2;
  951.     }
  953.     if (currMB->mb_available_left != NULL)
  954.     {
  955.       if((currMB->mb_available_left)->mb_type==IPCM || ((currMB->mb_available_left)->cbp > 15))
  956.         a0 = 1;
  957.     }
  959.     curr_cbp_ctx = a0 + b0;
  960.     cbp_bit = (cbp > 15 ) ? 1 : 0;
  961.     biari_encode_symbol(eep_dp, (signed short) cbp_bit, ctx->cbp_contexts[1] + curr_cbp_ctx );
  963.     if (cbp > 15)
  964.     {
  965.       if (currMB->mb_available_up != NULL)
  966.       {
  967.         if((currMB->mb_available_up)->mb_type==IPCM || 
  968.           (((currMB->mb_available_up)->cbp > 15) && ( ((currMB->mb_available_up)->cbp >> 4) == 2)))
  969.           b1 = 2;
  970.       }
  972.       if (currMB->mb_available_left != NULL)
  973.       {
  974.         if((currMB->mb_available_left)->mb_type==IPCM || 
  975.           (((currMB->mb_available_left)->cbp > 15) && ( ((currMB->mb_available_left)->cbp >> 4) == 2)))
  976.           a1 = 1;
  977.       }
  979.       curr_cbp_ctx = a1 + b1;
  980.       cbp_bit = ((cbp>>4) == 2) ? 1 : 0;
  981.       biari_encode_symbol(eep_dp, (signed short) cbp_bit, ctx->cbp_contexts[2] + curr_cbp_ctx );
  982.     }
  983.   }
  985.   dp->bitstream->write_flag = 1;
  986.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  987.   CABAC_TRACE;
  988. }
  990. const int maxpos       [] = {15, 14, 63, 31, 31, 15,  3, 14,  7, 15, 15, 14, 63, 31, 31, 15, 15, 14, 63, 31, 31, 15};
  991. const int c1isdc       [] = { 1,  0,  1,  1,  1,  1,  1,  0,  1,  1,  1,  0,  1,  1,  1,  1,  1,  0,  1,  1,  1,  1};
  993. const int type2ctx_bcbp[] = { 0,  1,  2,  3,  3,  4,  5,  6,  5,  5, 10, 11, 12, 13, 13, 14, 16, 17, 18, 19, 19, 20};
  994. const int type2ctx_map [] = { 0,  1,  2,  3,  4,  5,  6,  7,  6,  6, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21}; // 8
  995. const int type2ctx_last[] = { 0,  1,  2,  3,  4,  5,  6,  7,  6,  6, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21}; // 8
  996. const int type2ctx_one [] = { 0,  1,  2,  3,  3,  4,  5,  6,  5,  5, 10, 11, 12, 13, 13, 14, 16, 17, 18, 19, 19, 20}; // 7
  997. const int type2ctx_abs [] = { 0,  1,  2,  3,  3,  4,  5,  6,  5,  5, 10, 11, 12, 13, 13, 14, 16, 17, 18, 19, 19, 20}; // 7
  998. const int max_c2       [] = { 4,  4,  4,  4,  4,  4,  3,  4,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4}; // 9
  1000. /*!
  1001.  ****************************************************************************
  1002.  * brief
  1003.  *    Write CBP4-BIT
  1004.  ****************************************************************************
  1005.  */
  1006. void write_and_store_CBP_block_bit (Macroblock* currMB, EncodingEnvironmentPtr eep_dp, int type, int cbp_bit, TextureInfoContexts*  tex_ctx)
  1007. {
  1008. #define BIT_SET(x,n)  ((int)(((x)&((int64)1<<(n)))>>(n)))
  1010.   int y_ac        = (type==LUMA_16AC || type==LUMA_8x8 || type==LUMA_8x4 || type==LUMA_4x8 || type==LUMA_4x4
  1011.                      || type==CB_16AC || type==CB_8x8 || type==CB_8x4 || type==CB_4x8 || type==CB_4x4
  1012.                      || type==CR_16AC || type==CR_8x8 || type==CR_8x4 || type==CR_4x8 || type==CR_4x4);
  1013.   int y_dc        = (type==LUMA_16DC || type==CB_16DC || type==CR_16DC); 
  1014.   int u_ac        = (type==CHROMA_AC && !img->is_v_block);
  1015.   int v_ac        = (type==CHROMA_AC &&  img->is_v_block);
  1016.   int chroma_dc   = (type==CHROMA_DC || type==CHROMA_DC_2x4 || type==CHROMA_DC_4x4);
  1017.   int u_dc        = (chroma_dc && !img->is_v_block);
  1018.   int v_dc        = (chroma_dc &&  img->is_v_block);
  1019.   int j           = ((y_ac || u_ac || v_ac ? img->subblock_y : 0) << 2);
  1020.   int i           =  (y_ac || u_ac || v_ac ? img->subblock_x : 0);
  1021.   int bit         =  (y_dc ? 0 : y_ac ? 1 : u_dc ? 17 : v_dc ? 18 : u_ac ? 19 : 23);
  1022.   int default_bit =  (img->is_intra_block ? 1 : 0);
  1023.   int upper_bit   = default_bit;
  1024.   int left_bit    = default_bit;
  1025.   int ctx;
  1027.   int bit_pos_a   = 0;
  1028.   int bit_pos_b   = 0;
  1030.   PixelPos block_a, block_b;
  1032.   if (y_ac || y_dc)
  1033.   {
  1034.     get4x4Neighbour(currMB, (i << 2) - 1, j   , img->mb_size[IS_LUMA], &block_a);
  1035.     get4x4Neighbour(currMB, (i << 2),     j -1, img->mb_size[IS_LUMA], &block_b);
  1036.     if (y_ac)
  1037.     {
  1038.       if (block_a.available)
  1039.         bit_pos_a = 4*block_a.y + block_a.x;
  1040.       if (block_b.available)
  1041.         bit_pos_b = 4*block_b.y + block_b.x;
  1042.     }
  1043.   }
  1044.   else
  1045.   {
  1046.     get4x4Neighbour(currMB, (i << 2) - 1, j    , img->mb_size[IS_CHROMA], &block_a);
  1047.     get4x4Neighbour(currMB, (i << 2),     j - 1, img->mb_size[IS_CHROMA], &block_b);
  1048.     if (u_ac||v_ac)
  1049.     {
  1050.       if (block_a.available)
  1051.         bit_pos_a = (block_a.y << 2) + block_a.x;
  1052.       if (block_b.available)
  1053.         bit_pos_b = (block_b.y << 2) + block_b.x;
  1054.     }
  1055.   }
  1057.   bit = (y_dc ? 0 : y_ac ? 1 + j + i : u_dc ? 17 : v_dc ? 18 : u_ac ? 19 + j + i : 35 + j + i);
  1058.   //--- set bits for current block ---
  1059.   if (cbp_bit)
  1060.   {    
  1061.     if (type==LUMA_8x8)
  1062.     {
  1063.       currMB->cbp_bits[0] |= ((int64) 0x33 << bit);
  1065.       if (enc_picture->chroma_format_idc==YUV444)
  1066.       {
  1067.         currMB->cbp_bits_8x8[0] |= ((int64) 0x33 << bit);
  1068.       }
  1069.     }
  1070.     else if (type==CB_8x8)
  1071.     {
  1072.       currMB->cbp_bits_8x8[1] |= ((int64) 0x33 << bit);
  1073.       currMB->cbp_bits[1]     |= ((int64) 0x33 << bit);
  1074.     }
  1075.     else if (type==CR_8x8)
  1076.     {
  1077.       currMB->cbp_bits_8x8[2] |= ((int64) 0x33 << bit);
  1078.       currMB->cbp_bits[2]     |= ((int64) 0x33 << bit);
  1079.     }
  1080.     else if (type==LUMA_8x4)
  1081.     {      
  1082.       currMB->cbp_bits[0]     |= ((int64) 0x03 << bit);
  1083.     }
  1084.     else if (type==LUMA_4x8)
  1085.     {      
  1086.       currMB->cbp_bits[0]     |= ((int64) 0x11 << bit);
  1087.     }
  1088.     else if (type==CB_8x4)
  1089.     {
  1090.       currMB->cbp_bits[1]     |= ((int64) 0x03 << bit);
  1091.     }
  1092.     else if (type==CR_8x4)
  1093.     {
  1094.       currMB->cbp_bits[2]     |= ((int64) 0x03 << bit);
  1095.     }
  1096.     else if (type==CB_4x8)
  1097.     {
  1098.       currMB->cbp_bits[1]     |= ((int64) 0x11 << bit);
  1099.     }
  1100.     else if (type==CR_4x8)
  1101.     {
  1102.       currMB->cbp_bits[2]     |= ((int64) 0x11 << bit);
  1103.     }
  1104.     else if ((type==CB_4x4)||(type==CB_16AC)||(type==CB_16DC))
  1105.     {
  1106.       currMB->cbp_bits[1]     |= ((int64) 0x01 << bit);
  1107.     }
  1108.     else if ((type == CR_4x4)||(type == CR_16AC)||(type == CR_16DC))
  1109.     {
  1110.       currMB->cbp_bits[2]     |= ((int64) 0x01 << bit);
  1111.     }
  1112.     else
  1113.     {
  1114.       currMB->cbp_bits[0]     |= ((int64) 0x01 << bit);
  1115.     }
  1116.   }
  1118.   bit = (y_dc ? 0 : y_ac ? 1 : u_dc ? 17 : v_dc ? 18 : u_ac ? 19 : 35);
  1120.   if (enc_picture->chroma_format_idc!=YUV444)
  1121.   {
  1122.     if (type!=LUMA_8x8)
  1123.     {
  1124.       if (block_b.available)
  1125.       {
  1126.         if(img->mb_data[block_b.mb_addr].mb_type==IPCM)
  1127.           upper_bit = 1;
  1128.         else
  1129.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[0],bit+bit_pos_b);
  1130.       }
  1133.       if (block_a.available)
  1134.       {
  1135.         if(img->mb_data[block_a.mb_addr].mb_type == IPCM)
  1136.           left_bit = 1;
  1137.         else
  1138.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[0], bit + bit_pos_a);
  1139.       }
  1141.       ctx = 2 * upper_bit + left_bit;
  1143.       //===== encode symbol =====
  1144.       biari_encode_symbol (eep_dp, (short)cbp_bit, tex_ctx->bcbp_contexts[type2ctx_bcbp[type]] + ctx);
  1145.     }
  1146.   }
  1147.   else if( IS_INDEPENDENT(params) )
  1148.   {
  1149.     if (type!=LUMA_8x8)
  1150.     {
  1151.       if (block_b.available)
  1152.       {
  1153.         if(img->mb_data[block_b.mb_addr].mb_type==IPCM)
  1154.           upper_bit = 1;
  1155.         else
  1156.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[0],bit+bit_pos_b);
  1157.       }
  1160.       if (block_a.available)
  1161.       {
  1162.         if(img->mb_data[block_a.mb_addr].mb_type == IPCM)
  1163.           left_bit = 1;
  1164.         else
  1165.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[0], bit + bit_pos_a);
  1166.       }
  1168.       ctx = 2 * upper_bit + left_bit;
  1170.       //===== encode symbol =====
  1171.       biari_encode_symbol (eep_dp, (short)cbp_bit, tex_ctx->bcbp_contexts[type2ctx_bcbp[type]] + ctx);
  1172.     }
  1173.   }
  1174.   else 
  1175.   {
  1176.     if (block_b.available)
  1177.     {
  1178.       if(img->mb_data[block_b.mb_addr].mb_type == IPCM)
  1179.         upper_bit=1;
  1180.       else
  1181.       {
  1182.         if(type==LUMA_8x8)
  1183.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits_8x8[0], bit + bit_pos_b);
  1184.         else if (type==CB_8x8)
  1185.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits_8x8[1], bit + bit_pos_b);
  1186.         else if (type==CR_8x8)
  1187.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits_8x8[2], bit + bit_pos_b);
  1188.         else if ((type==CB_4x4)||(type==CB_4x8)||(type==CB_8x4)||(type==CB_16AC)||(type==CB_16DC))
  1189.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[1], bit + bit_pos_b);
  1190.         else if ((type==CR_4x4)||(type==CR_4x8)||(type==CR_8x4)||(type==CR_16AC)||(type==CR_16DC))
  1191.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[2], bit + bit_pos_b);
  1192.         else
  1193.           upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits[0], bit + bit_pos_b);
  1194.       }
  1195.     }
  1197.     if (block_a.available)
  1198.     {
  1199.       if(img->mb_data[block_a.mb_addr].mb_type==IPCM)
  1200.         left_bit = 1;
  1201.       else
  1202.       {
  1203.         if(type==LUMA_8x8)
  1204.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits_8x8[0],bit + bit_pos_a);
  1205.         else if (type==CB_8x8)
  1206.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits_8x8[1],bit + bit_pos_a);
  1207.         else if (type==CR_8x8)
  1208.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits_8x8[2],bit + bit_pos_a);
  1209.         else if ((type==CB_4x4)||(type==CB_4x8)||(type==CB_8x4)||(type==CB_16AC)||(type==CB_16DC))
  1210.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[1],bit + bit_pos_a);
  1211.         else if ((type==CR_4x4)||(type==CR_4x8)||(type==CR_8x4)||(type==CR_16AC)||(type==CR_16DC))
  1212.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[2],bit + bit_pos_a);
  1213.         else
  1214.           left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits[0],bit + bit_pos_a);
  1215.       }
  1216.     }
  1218.     ctx = 2*upper_bit+left_bit;
  1220.     //===== encode symbol =====
  1221.     biari_encode_symbol (eep_dp, (short)cbp_bit, tex_ctx->bcbp_contexts[type2ctx_bcbp[type]]+ctx);
  1222.   }
  1223. }
  1228. //===== position -> ctx for MAP =====
  1229. //--- zig-zag scan ----
  1230. const int  pos2ctx_map8x8 [] = { 0,  1,  2,  3,  4,  5,  5,  4,  4,  3,  3,  4,  4,  4,  5,  5,
  1231.                                         4,  4,  4,  4,  3,  3,  6,  7,  7,  7,  8,  9, 10,  9,  8,  7,
  1232.                                         7,  6, 11, 12, 13, 11,  6,  7,  8,  9, 14, 10,  9,  8,  6, 11,
  1233.                                        12, 13, 11,  6,  9, 14, 10,  9, 11, 12, 13, 11 ,14, 10, 12, 14}; // 15 CTX
  1234. const int  pos2ctx_map8x4 [] = { 0,  1,  2,  3,  4,  5,  7,  8,  9, 10, 11,  9,  8,  6,  7,  8,
  1235.                                         9, 10, 11,  9,  8,  6, 12,  8,  9, 10, 11,  9, 13, 13, 14, 14}; // 15 CTX
  1236. const int  pos2ctx_map4x4 [] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 14}; // 15 CTX
  1237. const int  pos2ctx_map2x4c[] = { 0,  0,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2}; // 15 CTX
  1238. const int  pos2ctx_map4x4c[] = { 0,  0,  0,  0,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2}; // 15 CTX
  1239. const int* pos2ctx_map    [] = {pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map8x8, pos2ctx_map8x4,
  1240.                                        pos2ctx_map8x4, pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map4x4,
  1241.                                        pos2ctx_map2x4c, pos2ctx_map4x4c, 
  1243.                                        pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map8x8,pos2ctx_map8x4,
  1244.                                        pos2ctx_map8x4, pos2ctx_map4x4,  //Cb component
  1245.                                        pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map8x8,pos2ctx_map8x4,
  1246.                                        pos2ctx_map8x4,pos2ctx_map4x4};  //Cr component
  1248. //--- interlace scan ----
  1249. //Taken from ABT
  1250. static const int  pos2ctx_map8x8i[] = { 0,  1,  1,  2,  2,  3,  3,  4,  5,  6,  7,  7,  7,  8,  4,  5,
  1251.                                         6,  9, 10, 10,  8, 11, 12, 11,  9,  9, 10, 10,  8, 11, 12, 11,
  1252.                                         9,  9, 10, 10,  8, 11, 12, 11,  9,  9, 10, 10,  8, 13, 13,  9,
  1253.                                         9, 10, 10,  8, 13, 13,  9,  9, 10, 10, 14, 14, 14, 14, 14, 14}; // 15 CTX
  1255. static const int  pos2ctx_map8x4i[] = { 0,  1,  2,  3,  4,  5,  6,  3,  4,  5,  6,  3,  4,  7,  6,  8,
  1256.                                         9,  7,  6,  8,  9, 10, 11, 12, 12, 10, 11, 13, 13, 14, 14, 14}; // 15 CTX
  1257. static const int  pos2ctx_map4x8i[] = { 0,  1,  1,  1,  2,  3,  3,  4,  4,  4,  5,  6,  2,  7,  7,  8,
  1258.                                         8,  8,  5,  6,  9, 10, 10, 11, 11, 11, 12, 13, 13, 14, 14, 14}; // 15 CTX
  1259. static const int* pos2ctx_map_int[] = {pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map8x8i,pos2ctx_map8x4i,
  1260.                                        pos2ctx_map4x8i,pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map4x4,
  1261.                                        pos2ctx_map2x4c, pos2ctx_map4x4c,
  1262. //444_TEMP_NOTE: the followings are addded for the 4:4:4 common mode};
  1263.                                         pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map8x8i,pos2ctx_map8x4i,
  1264.                                         pos2ctx_map8x4i,pos2ctx_map4x4, //Cb component
  1265.                                         pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map8x8i,pos2ctx_map8x4i,
  1266.                                         pos2ctx_map8x4i,pos2ctx_map4x4};  //Cr component}
  1269. //===== position -> ctx for LAST =====
  1270. const int  pos2ctx_last8x8 [] = { 0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  1271.                                          2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
  1272.                                          3,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  4,  4,
  1273.                                          5,  5,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8}; //  9 CTX
  1274. const int  pos2ctx_last8x4 [] = { 0,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,
  1275.                                          3,  3,  3,  3,  4,  4,  4,  4,  5,  5,  6,  6,  7,  7,  8,  8}; //  9 CTX
  1276. const int  pos2ctx_last4x4 [] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15}; // 15 CTX
  1277. const int  pos2ctx_last2x4c[] = { 0,  0,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2}; // 15 CTX
  1278. const int  pos2ctx_last4x4c[] = { 0,  0,  0,  0,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2}; // 15 CTX
  1279. const int* pos2ctx_last    [] = {pos2ctx_last4x4, pos2ctx_last4x4, pos2ctx_last8x8, pos2ctx_last8x4,
  1280.                                         pos2ctx_last8x4, pos2ctx_last4x4, pos2ctx_last4x4, pos2ctx_last4x4,
  1281.                                         pos2ctx_last2x4c, pos2ctx_last4x4c,
  1282.                                         pos2ctx_last4x4, pos2ctx_last4x4, pos2ctx_last8x8,pos2ctx_last8x4,
  1283.                                         pos2ctx_last8x4, pos2ctx_last4x4,  //Cb component
  1284.                                         pos2ctx_last4x4, pos2ctx_last4x4, pos2ctx_last8x8,pos2ctx_last8x4,
  1285.                                         pos2ctx_last8x4, pos2ctx_last4x4}; //Cr component
  1290. /*!
  1291. ****************************************************************************
  1292. * brief
  1293. *    Write Significance MAP
  1294. ****************************************************************************
  1295. */
  1296. void write_significance_map (Macroblock* currMB, EncodingEnvironmentPtr eep_dp, int type, int coeff[], int coeff_ctr, TextureInfoContexts*  tex_ctx)
  1297. {
  1298.   int   k;
  1299.   unsigned short sig, last;
  1300.   int   k0 = 0;
  1301.   int   k1 = maxpos[type];
  1303. #if ENABLE_FIELD_CTX
  1304.   int               fld       = ( img->structure!=FRAME || currMB->mb_field );
  1305. #else
  1306.   int               fld       = 0;
  1307. #endif
  1308.   BiContextTypePtr  map_ctx   = tex_ctx->map_contexts [fld][type2ctx_map [type]];
  1309.   BiContextTypePtr  last_ctx  = tex_ctx->last_contexts[fld][type2ctx_last[type]];
  1312.   if (!c1isdc[type])
  1313.   {
  1314.     k0++; k1++; coeff--;
  1315.   }
  1317.   if (!fld)
  1318.   {
  1319.     for (k=k0; k<k1; k++) // if last coeff is reached, it has to be significant
  1320.     {
  1321.       sig   = (coeff[k] != 0);
  1322.       biari_encode_symbol  (eep_dp, sig,  map_ctx + pos2ctx_map  [type][k]);
  1323.       if (sig)
  1324.       {
  1325.         last = (--coeff_ctr == 0);
  1327.         biari_encode_symbol(eep_dp, last, last_ctx + pos2ctx_last[type][k]);
  1328.         if (last) 
  1329.           return;
  1330.       }
  1331.     }
  1332.     return;
  1333.   }
  1334.   else
  1335.   {
  1336.     for (k=k0; k<k1; k++) // if last coeff is reached, it has to be significant
  1337.     {
  1338.       sig   = (coeff[k] != 0);
  1340.       biari_encode_symbol  (eep_dp, sig,  map_ctx + pos2ctx_map_int [type][k]);
  1341.       if (sig)
  1342.       {
  1343.         last = (--coeff_ctr == 0);
  1345.         biari_encode_symbol(eep_dp, last, last_ctx + pos2ctx_last[type][k]);
  1346.         if (last) 
  1347.           return;
  1348.       }
  1349.     }
  1350.   }
  1351. }
  1354. /*!
  1355.  ****************************************************************************
  1356.  * brief
  1357.  *    Write Levels
  1358.  ****************************************************************************
  1359.  */
  1360. void write_significant_coefficients (Macroblock* currMB, EncodingEnvironmentPtr eep_dp, int type, int coeff[], TextureInfoContexts*  tex_ctx)
  1361. {
  1362.   int   i;
  1363.   int   absLevel;
  1364.   int   ctx;
  1365.   short sign;
  1366.   short greater_one;
  1367.   int   c1 = 1;
  1368.   int   c2 = 0;
  1369.   BiContextType *one_contexts = tex_ctx->one_contexts[type2ctx_one[type]];
  1370.   BiContextType *abs_contexts = tex_ctx->abs_contexts[type2ctx_abs[type]];
  1372.   for (i=maxpos[type]; i>=0; i--)
  1373.   {
  1374.     if (coeff[i]!=0)
  1375.     {
  1376.       if (coeff[i] > 0)
  1377.       {
  1378.         absLevel =  coeff[i];  
  1379.         sign = 0;
  1380.       }
  1381.       else            
  1382.       {
  1383.         absLevel = -coeff[i];  
  1384.         sign = 1;
  1385.       }
  1387.       greater_one = (absLevel > 1);
  1389.       //--- if coefficient is one ---
  1390.       ctx = imin(c1, 4);
  1391.       biari_encode_symbol (eep_dp, greater_one, one_contexts + ctx);
  1393.       if (greater_one)
  1394.       {
  1395.         ctx = imin(c2++, max_c2[type]);
  1396.         unary_exp_golomb_level_encode(eep_dp, absLevel - 2, abs_contexts + ctx);
  1397.         c1 = 0;
  1398.       }
  1399.       else if (c1)
  1400.       {
  1401.         c1++;
  1402.       }
  1403.       biari_encode_symbol_eq_prob (eep_dp, sign);
  1404.     }
  1405.   }
  1406. }
  1410. /*!
  1411.  ****************************************************************************
  1412.  * brief
  1413.  *    Write Block-Transform Coefficients
  1414.  ****************************************************************************
  1415.  */
  1416. void writeRunLevel_CABAC (Macroblock* currMB, SyntaxElement *se, DataPartition *dp)
  1417. {
  1418.   EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac);
  1419.   int curr_len = arienco_bits_written(eep_dp);
  1420.   static int  coeff[64];
  1421.   static int  coeff_ctr = 0;
  1422.   static int  pos       = 0;
  1424.   //--- accumulate run-level information ---
  1425.   if (se->value1 != 0)
  1426.   {
  1427.     pos += se->value2;
  1428.     coeff[pos++] = se->value1;
  1429.     coeff_ctr++;
  1430.   }
  1431.   else
  1432.   {
  1433.     TextureInfoContexts *tex_ctx = img->currentSlice->tex_ctx;
  1434.     //===== encode CBP-BIT =====
  1435.     if (coeff_ctr > 0)
  1436.     {
  1437.       write_and_store_CBP_block_bit  (currMB, eep_dp, se->context, 1, tex_ctx);
  1438.       //===== encode significance map =====
  1439.       write_significance_map         (currMB, eep_dp, se->context, coeff, coeff_ctr, tex_ctx);
  1440.       //===== encode significant coefficients =====
  1441.       write_significant_coefficients (currMB, eep_dp, se->context, coeff, tex_ctx);
  1442.     }
  1443.     else
  1444.       write_and_store_CBP_block_bit  (currMB, eep_dp, se->context, 0, tex_ctx);
  1446.     //--- reset counters ---
  1447.     pos = coeff_ctr = 0;
  1448.     memset(coeff, 0 , 64 * sizeof(int));
  1449.   }
  1451.   dp->bitstream->write_flag = 1;
  1452.   se->len = (arienco_bits_written(eep_dp) - curr_len);
  1453.   CABAC_TRACE;
  1454. }
  1459. /*!
  1460.  ************************************************************************
  1461.  * brief
  1462.  *    Unary binarization and encoding of a symbol by using
  1463.  *    one or two distinct models for the first two and all
  1464.  *    remaining bins
  1465. *
  1466. ************************************************************************/
  1467. void unary_bin_encode(EncodingEnvironmentPtr eep_dp,
  1468.                       unsigned int symbol,
  1469.                       BiContextTypePtr ctx,
  1470.                       int ctx_offset)
  1471. {
  1472.   
  1473.   if (symbol==0)
  1474.   {
  1475.     biari_encode_symbol(eep_dp, 0, ctx );
  1476.     return;
  1477.   }
  1478.   else
  1479.   {
  1480.     biari_encode_symbol(eep_dp, 1, ctx );
  1481.     ctx += ctx_offset;
  1482.     while ((--symbol) > 0)
  1483.       biari_encode_symbol(eep_dp, 1, ctx);
  1484.     biari_encode_symbol(eep_dp, 0, ctx);
  1485.   }
  1486. }
  1488. /*!
  1489.  ************************************************************************
  1490.  * brief
  1491.  *    Unary binarization and encoding of a symbol by using
  1492.  *    one or two distinct models for the first two and all
  1493.  *    remaining bins; no terminating "0" for max_symbol
  1494.  *    (finite symbol alphabet)
  1495.  ************************************************************************
  1496.  */
  1497. void unary_bin_max_encode(EncodingEnvironmentPtr eep_dp,
  1498.                           unsigned int symbol,
  1499.                           BiContextTypePtr ctx,
  1500.                           int ctx_offset,
  1501.                           unsigned int max_symbol)
  1502. {
  1503.   if (symbol==0)
  1504.   {
  1505.     biari_encode_symbol(eep_dp, 0, ctx );
  1506.     return;
  1507.   }
  1508.   else
  1509.   {
  1510.     unsigned int l = symbol;
  1511.     biari_encode_symbol(eep_dp, 1, ctx );
  1512.     
  1513.     ctx += ctx_offset;
  1514.     while ((--l)>0)
  1515.       biari_encode_symbol(eep_dp, 1, ctx);
  1516.     if (symbol < max_symbol)
  1517.       biari_encode_symbol(eep_dp, 0, ctx);
  1518.   }
  1519. }
  1523. /*!
  1524.  ************************************************************************
  1525.  * brief
  1526.  *    Exp Golomb binarization and encoding
  1527.  ************************************************************************
  1528.  */
  1529. void exp_golomb_encode_eq_prob( EncodingEnvironmentPtr eep_dp,
  1530.                                 unsigned int symbol,
  1531.                                 int k)
  1532. {
  1533.   while(1)
  1534.   {
  1535.     if (symbol >= (unsigned int)(1<<k))
  1536.     {
  1537.       biari_encode_symbol_eq_prob(eep_dp, 1);   //first unary part
  1538.       symbol = symbol - (1<<k);
  1539.       k++;
  1540.     }
  1541.     else
  1542.     {
  1543.       biari_encode_symbol_eq_prob(eep_dp, 0);   //now terminated zero of unary part
  1544.       while (k--)                               //next binary part
  1545.         biari_encode_symbol_eq_prob(eep_dp, (signed short)((symbol>>k)&1));
  1546.       break;
  1547.     }
  1548.   }
  1549. }
  1551. /*!
  1552.  ************************************************************************
  1553.  * brief
  1554.  *    Exp-Golomb for Level Encoding
  1555. *
  1556. ************************************************************************/
  1557. void unary_exp_golomb_level_encode( EncodingEnvironmentPtr eep_dp,
  1558.                                     unsigned int symbol,
  1559.                                     BiContextTypePtr ctx)
  1560. {
  1561.   if (symbol==0)
  1562.   {
  1563.     biari_encode_symbol(eep_dp, 0, ctx );
  1564.     return;
  1565.   }
  1566.   else
  1567.   {
  1568.     unsigned int exp_start = 13; // 15-2 : 0,1 level decision always sent
  1569.     unsigned int l=symbol;
  1570.     unsigned int k = 1;
  1572.     biari_encode_symbol(eep_dp, 1, ctx );
  1573.     while (((--l)>0) && (++k <= exp_start))
  1574.       biari_encode_symbol(eep_dp, 1, ctx);
  1575.     if (symbol < exp_start) 
  1576.       biari_encode_symbol(eep_dp, 0, ctx);
  1577.     else 
  1578.       exp_golomb_encode_eq_prob(eep_dp,symbol - exp_start, 0);
  1579.   }
  1580. }
  1584. /*!
  1585.  ************************************************************************
  1586.  * brief
  1587.  *    Exp-Golomb for MV Encoding
  1588. *
  1589. ************************************************************************/
  1590. void unary_exp_golomb_mv_encode(EncodingEnvironmentPtr eep_dp,
  1591.                                 unsigned int symbol,
  1592.                                 BiContextTypePtr ctx,
  1593.                                 unsigned int max_bin)
  1594. {  
  1595.   if (symbol==0)
  1596.   {
  1597.     biari_encode_symbol(eep_dp, 0, ctx );
  1598.     return;
  1599.   }
  1600.   else
  1601.   {
  1602.     unsigned int bin=1;
  1603.     unsigned int exp_start = 8; // 9-1 : 0 mvd decision always sent
  1604.     unsigned int l = symbol, k = 1;
  1605.     biari_encode_symbol(eep_dp, 1, ctx++ );
  1606.     
  1607.     while (((--l)>0) && (++k <= exp_start))
  1608.     {
  1609.       biari_encode_symbol(eep_dp, 1, ctx  );
  1610.       if ((++bin) == 2) 
  1611.         ctx++;
  1612.       if (bin == max_bin) 
  1613.         ctx++;
  1614.     }
  1615.     if (symbol < exp_start) 
  1616.       biari_encode_symbol(eep_dp, 0, ctx);
  1617.     else 
  1618.       exp_golomb_encode_eq_prob(eep_dp, symbol - exp_start, 3);
  1619.   }
  1620. }