rdo.c
上传用户:lctgjx
上传日期:2022-06-04
资源大小:8887k
文件大小:24k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

Visual C++

  1. /*****************************************************************************
  2.  * rdo.c: h264 encoder library (rate-distortion optimization)
  3.  *****************************************************************************
  4.  * Copyright (C) 2005-2008 x264 project
  5.  *
  6.  * Authors: Loren Merritt <lorenm@u.washington.edu>
  7.  *          Jason Garrett-Glaser <darkshikari@gmail.com>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  23. /* duplicate all the writer functions, just calculating bit cost
  24.  * instead of writing the bitstream.
  25.  * TODO: use these for fast 1st pass too. */
  26. #define RDO_SKIP_BS 1
  27. typedef  unsigned char uint8_t;//--@lia
  28. typedef  unsigned short uint16_t;//--@lia
  29. typedef  unsigned int uint32_t;//--@lia
  30. //配置MS VC环境 --@lia
  31. #ifdef _MSC_VER
  32. #define inline __inline
  33. #endif
  34. /* Transition and size tables for abs<9 MVD and residual coding */
  35. /* Consist of i_prefix-2 1s, one zero, and a bypass sign bit */
  36. static uint8_t cabac_transition_unary[15][128];
  37. static uint16_t cabac_size_unary[15][128];
  38. /* Transition and size tables for abs>9 MVD */
  39. /* Consist of 5 1s and a bypass sign bit */
  40. static uint8_t cabac_transition_5ones[128];
  41. static uint16_t cabac_size_5ones[128];
  42. /* CAVLC: produces exactly the same bit count as a normal encode */
  43. /* this probably still leaves some unnecessary computations */
  44. #define bs_write1(s,v)     ((s)->i_bits_encoded += 1)
  45. #define bs_write(s,n,v)    ((s)->i_bits_encoded += (n))
  46. #define bs_write_ue(s,v)   ((s)->i_bits_encoded += bs_size_ue(v))
  47. #define bs_write_se(s,v)   ((s)->i_bits_encoded += bs_size_se(v))
  48. #define bs_write_te(s,v,l) ((s)->i_bits_encoded += bs_size_te(v,l))
  49. #define x264_macroblock_write_cavlc  static x264_macroblock_size_cavlc
  50. #include "cavlc.c"
  51. /* CABAC: not exactly the same. x264_cabac_size_decision() keeps track of
  52.  * fractional bits, but only finite precision. */
  53. #undef  x264_cabac_encode_decision
  54. #undef  x264_cabac_encode_decision_noup
  55. #define x264_cabac_encode_decision(c,x,v) x264_cabac_size_decision(c,x,v)
  56. #define x264_cabac_encode_decision_noup(c,x,v) x264_cabac_size_decision_noup(c,x,v)
  57. #define x264_cabac_encode_terminal(c)     ((c)->f8_bits_encoded += 7)
  58. #define x264_cabac_encode_bypass(c,v)     ((c)->f8_bits_encoded += 256)
  59. #define x264_cabac_encode_ue_bypass(c,e,v) ((c)->f8_bits_encoded += (bs_size_ue_big(v+(1<<e)-1)-e)<<8)
  60. #define x264_macroblock_write_cabac  static x264_macroblock_size_cabac
  61. #include "cabac.c"
  62. #define COPY_CABAC h->mc.memcpy_aligned( &cabac_tmp.f8_bits_encoded, &h->cabac.f8_bits_encoded, 
  63.         sizeof(x264_cabac_t) - offsetof(x264_cabac_t,f8_bits_encoded) )
  64. /* Sum the cached SATDs to avoid repeating them. */
  65. static inline int sum_satd( x264_t *h, int pixel, int x, int y )
  66. {
  67.     int satd = 0;
  68.     int min_x = x>>2;
  69.     int min_y = y>>2;
  70.     int max_x = (x>>2) + (x264_pixel_size[pixel].w>>2);
  71.     int max_y = (y>>2) + (x264_pixel_size[pixel].h>>2);
  72.     if( pixel == PIXEL_16x16 )
  73.         return h->mb.pic.fenc_satd_sum;
  74.     for( y = min_y; y < max_y; y++ )
  75.         for( x = min_x; x < max_x; x++ )
  76.             satd += h->mb.pic.fenc_satd[y][x];
  77.     return satd;
  78. }
  79. static inline int sum_sa8d( x264_t *h, int pixel, int x, int y )
  80. {
  81.     int sa8d = 0;
  82.     int min_x = x>>3;
  83.     int min_y = y>>3;
  84.     int max_x = (x>>3) + (x264_pixel_size[pixel].w>>3);
  85.     int max_y = (y>>3) + (x264_pixel_size[pixel].h>>3);
  86.     if( pixel == PIXEL_16x16 )
  87.         return h->mb.pic.fenc_sa8d_sum;
  88.     for( y = min_y; y < max_y; y++ )
  89.         for( x = min_x; x < max_x; x++ )
  90.             sa8d += h->mb.pic.fenc_sa8d[y][x];
  91.     return sa8d;
  92. }
  93. /* Psy RD distortion metric: SSD plus "Absolute Difference of Complexities" */
  94. /* SATD and SA8D are used to measure block complexity. */
  95. /* The difference between SATD and SA8D scores are both used to avoid bias from the DCT size.  Using SATD */
  96. /* only, for example, results in overusage of 8x8dct, while the opposite occurs when using SA8D. */
  97. /* FIXME:  Is there a better metric than averaged SATD/SA8D difference for complexity difference? */
  98. /* Hadamard transform is recursive, so a SATD+SA8D can be done faster by taking advantage of this fact. */
  99. /* This optimization can also be used in non-RD transform decision. */
  100. static inline int ssd_plane( x264_t *h, int size, int p, int x, int y )
  101. {
  102.     ALIGNED_16(static uint8_t zero[16]);
  103.     int satd = 0;
  104.     uint8_t *fdec = h->mb.pic.p_fdec[p] + x + y*FDEC_STRIDE;
  105.     uint8_t *fenc = h->mb.pic.p_fenc[p] + x + y*FENC_STRIDE;
  106.     if( p == 0 && h->mb.i_psy_rd )
  107.     {
  108.         /* If the plane is smaller than 8x8, we can't do an SA8D; this probably isn't a big problem. */
  109.         if( size <= PIXEL_8x8 )
  110.         {
  111.             uint64_t acs = h->pixf.hadamard_ac[size]( fdec, FDEC_STRIDE );
  112.             satd = abs((int32_t)acs - sum_satd( h, size, x, y ))
  113.                  + abs((int32_t)(acs>>32) - sum_sa8d( h, size, x, y ));
  114.             satd >>= 1;
  115.         }
  116.         else
  117.         {
  118.             int dc = h->pixf.sad[size]( fdec, FDEC_STRIDE, zero, 0 ) >> 1;
  119.             satd = abs(h->pixf.satd[size]( fdec, FDEC_STRIDE, zero, 0 ) - dc - sum_satd( h, size, x, y ));
  120.         }
  121.         satd = (satd * h->mb.i_psy_rd * h->mb.i_psy_rd_lambda + 128) >> 8;
  122.     }
  123.     return h->pixf.ssd[size](fenc, FENC_STRIDE, fdec, FDEC_STRIDE) + satd;
  124. }
  125. static inline int ssd_mb( x264_t *h )
  126. {
  127.     int chromassd = ssd_plane(h, PIXEL_8x8, 1, 0, 0) + ssd_plane(h, PIXEL_8x8, 2, 0, 0);
  128.     chromassd = (chromassd * h->mb.i_chroma_lambda2_offset + 128) >> 8;
  129.     return ssd_plane(h, PIXEL_16x16, 0, 0, 0) + chromassd;
  130. }
  131. static int x264_rd_cost_mb( x264_t *h, int i_lambda2 )
  132. {
  133.     int b_transform_bak = h->mb.b_transform_8x8;
  134.     int i_ssd;
  135.     int i_bits;
  136.     int type_bak = h->mb.i_type;
  137.     x264_macroblock_encode( h );
  138.     i_ssd = ssd_mb( h );
  139.     if( IS_SKIP( h->mb.i_type ) )
  140.     {
  141.         i_bits = (1 * i_lambda2 + 128) >> 8;
  142.     }
  143.     else if( h->param.b_cabac )
  144.     {
  145.         x264_cabac_t cabac_tmp;
  146.         COPY_CABAC;
  147.         x264_macroblock_size_cabac( h, &cabac_tmp );
  148.         i_bits = ( (uint64_t)cabac_tmp.f8_bits_encoded * i_lambda2 + 32768 ) >> 16;
  149.     }
  150.     else
  151.     {
  152.         bs_t bs_tmp = h->out.bs;
  153.         bs_tmp.i_bits_encoded = 0;
  154.         x264_macroblock_size_cavlc( h, &bs_tmp );
  155.         i_bits = ( bs_tmp.i_bits_encoded * i_lambda2 + 128 ) >> 8;
  156.     }
  157.     h->mb.b_transform_8x8 = b_transform_bak;
  158.     h->mb.i_type = type_bak;
  159.     return i_ssd + i_bits;
  160. }
  161. /* partition RD functions use 8 bits more precision to avoid large rounding errors at low QPs */
  162. static uint64_t x264_rd_cost_subpart( x264_t *h, int i_lambda2, int i4, int i_pixel )
  163. {
  164.     uint64_t i_ssd, i_bits;
  165.     x264_macroblock_encode_p4x4( h, i4 );
  166.     if( i_pixel == PIXEL_8x4 )
  167.         x264_macroblock_encode_p4x4( h, i4+1 );
  168.     if( i_pixel == PIXEL_4x8 )
  169.         x264_macroblock_encode_p4x4( h, i4+2 );
  170.     i_ssd = ssd_plane( h, i_pixel, 0, block_idx_x[i4]*4, block_idx_y[i4]*4 );
  171.     if( h->param.b_cabac )
  172.     {
  173.         x264_cabac_t cabac_tmp;
  174.         COPY_CABAC;
  175.         x264_subpartition_size_cabac( h, &cabac_tmp, i4, i_pixel );
  176.         i_bits = ( (uint64_t)cabac_tmp.f8_bits_encoded * i_lambda2 + 128 ) >> 8;
  177.     }
  178.     else
  179.     {
  180.         i_bits = x264_subpartition_size_cavlc( h, i4, i_pixel );
  181.     }
  182.     return (i_ssd<<8) + i_bits;
  183. }
  184. uint64_t x264_rd_cost_part( x264_t *h, int i_lambda2, int i4, int i_pixel )
  185. {
  186.     uint64_t i_ssd, i_bits;
  187.     int i8 = i4 >> 2;
  188.     int chromassd;
  189.     if( i_pixel == PIXEL_16x16 )
  190.     {
  191.         int i_cost = x264_rd_cost_mb( h, i_lambda2 );
  192.         return i_cost;
  193.     }
  194.     if( i_pixel > PIXEL_8x8 )
  195.         return x264_rd_cost_subpart( h, i_lambda2, i4, i_pixel );
  196.     h->mb.i_cbp_luma = 0;
  197.     x264_macroblock_encode_p8x8( h, i8 );
  198.     if( i_pixel == PIXEL_16x8 )
  199.         x264_macroblock_encode_p8x8( h, i8+1 );
  200.     if( i_pixel == PIXEL_8x16 )
  201.         x264_macroblock_encode_p8x8( h, i8+2 );
  202.     chromassd = ssd_plane( h, i_pixel+3, 1, (i8&1)*4, (i8>>1)*4 )
  203.               + ssd_plane( h, i_pixel+3, 2, (i8&1)*4, (i8>>1)*4 );
  204.     chromassd = (chromassd * h->mb.i_chroma_lambda2_offset + 128) >> 8;
  205.     i_ssd = ssd_plane( h, i_pixel,   0, (i8&1)*8, (i8>>1)*8 ) + chromassd;
  206.     if( h->param.b_cabac )
  207.     {
  208.         x264_cabac_t cabac_tmp;
  209.         COPY_CABAC;
  210.         x264_partition_size_cabac( h, &cabac_tmp, i8, i_pixel );
  211.         i_bits = ( (uint64_t)cabac_tmp.f8_bits_encoded * i_lambda2 + 128 ) >> 8;
  212.     }
  213.     else
  214.     {
  215.         i_bits = x264_partition_size_cavlc( h, i8, i_pixel ) * i_lambda2;
  216.     }
  217.     return (i_ssd<<8) + i_bits;
  218. }
  219. static uint64_t x264_rd_cost_i8x8( x264_t *h, int i_lambda2, int i8, int i_mode )
  220. {
  221.     uint64_t i_ssd, i_bits;
  222.     h->mb.i_cbp_luma &= ~(1<<i8);
  223.     h->mb.b_transform_8x8 = 1;
  224.     x264_mb_encode_i8x8( h, i8, h->mb.i_qp );
  225.     i_ssd = ssd_plane( h, PIXEL_8x8, 0, (i8&1)*8, (i8>>1)*8 );
  226.     if( h->param.b_cabac )
  227.     {
  228.         x264_cabac_t cabac_tmp;
  229.         COPY_CABAC;
  230.         x264_partition_i8x8_size_cabac( h, &cabac_tmp, i8, i_mode );
  231.         i_bits = ( (uint64_t)cabac_tmp.f8_bits_encoded * i_lambda2 + 128 ) >> 8;
  232.     }
  233.     else
  234.     {
  235.         i_bits = x264_partition_i8x8_size_cavlc( h, i8, i_mode ) * i_lambda2;
  236.     }
  237.     return (i_ssd<<8) + i_bits;
  238. }
  239. static uint64_t x264_rd_cost_i4x4( x264_t *h, int i_lambda2, int i4, int i_mode )
  240. {
  241.     uint64_t i_ssd, i_bits;
  242.     x264_mb_encode_i4x4( h, i4, h->mb.i_qp );
  243.     i_ssd = ssd_plane( h, PIXEL_4x4, 0, block_idx_x[i4]*4, block_idx_y[i4]*4 );
  244.     if( h->param.b_cabac )
  245.     {
  246.         x264_cabac_t cabac_tmp;
  247.         COPY_CABAC;
  248.         x264_partition_i4x4_size_cabac( h, &cabac_tmp, i4, i_mode );
  249.         i_bits = ( (uint64_t)cabac_tmp.f8_bits_encoded * i_lambda2 + 128 ) >> 8;
  250.     }
  251.     else
  252.     {
  253.         i_bits = x264_partition_i4x4_size_cavlc( h, i4, i_mode ) * i_lambda2;
  254.     }
  255.     return (i_ssd<<8) + i_bits;
  256. }
  257. static uint64_t x264_rd_cost_i8x8_chroma( x264_t *h, int i_lambda2, int i_mode, int b_dct )
  258. {
  259.     uint64_t i_ssd, i_bits;
  260.     if( b_dct )
  261.         x264_mb_encode_8x8_chroma( h, 0, h->mb.i_chroma_qp );
  262.     i_ssd = ssd_plane( h, PIXEL_8x8, 1, 0, 0 ) +
  263.             ssd_plane( h, PIXEL_8x8, 2, 0, 0 );
  264.     h->mb.i_chroma_pred_mode = i_mode;
  265.     if( h->param.b_cabac )
  266.     {
  267.         x264_cabac_t cabac_tmp;
  268.         COPY_CABAC;
  269.         x264_i8x8_chroma_size_cabac( h, &cabac_tmp );
  270.         i_bits = ( (uint64_t)cabac_tmp.f8_bits_encoded * i_lambda2 + 128 ) >> 8;
  271.     }
  272.     else
  273.     {
  274.         i_bits = x264_i8x8_chroma_size_cavlc( h ) * i_lambda2;
  275.     }
  276.     return (i_ssd<<8) + i_bits;
  277. }
  278. /****************************************************************************
  279.  * Trellis RD quantization
  280.  ****************************************************************************/
  281. #define TRELLIS_SCORE_MAX ((uint64_t)1<<50)
  282. #define CABAC_SIZE_BITS 8
  283. #define SSD_WEIGHT_BITS 5
  284. #define LAMBDA_BITS 4
  285. /* precalculate the cost of coding various combinations of bits in a single context */
  286. void x264_rdo_init( void )
  287. {
  288.     int i_prefix, i_ctx, i;
  289.     for( i_prefix = 0; i_prefix < 15; i_prefix++ )
  290.     {
  291.         for( i_ctx = 0; i_ctx < 128; i_ctx++ )
  292.         {
  293.             int f8_bits = 0;
  294.             uint8_t ctx = i_ctx;
  295.             for( i = 1; i < i_prefix; i++ )
  296.                 f8_bits += x264_cabac_size_decision2( &ctx, 1 );
  297.             if( i_prefix > 0 && i_prefix < 14 )
  298.                 f8_bits += x264_cabac_size_decision2( &ctx, 0 );
  299.             f8_bits += 1 << CABAC_SIZE_BITS; //sign
  300.             cabac_size_unary[i_prefix][i_ctx] = f8_bits;
  301.             cabac_transition_unary[i_prefix][i_ctx] = ctx;
  302.         }
  303.     }
  304.     for( i_ctx = 0; i_ctx < 128; i_ctx++ )
  305.     {
  306.         int f8_bits = 0;
  307.         uint8_t ctx = i_ctx;
  308.         for( i = 0; i < 5; i++ )
  309.             f8_bits += x264_cabac_size_decision2( &ctx, 1 );
  310.         f8_bits += 1 << CABAC_SIZE_BITS; //sign
  311.         cabac_size_5ones[i_ctx] = f8_bits;
  312.         cabac_transition_5ones[i_ctx] = ctx;
  313.     }
  314. }
  315. typedef struct {
  316.     int64_t score;
  317.     int level_idx; // index into level_tree[]
  318.     uint8_t cabac_state[10]; //just the contexts relevant to coding abs_level_m1
  319. } trellis_node_t;
  320. // TODO:
  321. // save cabac state between blocks?
  322. // use trellis' RD score instead of x264_mb_decimate_score?
  323. // code 8x8 sig/last flags forwards with deadzone and save the contexts at
  324. //   each position?
  325. // change weights when using CQMs?
  326. // possible optimizations:
  327. // make scores fit in 32bit
  328. // save quantized coefs during rd, to avoid a duplicate trellis in the final encode
  329. // if trellissing all MBRD modes, finish SSD calculation so we can skip all of
  330. //   the normal dequant/idct/ssd/cabac
  331. // the unquant_mf here is not the same as dequant_mf:
  332. // in normal operation (dct->quant->dequant->idct) the dct and idct are not
  333. // normalized. quant/dequant absorb those scaling factors.
  334. // in this function, we just do (quant->unquant) and want the output to be
  335. // comparable to the input. so unquant is the direct inverse of quant,
  336. // and uses the dct scaling factors, not the idct ones.
  337. static ALWAYS_INLINE int quant_trellis_cabac( x264_t *h, int16_t *dct,
  338.                                  const uint16_t *quant_mf, const int *unquant_mf,
  339.                                  const int *coef_weight, const uint8_t *zigzag,
  340.                                  int i_ctxBlockCat, int i_lambda2, int b_ac, int dc, int i_coefs, int idx )
  341. {
  342.     int abs_coefs[64], signs[64];
  343.     trellis_node_t nodes[2][8];
  344.     trellis_node_t *nodes_cur = nodes[0];
  345.     trellis_node_t *nodes_prev = nodes[1];
  346.     trellis_node_t *bnode;
  347.     const int b_interlaced = h->mb.b_interlaced;
  348.     uint8_t *cabac_state_sig = &h->cabac.state[ significant_coeff_flag_offset[b_interlaced][i_ctxBlockCat] ];
  349.     uint8_t *cabac_state_last = &h->cabac.state[ last_coeff_flag_offset[b_interlaced][i_ctxBlockCat] ];
  350.     const int f = 1 << 15; // no deadzone
  351.     int i_last_nnz;
  352.     int i, j;
  353.     // (# of coefs) * (# of ctx) * (# of levels tried) = 1024
  354.     // we don't need to keep all of those: (# of coefs) * (# of ctx) would be enough,
  355.     // but it takes more time to remove dead states than you gain in reduced memory.
  356.     struct {
  357.         uint16_t abs_level;
  358.         uint16_t next;
  359.     } level_tree[64*8*2];
  360.     int i_levels_used = 1;
  361.     /* init coefs */
  362.     for( i = i_coefs-1; i >= b_ac; i-- )
  363.         if( (unsigned)(dct[zigzag[i]] * (dc?quant_mf[0]>>1:quant_mf[zigzag[i]]) + f-1) >= 2*f )
  364.             break;
  365.     if( i < b_ac )
  366.     {
  367.         /* We only need to memset an empty 4x4 block.  8x8 can be
  368.            implicitly emptied via zero nnz, as can dc. */
  369.         if( i_coefs == 16 && !dc )
  370.             memset( dct, 0, 16 * sizeof(int16_t) );
  371.         return 0;
  372.     }
  373.     i_last_nnz = i;
  374.     for( ; i >= b_ac; i-- )
  375.     {
  376.         int coef = dct[zigzag[i]];
  377.         abs_coefs[i] = abs(coef);
  378.         signs[i] = coef < 0 ? -1 : 1;
  379.     }
  380.     /* init trellis */
  381.     for( i = 1; i < 8; i++ )
  382.         nodes_cur[i].score = TRELLIS_SCORE_MAX;
  383.     nodes_cur[0].score = 0;
  384.     nodes_cur[0].level_idx = 0;
  385.     level_tree[0].abs_level = 0;
  386.     level_tree[0].next = 0;
  387.     // coefs are processed in reverse order, because that's how the abs value is coded.
  388.     // last_coef and significant_coef flags are normally coded in forward order, but
  389.     // we have to reverse them to match the levels.
  390.     // in 4x4 blocks, last_coef and significant_coef use a separate context for each
  391.     // position, so the order doesn't matter, and we don't even have to update their contexts.
  392.     // in 8x8 blocks, some positions share contexts, so we'll just have to hope that
  393.     // cabac isn't too sensitive.
  394.     memcpy( nodes_cur[0].cabac_state, &h->cabac.state[ coeff_abs_level_m1_offset[i_ctxBlockCat] ], 10 );
  395.     for( i = i_last_nnz; i >= b_ac; i-- )
  396.     {
  397.         int i_coef = abs_coefs[i];
  398.         int q = ( f + i_coef * (dc?quant_mf[0]>>1:quant_mf[zigzag[i]]) ) >> 16;
  399.         int abs_level;
  400.         int cost_sig[2], cost_last[2];
  401.         trellis_node_t n;
  402.         // skip 0s: this doesn't affect the output, but saves some unnecessary computation.
  403.         if( q == 0 )
  404.         {
  405.             // no need to calculate ssd of 0s: it's the same in all nodes.
  406.             // no need to modify level_tree for ctx=0: it starts with an infinite loop of 0s.
  407.             int sigindex = i_coefs == 64 ? significant_coeff_flag_offset_8x8[b_interlaced][i] : i;
  408.             const uint32_t cost_sig0 = x264_cabac_size_decision_noup2( &cabac_state_sig[sigindex], 0 )
  409.                                      * (uint64_t)i_lambda2 >> ( CABAC_SIZE_BITS - LAMBDA_BITS );
  410.             for( j = 1; j < 8; j++ )
  411.             {
  412.                 if( nodes_cur[j].score != TRELLIS_SCORE_MAX )
  413.                 {
  414. #define SET_LEVEL(n,l) 
  415.                     level_tree[i_levels_used].abs_level = l; 
  416.                     level_tree[i_levels_used].next = n.level_idx; 
  417.                     n.level_idx = i_levels_used; 
  418.                     i_levels_used++;
  419.                     SET_LEVEL( nodes_cur[j], 0 );
  420.                     nodes_cur[j].score += cost_sig0;
  421.                 }
  422.             }
  423.             continue;
  424.         }
  425.         XCHG( trellis_node_t*, nodes_cur, nodes_prev );
  426.         for( j = 0; j < 8; j++ )
  427.             nodes_cur[j].score = TRELLIS_SCORE_MAX;
  428.         if( i < i_coefs-1 )
  429.         {
  430.             int sigindex = i_coefs == 64 ? significant_coeff_flag_offset_8x8[b_interlaced][i] : i;
  431.             int lastindex = i_coefs == 64 ? last_coeff_flag_offset_8x8[i] : i;
  432.             cost_sig[0] = x264_cabac_size_decision_noup2( &cabac_state_sig[sigindex], 0 );
  433.             cost_sig[1] = x264_cabac_size_decision_noup2( &cabac_state_sig[sigindex], 1 );
  434.             cost_last[0] = x264_cabac_size_decision_noup2( &cabac_state_last[lastindex], 0 );
  435.             cost_last[1] = x264_cabac_size_decision_noup2( &cabac_state_last[lastindex], 1 );
  436.         }
  437.         else
  438.         {
  439.             cost_sig[0] = cost_sig[1] = 0;
  440.             cost_last[0] = cost_last[1] = 0;
  441.         }
  442.         // there are a few cases where increasing the coeff magnitude helps,
  443.         // but it's only around .003 dB, and skipping them ~doubles the speed of trellis.
  444.         // could also try q-2: that sometimes helps, but also sometimes decimates blocks
  445.         // that are better left coded, especially at QP > 40.
  446.         for( abs_level = q; abs_level >= q-1; abs_level-- )
  447.         {
  448.             int unquant_abs_level = (((dc?unquant_mf[0]<<1:unquant_mf[zigzag[i]]) * abs_level + 128) >> 8);
  449.             int d = i_coef - unquant_abs_level;
  450.             int64_t ssd;
  451.             /* Psy trellis: bias in favor of higher AC coefficients in the reconstructed frame. */
  452.             if( h->mb.i_psy_trellis && i && !dc && i_ctxBlockCat != DCT_CHROMA_AC )
  453.             {
  454.                 int orig_coef = (i_coefs == 64) ? h->mb.pic.fenc_dct8[idx][i] : h->mb.pic.fenc_dct4[idx][i];
  455.                 int predicted_coef = orig_coef - i_coef * signs[i];
  456.                 int psy_value = h->mb.i_psy_trellis * abs(predicted_coef + unquant_abs_level * signs[i]);
  457.                 int psy_weight = (i_coefs == 64) ? x264_dct8_weight_tab[zigzag[i]] : x264_dct4_weight_tab[zigzag[i]];
  458.                 ssd = (int64_t)d*d * coef_weight[i] - psy_weight * psy_value;
  459.             }
  460.             else
  461.             /* FIXME: for i16x16 dc is this weight optimal? */
  462.                 ssd = (int64_t)d*d * (dc?256:coef_weight[i]);
  463.             for( j = 0; j < 8; j++ )
  464.             {
  465.                 int node_ctx = j;
  466.                 if( nodes_prev[j].score == TRELLIS_SCORE_MAX )
  467.                     continue;
  468.                 n = nodes_prev[j];
  469.                 /* code the proposed level, and count how much entropy it would take */
  470.                 if( abs_level || node_ctx )
  471.                 {
  472.                     unsigned f8_bits = cost_sig[ abs_level != 0 ];
  473.                     if( abs_level )
  474.                     {
  475.                         const int i_prefix = X264_MIN( abs_level - 1, 14 );
  476.                         f8_bits += cost_last[ node_ctx == 0 ];
  477.                         f8_bits += x264_cabac_size_decision2( &n.cabac_state[coeff_abs_level1_ctx[node_ctx]], i_prefix > 0 );
  478.                         if( i_prefix > 0 )
  479.                         {
  480.                             uint8_t *ctx = &n.cabac_state[coeff_abs_levelgt1_ctx[node_ctx]];
  481.                             f8_bits += cabac_size_unary[i_prefix][*ctx];
  482.                             *ctx = cabac_transition_unary[i_prefix][*ctx];
  483.                             if( abs_level >= 15 )
  484.                                 f8_bits += bs_size_ue_big( abs_level - 15 ) << CABAC_SIZE_BITS;
  485.                             node_ctx = coeff_abs_level_transition[1][node_ctx];
  486.                         }
  487.                         else
  488.                         {
  489.                             f8_bits += 1 << CABAC_SIZE_BITS;
  490.                             node_ctx = coeff_abs_level_transition[0][node_ctx];
  491.                         }
  492.                     }
  493.                     n.score += (uint64_t)f8_bits * i_lambda2 >> ( CABAC_SIZE_BITS - LAMBDA_BITS );
  494.                 }
  495.                 if( j || i || dc )
  496.                     n.score += ssd;
  497.                 /* Optimize rounding for DC coefficients in DC-only luma 4x4/8x8 blocks. */
  498.                 else
  499.                 {
  500.                     d = i_coef * signs[0] - ((unquant_abs_level * signs[0] + 8)&~15);
  501.                     n.score += (int64_t)d*d * coef_weight[i];
  502.                 }
  503.                 /* save the node if it's better than any existing node with the same cabac ctx */
  504.                 if( n.score < nodes_cur[node_ctx].score )
  505.                 {
  506.                     SET_LEVEL( n, abs_level );
  507.                     nodes_cur[node_ctx] = n;
  508.                 }
  509.             }
  510.         }
  511.     }
  512.     /* output levels from the best path through the trellis */
  513.     bnode = &nodes_cur[0];
  514.     for( j = 1; j < 8; j++ )
  515.         if( nodes_cur[j].score < bnode->score )
  516.             bnode = &nodes_cur[j];
  517.     if( bnode == &nodes_cur[0] )
  518.     {
  519.         if( i_coefs == 16 && !dc )
  520.             memset( dct, 0, 16 * sizeof(int16_t) );
  521.         return 0;
  522.     }
  523.     j = bnode->level_idx;
  524.     for( i = b_ac; j; i++ )
  525.     {
  526.         dct[zigzag[i]] = level_tree[j].abs_level * signs[i];
  527.         j = level_tree[j].next;
  528.     }
  529.     for( ; i < i_coefs; i++ )
  530.         dct[zigzag[i]] = 0;
  531.     return 1;
  532. }
  533. const static uint8_t x264_zigzag_scan2[4] = {0,1,2,3};
  534. int x264_quant_dc_trellis( x264_t *h, int16_t *dct, int i_quant_cat,
  535.                             int i_qp, int i_ctxBlockCat, int b_intra, int b_chroma )
  536. {
  537.     return quant_trellis_cabac( h, (int16_t*)dct,
  538.         h->quant4_mf[i_quant_cat][i_qp], h->unquant4_mf[i_quant_cat][i_qp],
  539.         NULL, i_ctxBlockCat==DCT_CHROMA_DC ? x264_zigzag_scan2 : x264_zigzag_scan4[h->mb.b_interlaced],
  540.         i_ctxBlockCat, h->mb.i_trellis_lambda2[b_chroma][b_intra], 0, 1, i_ctxBlockCat==DCT_CHROMA_DC ? 4 : 16, 0 );
  541. }
  542. int x264_quant_4x4_trellis( x264_t *h, int16_t dct[4][4], int i_quant_cat,
  543.                              int i_qp, int i_ctxBlockCat, int b_intra, int b_chroma, int idx )
  544. {
  545.     int b_ac = (i_ctxBlockCat == DCT_LUMA_AC || i_ctxBlockCat == DCT_CHROMA_AC);
  546.     return quant_trellis_cabac( h, (int16_t*)dct,
  547.         h->quant4_mf[i_quant_cat][i_qp], h->unquant4_mf[i_quant_cat][i_qp],
  548.         x264_dct4_weight2_zigzag[h->mb.b_interlaced],
  549.         x264_zigzag_scan4[h->mb.b_interlaced],
  550.         i_ctxBlockCat, h->mb.i_trellis_lambda2[b_chroma][b_intra], b_ac, 0, 16, idx );
  551. }
  552. int x264_quant_8x8_trellis( x264_t *h, int16_t dct[8][8], int i_quant_cat,
  553.                              int i_qp, int b_intra, int idx )
  554. {
  555.     return quant_trellis_cabac( h, (int16_t*)dct,
  556.         h->quant8_mf[i_quant_cat][i_qp], h->unquant8_mf[i_quant_cat][i_qp],
  557.         x264_dct8_weight2_zigzag[h->mb.b_interlaced],
  558.         x264_zigzag_scan8[h->mb.b_interlaced],
  559.         DCT_LUMA_8x8, h->mb.i_trellis_lambda2[0][b_intra], 0, 0, 64, idx );
  560. }