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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
cavlc.c
资源名称：h264src.zip　[点击查看]
上传用户：sunbaby
上传日期：2013-05-31
资源大小：242k
文件大小：34k
源码类别：

mpeg/mp3

开发平台：

Visual C++

cavlc.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  *  T264 AVC CODEC
  4.  *
  5.  *  Copyright(C) 2004-2005 llcc <lcgate1@yahoo.com.cn>
  6.  *               2004-2005 visionany <visionany@yahoo.com.cn>
  7.  *
  8.  *  This program is free software ; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation ; either version 2 of the License, or
  11.  *  (at your option) any later version.
  12.  *
  13.  *  This program is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with this program ; if not, write to the Free Software
  20.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21.  *
  22.  ****************************************************************************/
  24.  /*****************************************************************************
  25.  * cavlc.c: from x 264
  26.  *****************************************************************************/
  29. //#include <stdlib.h>
  30. //#include <string.h>
  31. //#include <stdint.h>
  33. #include <stdio.h>
  35. #include "T264.h"
  36. #include "vlc.h"
  37. #include "bitstream.h"
  38. #include "inter.h"
  39. #include <assert.h>
  41. static const uint8_t intra4x4_cbp_to_golomb[48]=
  42. {
  43.   3, 29, 30, 17, 31, 18, 37,  8, 32, 38, 19,  9, 20, 10, 11,  2,
  44.  16, 33, 34, 21, 35, 22, 39,  4, 36, 40, 23,  5, 24,  6,  7,  1,
  45.  41, 42, 43, 25, 44, 26, 46, 12, 45, 47, 27, 13, 28, 14, 15,  0
  46. };
  47. static const uint8_t inter_cbp_to_golomb[48]=
  48. {
  49.   0,  2,  3,  7,  4,  8, 17, 13,  5, 18,  9, 14, 10, 15, 16, 11,
  50.   1, 32, 33, 36, 34, 37, 44, 40, 35, 45, 38, 41, 39, 42, 43, 19,
  51.   6, 24, 25, 20, 26, 21, 46, 28, 27, 47, 22, 29, 23, 30, 31, 12
  52. };
  54. /*
  55. static const uint8_t block_idx_x[16] =
  56. {
  57.     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
  58. };
  59. static const uint8_t block_idx_y[16] =
  60. {
  61.     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
  62. };
  63. static const uint8_t block_idx_xy[4][4] =
  64. {
  65.     { 0, 2, 8,  10},
  66.     { 1, 3, 9,  11},
  67.     { 4, 6, 12, 14},
  68.     { 5, 7, 13, 15}
  69. };
  70. */
  72. #define IS_DIRECT(x) (x == B_DIRECT_16x16 || x == B_DIRECT_8x8)
  73. #define BLOCK_INDEX_CHROMA_DC   (-1)
  74. #define BLOCK_INDEX_LUMA_DC     (-2)
  76. static __inline void eg_write_vlc(bs_t* bs, vlc_t v)
  77. {
  78. eg_write_direct(bs, v.i_bits & ((uint32_t)~0 >> (uint32_t)(32 - v.i_size)), v.i_size);
  79. }
  81. int8_t
  82. T264_mb_predict_intra4x4_mode(T264_t *t, int32_t idx)
  83. {
  84. int32_t x, y;
  85. int8_t nA, nB, pred_blk;
  87.     x = luma_inverse_x[idx];
  88.     y = luma_inverse_y[idx];
  90.     nA = t->mb.i4x4_pred_mode_ref[IPM_LUMA + x + y * 8 - 1];
  91.     nB = t->mb.i4x4_pred_mode_ref[IPM_LUMA + x + y * 8 - 8];
  93.     pred_blk  = T264_MIN(nA, nB);
  95.     if( pred_blk < 0 )
  96.         return Intra_4x4_DC;
  98.     return pred_blk;
  99. }
  101. uint8_t 
  102. T264_mb_predict_non_zero_code(T264_t* t, int idx)
  103. {
  104.     int32_t x, y;
  105.     int32_t nA, nB;
  106. int16_t pred_blk;
  108. if(idx >= 0 && idx < 16)
  109. {
  110.         x = luma_inverse_x[idx];
  111.         y = luma_inverse_y[idx];
  112.         nA = t->mb.nnz_ref[NNZ_LUMA + x + y * 8 - 1];
  113.         nB = t->mb.nnz_ref[NNZ_LUMA + x + y * 8 - 8];
  114. }
  115. else if(idx < 20)
  116. {
  117. y = (idx - 16) / 2;
  118. x = (idx - 16) % 2;
  119.         nA = t->mb.nnz_ref[NNZ_CHROMA0 + x + y * 8 - 1];
  120.         nB = t->mb.nnz_ref[NNZ_CHROMA0 + x + y * 8 - 8];
  121. }
  122. else if(idx < 24)
  123. {
  124.         y = (idx - 20) / 2;
  125.         x = (idx - 20) % 2;
  126.         nA = t->mb.nnz_ref[NNZ_CHROMA1 + x + y * 8 - 1];
  127.         nB = t->mb.nnz_ref[NNZ_CHROMA1 + x + y * 8 - 8];
  128. }
  130.     pred_blk = nA + nB;
  132.     if( pred_blk < 0x80 )
  133.     {
  134.         pred_blk = ( pred_blk + 1 ) >> 1;
  135.     }
  136.     return pred_blk & 0x7f;
  137. }
  139. /****************************************************************************
  140.  * block_residual_write_cavlc
  141.  ****************************************************************************/
  142. static void block_residual_write_cavlc( T264_t *h, int32_t i_idx, int16_t *l, int32_t i_count )
  143. {
  144.     int level[16], run[16];
  145.     int i_total, i_trailing;
  146.     int i_total_zero;
  147.     int i_last;
  148.     unsigned int i_sign;
  150.     int i;
  151.     int i_zero_left;
  152.     int i_suffix_length;
  154.     /* first find i_last */
  155.     i_last = i_count - 1;
  156.     while( i_last >= 0 && l[i_last] == 0 )
  157.     {
  158.         i_last--;
  159.     }
  161.     i_sign = 0;
  162.     i_total = 0;
  163.     i_trailing = 0;
  164.     i_total_zero = 0;
  166.     if( i_last >= 0 )
  167.     {
  168.         int b_trailing = 1;
  169.         int idx = 0;
  171.         /* level and run and total */
  172.         while( i_last >= 0 )
  173.         {
  174.             level[idx] = l[i_last--];
  176.             run[idx] = 0;
  177.             while( i_last >= 0 && l[i_last] == 0 )
  178.             {
  179.                 run[idx]++;
  180.                 i_last--;
  181.             }
  183.             i_total++;
  184.             i_total_zero += run[idx];
  186.             if( b_trailing && ABS( level[idx] ) == 1 && i_trailing < 3 )
  187.             {
  188.                 i_sign <<= 1;
  189.                 if( level[idx] < 0 )
  190.                 {
  191.                     i_sign |= 0x01;
  192.                 }
  194.                 i_trailing++;
  195.             }
  196.             else
  197.             {
  198.                 b_trailing = 0;
  199.             }
  201.             idx++;
  202.         }
  203.     }
  205.     /* total/trailing represented by Coeff_token (5 tables)*/
  206.     if( i_idx == BLOCK_INDEX_CHROMA_DC )
  207.     {
  208. eg_write_vlc(h->bs, x264_coeff_token[4][i_total*4+i_trailing]);
  209.     }
  210.     else
  211.     {
  212.         /* T264_mb_predict_non_zero_code return 0 <-> (16+16+1)>>1 = 16 */
  213.         static const int ct_index[17] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,3 };
  214.         int nC = 0;
  216.         if( i_idx == BLOCK_INDEX_LUMA_DC )
  217.         {
  218. // predict nC = (nA + nB) / 2;
  219.             nC = T264_mb_predict_non_zero_code(h, 0);
  220.         }
  221.         else
  222.         {
  223. // predict nC = (nA + nB) / 2;
  224.             nC = T264_mb_predict_non_zero_code(h, i_idx);
  225.         }
  227. eg_write_vlc(h->bs, x264_coeff_token[ct_index[nC]][i_total*4+i_trailing]);
  228.     }
  230.     if( i_total <= 0 )
  231.     {
  232.         return;
  233.     }
  235. //encoding trailing '1's (max = 3)
  236.     i_suffix_length = i_total > 10 && i_trailing < 3 ? 1 : 0;
  237.     if( i_trailing > 0 )
  238.     {
  239. eg_write_direct(h->bs, i_sign & ((uint32_t)~0 >> (uint32_t)(32 - i_trailing)), i_trailing);
  240.     }
  242. //encoding remain levels of non-zero coefficients (prefix + suffix)
  243.     for( i = i_trailing; i < i_total; i++ )
  244.     {
  245.         int i_level_code;
  247.         /* calculate level code */
  248.         if( level[i] < 0 )
  249.         {
  250.             i_level_code = -2*level[i] - 1;
  251.         }
  252.         else /* if( level[i] > 0 ) */
  253.         {
  254.             i_level_code = 2 * level[i] - 2;
  255.         }
  256.         if( i == i_trailing && i_trailing < 3 )
  257.         {
  258.             i_level_code -=2; /* as level[i] can't be 1 for the first one if i_trailing < 3 */
  259.         }
  261.         if( ( i_level_code >> i_suffix_length ) < 14 )
  262.         {
  263.             eg_write_vlc(h->bs, x264_level_prefix[i_level_code >> i_suffix_length]);
  264.             if( i_suffix_length > 0 )
  265.             {
  266. eg_write_direct(h->bs, (uint32_t)i_level_code & ((uint32_t)~0 >> (uint32_t)(32 - i_suffix_length)), i_suffix_length);
  267.             }
  268.         }
  269.         else if( i_suffix_length == 0 && i_level_code < 30 )
  270.         {
  271.             eg_write_vlc(h->bs, x264_level_prefix[14]);
  272.             eg_write_direct(h->bs, (i_level_code - 14) & ((uint32_t)~0 >> (uint32_t)(32 - 4)), 4);
  273.         }
  274.         else if( i_suffix_length > 0 && ( i_level_code >> i_suffix_length ) == 14 )
  275.         {
  276.             eg_write_vlc(h->bs, x264_level_prefix[14]);
  277.             eg_write_direct(h->bs, i_level_code & ((uint32_t)~0 >> (uint32_t)(32 - i_suffix_length)), i_suffix_length);
  278.         }
  279.         else
  280.         {
  281.             eg_write_vlc(h->bs, x264_level_prefix[15]);
  282.             i_level_code -= 15 << i_suffix_length;
  283.             if( i_suffix_length == 0 )
  284.             {
  285.                 i_level_code -= 15;
  286.             }
  288.             if( i_level_code >= ( 1 << 12 ) || i_level_code < 0 )
  289.             {
  290.                 fprintf( stderr, "OVERFLOW levelcode=%dn", i_level_code );
  291.             }
  293. eg_write_direct(h->bs, i_level_code & ((uint32_t)~0 >> (uint32_t)(32 - 12)), 12);
  294.         }
  296.         if( i_suffix_length == 0 )
  297.         {
  298.             i_suffix_length++;
  299.         }
  300.         if( ABS( level[i] ) > ( 3 << ( i_suffix_length - 1 ) ) && i_suffix_length < 6 )
  301.         {
  302.             i_suffix_length++;
  303.         }
  304.     }
  306. //encode total zeros [i_total-1][i_total_zero]
  307.     if( i_total < i_count )
  308.     {
  309.         if( i_idx == BLOCK_INDEX_CHROMA_DC )
  310.         {
  311.             eg_write_vlc(h->bs, x264_total_zeros_dc[i_total-1][i_total_zero]);
  312.         }
  313.         else
  314.         {
  315.             eg_write_vlc(h->bs, x264_total_zeros[i_total-1][i_total_zero]);
  316.         }
  317.     }
  319. //encode each run of zeros
  320.     for( i = 0, i_zero_left = i_total_zero; i < i_total - 1; i++ )
  321.     {
  322.         int i_zl;
  324.         if( i_zero_left <= 0 )
  325.         {
  326.             break;
  327.         }
  329.         i_zl = T264_MIN( i_zero_left - 1, 6 );
  331. eg_write_vlc(h->bs, x264_run_before[i_zl][run[i]]);
  333.         i_zero_left -= run[i];
  334.     }
  335. }
  337. void 
  338. T264_macroblock_write_cavlc(T264_t *t)
  339. {
  340.     int32_t mb_mode = t->mb.mb_mode;
  341.     int32_t i;
  342.     int32_t offset;
  344.     if (t->slice_type == SLICE_I)
  345.     {
  346.         offset = 0;
  347.     }
  348.     else if (t->slice_type == SLICE_P)
  349.     {
  350.         offset = 5;
  351.     }
  352.     else if (t->slice_type == SLICE_B)
  353.     {
  354.         offset = 23;
  355.     }
  357.     if(t->slice_type != SLICE_I)
  358.     {
  359.         eg_write_ue(t->bs, t->skip);  /* skip run */
  360.         t->skip = 0;
  361.     }
  363.     if (mb_mode == I_4x4)
  364.     {
  365.         // mb_type
  366.         eg_write_ue(t->bs, offset + 0);
  367.         /* Prediction: Luma */
  368.         for (i = 0 ; i < 16; i ++) /* i : Inverse raster scan */
  369.         {
  370.             int8_t pred = T264_mb_predict_intra4x4_mode(t, i);
  371.             int8_t mode = t->mb.mode_i4x4[i];
  373.             if( pred == mode)
  374.             {
  375.                 eg_write_direct1(t->bs, 1); /* b_prev_intra4x4_pred_mode */
  376.             }
  377.             else
  378.             {
  379.                 eg_write_direct1(t->bs, 0); /* b_prev_intra4x4_pred_mode */
  380.                 if( mode < pred )
  381.                 {
  382.                     eg_write_direct(t->bs, mode, 3);  /* rem_intra4x4_pred_mode */
  383.                 }
  384.                 else
  385.                 {
  386.                     eg_write_direct(t->bs, mode - 1, 3);  /* rem_intra4x4_pred_mode */
  387.                 }
  388.             }
  389.         }
  390.         //intra_chroma_pred_mode
  391.         eg_write_ue(t->bs, t->mb.mb_mode_uv);
  393.         // coded_block_pattern
  394.         eg_write_ue(t->bs, intra4x4_cbp_to_golomb[( t->mb.cbp_c << 4 ) | t->mb.cbp_y]);
  396.         //delta_qp
  397.         if (t->mb.cbp_y > 0 || t->mb.cbp_c > 0)
  398.         {
  399.             eg_write_se(t->bs, t->mb.mb_qp_delta); /* 0 = no change on qp */
  401.             for (i = 0; i < 16 ; i ++)
  402.             {
  403.                 if(t->mb.cbp_y & (1 << ( i / 4 )))
  404.                 {
  405.                     block_residual_write_cavlc(t, i, t->mb.dct_y_z[i], 16);
  406.                 }
  407.             }
  408.         }
  409.     }
  410.     else if (mb_mode == I_16x16)
  411.     {
  412.         // mb_type
  413.         eg_write_ue(t->bs, offset + 1 + t->mb.mode_i16x16 + 
  414.             t->mb.cbp_c * 4 + (t->mb.cbp_y == 0 ? 0 : 12));
  415.         // intra chroma pred mode
  416.         eg_write_ue(t->bs, t->mb.mb_mode_uv);
  418.         // delta qp
  419.         eg_write_se(t->bs, t->mb.mb_qp_delta);
  421.         // dc luma
  422.         block_residual_write_cavlc(t, BLOCK_INDEX_LUMA_DC, t->mb.dc4x4_z, 16);
  424.         if (t->mb.cbp_y != 0)
  425.         {
  426.             for(i = 0 ; i < 16 ; i ++)
  427.             {
  428.                 if (t->mb.cbp_y & (1 << (i / 4)))
  429.                 {
  430.                     block_residual_write_cavlc(t, i, &(t->mb.dct_y_z[i][1]), 15);
  431.                 }
  432.             }
  433.         }
  434.     }
  435.     else
  436.     {
  437.         T264_vector_t vec;
  438.         if (t->slice_type == SLICE_P)
  439.         {
  440.             switch (t->mb.mb_part) 
  441.             {
  442.             case MB_16x16:
  443.                 eg_write_ue(t->bs, MB_16x16);
  444.                 if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  445.                 {
  446.                     eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][0].refno);
  447.                 }
  448.                 vec = t->mb.vec[0][0];
  449.                 T264_predict_mv(t, 0, 0, 4, &vec);
  450.                 eg_write_se(t->bs, t->mb.vec[0][0].x - vec.x);
  451.                 eg_write_se(t->bs, t->mb.vec[0][0].y - vec.y);
  452.              break;
  453.             case MB_16x8:
  454.                 eg_write_ue(t->bs, MB_16x8);
  455.                 if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  456.                 {
  457.                     eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][0].refno);
  458.                     eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][8].refno);
  459.                 }
  460.                 vec = t->mb.vec[0][0];
  461.                 T264_predict_mv(t, 0, 0, 4, &vec);
  462.                 eg_write_se(t->bs, t->mb.vec[0][0].x - vec.x);
  463.                 eg_write_se(t->bs, t->mb.vec[0][0].y - vec.y);
  465.                 vec = t->mb.vec[0][8];
  466.                 T264_predict_mv(t, 0, 8, 4, &vec);
  467.                 eg_write_se(t->bs, t->mb.vec[0][8].x - vec.x);
  468.                 eg_write_se(t->bs, t->mb.vec[0][8].y - vec.y);
  469.              break;
  470.             case MB_8x16:
  471.                 eg_write_ue(t->bs, MB_8x16);
  472.                 if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  473.                 {
  474.                     eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][0].refno);
  475.                     eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][luma_index[4]].refno);
  476.                 }
  477.                 vec = t->mb.vec[0][0];
  478.                 T264_predict_mv(t, 0, 0, 2, &vec);
  479.                 eg_write_se(t->bs, t->mb.vec[0][0].x - vec.x);
  480.                 eg_write_se(t->bs, t->mb.vec[0][0].y - vec.y);
  482.                 vec = t->mb.vec[0][luma_index[4]];
  483.                 T264_predict_mv(t, 0, luma_index[4], 2, &vec);
  484.                 eg_write_se(t->bs, t->mb.vec[0][luma_index[4]].x - vec.x);
  485.                 eg_write_se(t->bs, t->mb.vec[0][luma_index[4]].y - vec.y);
  486.                 break;
  487.             case MB_8x8:
  488.             case MB_8x8ref0:
  489.                 if (t->mb.vec[0][luma_index[0]].refno == 0 &&
  490.                     t->mb.vec[0][luma_index[4]].refno == 0 &&
  491.                     t->mb.vec[0][luma_index[8]].refno == 0 &&
  492.                     t->mb.vec[0][luma_index[12]].refno == 0)
  493.                 {
  494.                     eg_write_ue(t->bs, MB_8x8ref0);
  495.                     for (i = 0 ; i < 4 ; i ++)
  496.                     {
  497.                         switch (t->mb.submb_part[luma_index[4 * i]]) 
  498.                         {
  499.                         case MB_8x8:
  500.                             eg_write_ue(t->bs, 0);
  501.                          break;
  502.                         case MB_8x4:
  503.                             eg_write_ue(t->bs, 1);
  504.                             break;
  505.                         case MB_4x8:
  506.                             eg_write_ue(t->bs, 2);
  507.                             break;
  508.                         case MB_4x4:
  509.                             eg_write_ue(t->bs, 3);
  510.                             break;
  511.                         default:
  512.                             break;
  513.                         }
  514.                     }
  515.                 }
  516.                 else
  517.                 {
  518.                     eg_write_ue(t->bs, MB_8x8);
  519.                     for (i = 0 ; i < 4 ; i ++)
  520.                     {
  521.                         switch (t->mb.submb_part[luma_index[4 * i]]) 
  522.                         {
  523.                         case MB_8x8:
  524.                             eg_write_ue(t->bs, 0);
  525.                             break;
  526.                         case MB_8x4:
  527.                             eg_write_ue(t->bs, 1);
  528.                             break;
  529.                         case MB_4x8:
  530.                             eg_write_ue(t->bs, 2);
  531.                             break;
  532.                         case MB_4x4:
  533.                             eg_write_ue(t->bs, 3);
  534.                             break;
  535.                         default:
  536.                             break;
  537.                         }
  538.                     }
  539.                     
  540.                     if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  541.                     {
  542.                         eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][0].refno);
  543.                         eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][luma_index[4]].refno);
  544.                         eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][luma_index[8]].refno);
  545.                         eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][luma_index[12]].refno);
  546.                     }
  547.                 }
  548.                 for(i = 0 ; i < 4 ; i ++)
  549.                 {
  550.                     switch(t->mb.submb_part[luma_index[4 * i]]) 
  551.                     {
  552.                     case MB_8x8:
  553.                         vec = t->mb.vec[0][luma_index[4 * i]];
  554.                         T264_predict_mv(t, 0, luma_index[4 * i], 2, &vec);
  555.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].x - vec.x);
  556.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].y - vec.y);
  557.                      break;
  558.                     case MB_8x4:
  559.                         vec = t->mb.vec[0][luma_index[4 * i]];
  560.                         T264_predict_mv(t, 0, luma_index[4 * i], 2, &vec);
  561.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].x - vec.x);
  562.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].y - vec.y);
  564.                         vec = t->mb.vec[0][luma_index[4 * i + 2]];
  565.                         T264_predict_mv(t, 0, luma_index[4 * i + 2], 2, &vec);
  566.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 2]].x - vec.x);
  567.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 2]].y - vec.y);
  568.                      break;
  569.                     case MB_4x8:
  570.                         vec = t->mb.vec[0][luma_index[4 * i]];
  571.                         T264_predict_mv(t, 0, luma_index[4 * i], 1, &vec);
  572.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].x - vec.x);
  573.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].y - vec.y);
  575.                         vec = t->mb.vec[0][luma_index[4 * i + 1]];
  576.                         T264_predict_mv(t, 0, luma_index[4 * i + 1], 1, &vec);
  577.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 1]].x - vec.x);
  578.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 1]].y - vec.y);
  579.                         break;
  580.                     case MB_4x4:
  581.                         vec = t->mb.vec[0][luma_index[4 * i]];
  582.                         T264_predict_mv(t, 0, luma_index[4 * i], 1, &vec);
  583.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].x - vec.x);
  584.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].y - vec.y);
  586.                         vec = t->mb.vec[0][luma_index[4 * i + 1]];
  587.                         T264_predict_mv(t, 0, luma_index[4 * i + 1], 1, &vec);
  588.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 1]].x - vec.x);
  589.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 1]].y - vec.y);
  591.                         vec = t->mb.vec[0][luma_index[4 * i + 2]];
  592.                         T264_predict_mv(t, 0, luma_index[4 * i + 2], 1, &vec);
  593.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 2]].x - vec.x);
  594.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 2]].y - vec.y);
  596.                         vec = t->mb.vec[0][luma_index[4 * i + 3]];
  597.                         T264_predict_mv(t, 0, luma_index[4 * i + 3], 1, &vec);
  598.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 3]].x - vec.x);
  599.                         eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i + 3]].y - vec.y);
  600.                         break;
  601.                     }
  602.                 }
  603.                 break;
  604.             default:
  605.                 break;
  606.             }
  607.         }
  608.         else
  609.         {
  610.             switch (t->mb.mb_part)
  611.             {
  612.             case MB_16x16:
  613.                  if (t->mb.is_copy != 1)
  614.                  {
  615.                     switch (t->mb.mb_part2[0])
  616.                     {
  617.                     case B_L0_16x16:
  618.                         eg_write_ue(t->bs, 1);
  619.                         if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  620.                         {
  621.                             eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][0].refno);
  622.                         }
  623.                         vec = t->mb.vec[0][0];
  624.                         T264_predict_mv(t, 0, 0, 4, &vec);
  625.                         eg_write_se(t->bs, t->mb.vec[0][0].x - vec.x);
  626.                         eg_write_se(t->bs, t->mb.vec[0][0].y - vec.y);
  627.                         break;
  628.                     case B_L1_16x16:
  629.                         eg_write_ue(t->bs, 2);
  630.                         if (t->ps.num_ref_idx_l1_active_minus1 > 0)
  631.                         {
  632.                             eg_write_te(t->bs, t->ps.num_ref_idx_l1_active_minus1, t->mb.vec[1][0].refno);
  633.                         }
  634.                         vec = t->mb.vec[1][0];
  635.                         T264_predict_mv(t, 1, 0, 4, &vec);
  636.                         eg_write_se(t->bs, t->mb.vec[1][0].x - vec.x);
  637.                         eg_write_se(t->bs, t->mb.vec[1][0].y - vec.y);
  638.                         break;
  639.                     case B_Bi_16x16:
  640.                         eg_write_ue(t->bs, 3);
  641.                         if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  642.                         {
  643.                             eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][0].refno);
  644.                         }
  645.                         if (t->ps.num_ref_idx_l1_active_minus1 > 0)
  646.                         {
  647.                             eg_write_te(t->bs, t->ps.num_ref_idx_l1_active_minus1, t->mb.vec[1][0].refno);
  648.                         }
  649.                         vec = t->mb.vec[0][0];
  650.                         T264_predict_mv(t, 0, 0, 4, &vec);
  651.                         eg_write_se(t->bs, t->mb.vec[0][0].x - vec.x);
  652.                         eg_write_se(t->bs, t->mb.vec[0][0].y - vec.y);
  653.                         vec = t->mb.vec[1][0];
  654.                         T264_predict_mv(t, 1, 0, 4, &vec);
  655.                         eg_write_se(t->bs, t->mb.vec[1][0].x - vec.x);
  656.                         eg_write_se(t->bs, t->mb.vec[1][0].y - vec.y);
  657.                         break;
  658.                     }
  659.                 }
  660.                 else
  661.                 {
  662.                     eg_write_ue(t->bs, 0);
  663.                 }
  664.                 break;
  665.             case MB_16x8:
  666.                 {
  667.                     static int8_t mode_16x8[3][3] = 
  668.                     {
  669.                         B_L0_L0_16x8, B_L0_L1_16x8, B_L0_Bi_16x8,
  670.                         B_L1_L0_16x8, B_L1_L1_16x8, B_L1_Bi_16x8,
  671.                         B_Bi_L0_16x8, B_Bi_L1_16x8, B_Bi_Bi_16x8
  672.                     };
  673.                     eg_write_ue(t->bs, mode_16x8[t->mb.mb_part2[0] - B_L0_16x8][t->mb.mb_part2[1] - B_L0_16x8]);
  674.                     if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  675.                     {
  676.                         if (t->mb.mb_part2[0] != B_L1_16x8)
  677.                             eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][0].refno);
  678.                         if (t->mb.mb_part2[1] != B_L1_16x8)
  679.                             eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][8].refno);
  680.                     }
  681.                     if (t->ps.num_ref_idx_l1_active_minus1 > 0)
  682.                     {
  683.                         if (t->mb.mb_part2[0] != B_L0_16x8)
  684.                             eg_write_te(t->bs, t->ps.num_ref_idx_l1_active_minus1, t->mb.vec[1][0].refno);
  685.                         if (t->mb.mb_part2[1] != B_L0_16x8)
  686.                             eg_write_te(t->bs, t->ps.num_ref_idx_l1_active_minus1, t->mb.vec[1][8].refno);
  687.                     }
  688.                     // l0
  689.                     for (i = 0 ; i < 2 ; i ++)
  690.                     {
  691.                         switch(t->mb.mb_part2[i]) 
  692.                         {
  693.                         case B_L0_16x8:
  694.                             vec = t->mb.vec[0][8 * i];
  695.                             T264_predict_mv(t, 0, luma_index[8 * i], 4, &vec);
  696.                             eg_write_se(t->bs, t->mb.vec[0][luma_index[8 * i]].x - vec.x);
  697.                             eg_write_se(t->bs, t->mb.vec[0][luma_index[8 * i]].y - vec.y);
  698.                             break;
  699.                         case B_Bi_16x8:
  700.                             vec = t->mb.vec[0][luma_index[8 * i]];
  701.                             T264_predict_mv(t, 0, luma_index[8 * i], 4, &vec);
  702.                             eg_write_se(t->bs, t->mb.vec[0][luma_index[8 * i]].x - vec.x);
  703.                             eg_write_se(t->bs, t->mb.vec[0][luma_index[8 * i]].y - vec.y);
  704.                         }
  705.                     }
  706.                     for (i = 0 ; i < 2 ; i ++)
  707.                     {
  708.                         switch(t->mb.mb_part2[i]) 
  709.                         {
  710.                         case B_L1_16x8:
  711.                             vec = t->mb.vec[1][luma_index[8 * i]];
  712.                             T264_predict_mv(t, 1, luma_index[8 * i], 4, &vec);
  713.                             eg_write_se(t->bs, t->mb.vec[1][luma_index[8 * i]].x - vec.x);
  714.                             eg_write_se(t->bs, t->mb.vec[1][luma_index[8 * i]].y - vec.y);
  715.                             break;
  716.                         case B_Bi_16x8:
  717.                             vec = t->mb.vec[1][luma_index[8 * i]];
  718.                             T264_predict_mv(t, 1, luma_index[8 * i], 4, &vec);
  719.                             eg_write_se(t->bs, t->mb.vec[1][luma_index[8 * i]].x - vec.x);
  720.                             eg_write_se(t->bs, t->mb.vec[1][luma_index[8 * i]].y - vec.y);
  721.                             break;
  722.                         }
  723.                     }
  724.                 }
  725.                 break;
  726.             case MB_8x16:
  727.                 {
  728.                     static int8_t mode_8x16[3][3] = 
  729.                     {
  730.                         B_L0_L0_8x16, B_L0_L1_8x16, B_L0_Bi_8x16,
  731.                         B_L1_L0_8x16, B_L1_L1_8x16, B_L1_Bi_8x16,
  732.                         B_Bi_L0_8x16, B_Bi_L1_8x16, B_Bi_Bi_8x16
  733.                     };
  734.                     eg_write_ue(t->bs, mode_8x16[t->mb.mb_part2[0] - B_L0_8x16][t->mb.mb_part2[1] - B_L0_8x16]);
  735.                     if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  736.                     {
  737.                         if (t->mb.mb_part2[0] != B_L1_8x16)
  738.                             eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][0].refno);
  739.                         if (t->mb.mb_part2[1] != B_L1_8x16)
  740.                             eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][2].refno);
  741.                     }
  742.                     if (t->ps.num_ref_idx_l1_active_minus1 > 0)
  743.                     {
  744.                         if (t->mb.mb_part2[0] != B_L0_8x16)
  745.                             eg_write_te(t->bs, t->ps.num_ref_idx_l1_active_minus1, t->mb.vec[1][0].refno);
  746.                         if (t->mb.mb_part2[1] != B_L0_8x16)
  747.                             eg_write_te(t->bs, t->ps.num_ref_idx_l1_active_minus1, t->mb.vec[1][2].refno);
  748.                     }
  749.                     // l0
  750.                     for (i = 0 ; i < 2 ; i ++)
  751.                     {
  752.                         switch(t->mb.mb_part2[i]) 
  753.                         {
  754.                         case B_L0_8x16:
  755.                             vec = t->mb.vec[0][2 * i];
  756.                             T264_predict_mv(t, 0, luma_index[4 * i], 2, &vec);
  757.                             eg_write_se(t->bs, t->mb.vec[0][2 * i].x - vec.x);
  758.                             eg_write_se(t->bs, t->mb.vec[0][2 * i].y - vec.y);
  759.                             break;
  760.                         case B_Bi_8x16:
  761.                             vec = t->mb.vec[0][2 * i];
  762.                             T264_predict_mv(t, 0, luma_index[4 * i], 2, &vec);
  763.                             eg_write_se(t->bs, t->mb.vec[0][2 * i].x - vec.x);
  764.                             eg_write_se(t->bs, t->mb.vec[0][2 * i].y - vec.y);
  765.                         }
  766.                     }
  767.                     for (i = 0 ; i < 2 ; i ++)
  768.                     {
  769.                         switch(t->mb.mb_part2[i]) 
  770.                         {
  771.                         case B_L1_8x16:
  772.                             vec = t->mb.vec[1][2 * i];
  773.                             T264_predict_mv(t, 1, luma_index[4 * i], 2, &vec);
  774.                             eg_write_se(t->bs, t->mb.vec[1][2 * i].x - vec.x);
  775.                             eg_write_se(t->bs, t->mb.vec[1][2 * i].y - vec.y);
  776.                             break;
  777.                         case B_Bi_8x16:
  778.                             vec = t->mb.vec[1][2 * i];
  779.                             T264_predict_mv(t, 1, luma_index[4 * i], 2, &vec);
  780.                             eg_write_se(t->bs, t->mb.vec[1][2 * i].x - vec.x);
  781.                             eg_write_se(t->bs, t->mb.vec[1][2 * i].y - vec.y);
  782.                             break;
  783.                         }
  784.                     }
  785.                 }
  786.                 break;
  787.             case MB_8x8:
  788.                 {
  789.                     eg_write_ue(t->bs, 22);
  790.                     for (i = 0 ; i < 4 ; i ++)
  791.                     {
  792.                         if (t->mb.sub_is_copy[i] != 1)
  793.                         {
  794.                             switch (t->mb.submb_part[luma_index[4 * i]]) 
  795.                             {
  796.                             case B_L0_8x8:
  797.                                 eg_write_ue(t->bs, 1);
  798.                                 break;
  799.                             case B_L1_8x8:
  800.                                 eg_write_ue(t->bs, 2);
  801.                                 break;
  802.                             case B_Bi_8x8:
  803.                                 eg_write_ue(t->bs, 3);
  804.                                 break;
  805.                             default:
  806.                                 assert(0);
  807.                                 break;
  808.                             }
  809.                         }
  810.                         else
  811.                         {
  812.                             eg_write_ue(t->bs, 0);
  813.                             break;
  814.                         }
  815.                     }
  816.                     if (t->ps.num_ref_idx_l0_active_minus1 > 0)
  817.                     {
  818.                         for (i = 0 ; i < 4 ; i ++)
  819.                         {
  820.                             if (t->mb.submb_part[luma_index[4 * i]] != 2 && t->mb.submb_part[luma_index[4 * i]] != 0)
  821.                                 eg_write_te(t->bs, t->ps.num_ref_idx_l0_active_minus1, t->mb.vec[0][4 * i].refno);
  822.                         }
  823.                     }
  824.                     if (t->ps.num_ref_idx_l1_active_minus1 > 0)
  825.                     {
  826.                         for (i = 0 ; i < 4 ; i ++)
  827.                         {
  828.                             if (t->mb.submb_part[luma_index[4 * i]] != 1 && t->mb.submb_part[luma_index[4 * i]] != 0)
  829.                                 eg_write_te(t->bs, t->ps.num_ref_idx_l1_active_minus1, t->mb.vec[1][4 * i].refno);
  830.                         }
  831.                     }
  832.                     // l0
  833.                     for (i = 0 ; i < 4 ; i ++)
  834.                     {
  835.                         switch(t->mb.submb_part[luma_index[4 * i]]) 
  836.                         {
  837.                         case B_L0_8x8:
  838.                         case B_Bi_8x8:
  839.                             vec = t->mb.vec[0][luma_index[4 * i]];
  840.                             T264_predict_mv(t, 0, luma_index[4 * i], 2, &vec);
  841.                             eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].x - vec.x);
  842.                             eg_write_se(t->bs, t->mb.vec[0][luma_index[4 * i]].y - vec.y);
  843.                             break;
  844.                         }
  845.                     }
  846.                     for (i = 0 ; i < 4 ; i ++)
  847.                     {
  848.                         switch(t->mb.submb_part[luma_index[4 * i]]) 
  849.                         {
  850.                         case B_L1_8x8:
  851.                         case B_Bi_8x8:
  852.                             vec = t->mb.vec[1][luma_index[4 * i]];
  853.                             T264_predict_mv(t, 1, luma_index[4 * i], 2, &vec);
  854.                             eg_write_se(t->bs, t->mb.vec[1][luma_index[4 * i]].x - vec.x);
  855.                             eg_write_se(t->bs, t->mb.vec[1][luma_index[4 * i]].y - vec.y);
  856.                             break;
  857.                         }
  858.                     }
  859.                 }
  860.                 break;
  861.             }
  862.         }
  863.         eg_write_ue(t->bs, inter_cbp_to_golomb[(t->mb.cbp_c << 4)| t->mb.cbp_y]);
  864.         //delta_qp
  865.         if (t->mb.cbp_y > 0 || t->mb.cbp_c > 0)
  866.         {
  867.             eg_write_se(t->bs, t->mb.mb_qp_delta); /* 0 = no change on qp */
  869.             for (i = 0; i < 16 ; i ++)
  870.             {
  871.                 if(t->mb.cbp_y & (1 << ( i / 4 )))
  872.                 {
  873.                     block_residual_write_cavlc(t, i, t->mb.dct_y_z[i], 16);
  874.                 }
  875.             }
  876.         }
  877.     }
  879.     if (t->mb.cbp_c != 0)
  880.     {
  881.         block_residual_write_cavlc(t, BLOCK_INDEX_CHROMA_DC, t->mb.dc2x2_z[0], 4);
  882.         block_residual_write_cavlc(t, BLOCK_INDEX_CHROMA_DC, t->mb.dc2x2_z[1], 4);
  883.         if (t->mb.cbp_c & 0x2)
  884.         {
  885.             for(i = 0 ; i < 8 ; i ++)
  886.             {
  887.                 block_residual_write_cavlc(t, 16 + i, &(t->mb.dct_uv_z[i / 4][i % 4][1]), 15);
  888.             }
  889.         }
  890.     }
  891. }