/*****************************************************************************
* cabac.c: h264 encoder library
*****************************************************************************
- * Copyright (C) 2003 Laurent Aimar
- * $Id: cabac.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
+ * Copyright (C) 2003-2008 x264 project
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ * Loren Merritt <lorenm@u.washington.edu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*****************************************************************************/
-#include <stdio.h>
-#include <string.h>
-
#include "common/common.h"
#include "macroblock.h"
-static inline void x264_cabac_encode_ue_bypass( x264_cabac_t *cb, int exp_bits, int val )
-{
-#ifdef RDO_SKIP_BS
- cb->f8_bits_encoded += ( bs_size_ue( val + (1<<exp_bits)-1 ) - exp_bits ) << 8;
-#else
- int k;
- for( k = exp_bits; val >= (1<<k); k++ )
- {
- x264_cabac_encode_bypass( cb, 1 );
- val -= 1 << k;
- }
- x264_cabac_encode_bypass( cb, 0 );
- while( k-- )
- x264_cabac_encode_bypass( cb, (val >> k)&0x01 );
-#endif
-}
-
static inline void x264_cabac_mb_type_intra( x264_t *h, x264_cabac_t *cb, int i_mb_type,
int ctx0, int ctx1, int ctx2, int ctx3, int ctx4, int ctx5 )
{
else if( i_mb_type == I_PCM )
{
x264_cabac_encode_decision( cb, ctx0, 1 );
- x264_cabac_encode_terminal( cb, 1 );
- x264_cabac_encode_flush( cb );
+ x264_cabac_encode_flush( h, cb );
}
else
{
int i_pred = x264_mb_pred_mode16x16_fix[h->mb.i_intra16x16_pred_mode];
x264_cabac_encode_decision( cb, ctx0, 1 );
- x264_cabac_encode_terminal( cb, 0 );
+ x264_cabac_encode_terminal( cb );
- x264_cabac_encode_decision( cb, ctx1, ( h->mb.i_cbp_luma == 0 ? 0 : 1 ));
+ x264_cabac_encode_decision( cb, ctx1, !!h->mb.i_cbp_luma );
if( h->mb.i_cbp_chroma == 0 )
{
x264_cabac_encode_decision( cb, ctx2, 0 );
else
{
x264_cabac_encode_decision( cb, ctx2, 1 );
- x264_cabac_encode_decision( cb, ctx3, ( h->mb.i_cbp_chroma == 1 ? 0 : 1 ) );
+ x264_cabac_encode_decision( cb, ctx3, h->mb.i_cbp_chroma != 1 );
}
- x264_cabac_encode_decision( cb, ctx4, ( (i_pred / 2) ? 1 : 0 ));
- x264_cabac_encode_decision( cb, ctx5, ( (i_pred % 2) ? 1 : 0 ));
+ x264_cabac_encode_decision( cb, ctx4, i_pred>>1 );
+ x264_cabac_encode_decision( cb, ctx5, i_pred&1 );
}
}
static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
{
- /* TODO: clean up and optimize */
- int i8x8;
- for( i8x8 = 0; i8x8 < 4; i8x8++ )
- {
- int i_mba_xy = -1;
- int i_mbb_xy = -1;
- int x = block_idx_x[4*i8x8];
- int y = block_idx_y[4*i8x8];
- int ctx = 0;
-
- if( x > 0 )
- i_mba_xy = h->mb.i_mb_xy;
- else if( h->mb.i_neighbour & MB_LEFT )
- i_mba_xy = h->mb.i_mb_xy - 1;
-
- if( y > 0 )
- i_mbb_xy = h->mb.i_mb_xy;
- else if( h->mb.i_neighbour & MB_TOP )
- i_mbb_xy = h->mb.i_mb_top_xy;
-
-
- /* No need to test for PCM and SKIP */
- if( i_mba_xy >= 0 )
- {
- const int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
- if( ((h->mb.cbp[i_mba_xy] >> i8x8a)&0x01) == 0 )
- {
- ctx++;
- }
- }
-
- if( i_mbb_xy >= 0 )
- {
- const int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
- if( ((h->mb.cbp[i_mbb_xy] >> i8x8b)&0x01) == 0 )
- {
- ctx += 2;
- }
- }
-
- x264_cabac_encode_decision( cb, 73 + ctx, (h->mb.i_cbp_luma >> i8x8)&0x01 );
- }
+ int cbp = h->mb.i_cbp_luma;
+ int cbp_l = h->mb.i_neighbour & MB_LEFT ? h->mb.cbp[h->mb.i_mb_xy - 1] : -1;
+ int cbp_t = h->mb.i_neighbour & MB_TOP ? h->mb.cbp[h->mb.i_mb_top_xy] : -1;
+ x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 1) & 1) - ((cbp_t >> 1) & 2), (h->mb.i_cbp_luma >> 0) & 1 );
+ x264_cabac_encode_decision( cb, 76 - ((cbp >> 0) & 1) - ((cbp_t >> 2) & 2), (h->mb.i_cbp_luma >> 1) & 1 );
+ x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 3) & 1) - ((cbp << 1) & 2), (h->mb.i_cbp_luma >> 2) & 1 );
+ x264_cabac_encode_decision( cb, 76 - ((cbp >> 2) & 1) - ((cbp >> 0) & 2), (h->mb.i_cbp_luma >> 3) & 1 );
}
static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
int ctx;
+ /* Avoid writing a delta quant if we have an empty i16x16 block, e.g. in a completely flat background area */
+ if( h->mb.i_type == I_16x16 && !h->mb.cbp[h->mb.i_mb_xy] )
+ {
+#ifndef RDO_SKIP_BS
+ h->mb.i_qp = h->mb.i_last_qp;
+#endif
+ i_dqp = 0;
+ }
+
/* No need to test for PCM / SKIP */
- if( h->mb.i_neighbour && h->mb.i_last_dqp != 0 &&
+ if( h->mb.i_last_dqp &&
( h->mb.type[i_mbn_xy] == I_16x16 || (h->mb.cbp[i_mbn_xy]&0x3f) ) )
ctx = 1;
else
x264_cabac_encode_decision( cb, 60 + ctx, 0 );
}
+#ifndef RDO_SKIP_BS
void x264_cabac_mb_skip( x264_t *h, int b_skip )
{
- int ctx = 0;
-
- if( h->mb.i_mb_type_left >= 0 && !IS_SKIP( h->mb.i_mb_type_left ) )
- {
- ctx++;
- }
- if( h->mb.i_mb_type_top >= 0 && !IS_SKIP( h->mb.i_mb_type_top ) )
- {
- ctx++;
- }
-
- ctx += (h->sh.i_type == SLICE_TYPE_P) ? 11 : 24;
+ int ctx = (h->mb.i_mb_type_left >= 0 && !IS_SKIP( h->mb.i_mb_type_left ))
+ + (h->mb.i_mb_type_top >= 0 && !IS_SKIP( h->mb.i_mb_type_top ))
+ + (h->sh.i_type == SLICE_TYPE_P ? 11 : 24);
x264_cabac_encode_decision( &h->cabac, ctx, b_skip );
}
+#endif
static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
{
}
}
-static inline void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
+static NOINLINE void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
{
-#define WRITE_SUB_3(a,b,c) {\
- x264_cabac_encode_decision( cb, 36, a );\
- x264_cabac_encode_decision( cb, 37, b );\
- x264_cabac_encode_decision( cb, 39, c );\
- }
-#define WRITE_SUB_5(a,b,c,d,e) {\
- x264_cabac_encode_decision( cb, 36, a );\
- x264_cabac_encode_decision( cb, 37, b );\
- x264_cabac_encode_decision( cb, 38, c );\
- x264_cabac_encode_decision( cb, 39, d );\
- x264_cabac_encode_decision( cb, 39, e );\
- }
-#define WRITE_SUB_6(a,b,c,d,e,f) {\
- WRITE_SUB_5(a,b,c,d,e)\
- x264_cabac_encode_decision( cb, 39, f );\
+ static const uint8_t part_bits[12][7] = {
+ {6,1,1,1,0,1,1}, // D_L0_4x4
+ {5,1,1,0,0,1}, // D_L0_8x4
+ {5,1,1,0,1,0}, // D_L0_4x8
+ {3,1,0,0}, // D_L0_8x8
+ {5,1,1,1,1,0}, // D_L1_4x4
+ {5,1,1,0,1,1}, // D_L1_8x4
+ {6,1,1,1,0,0,0}, // D_L1_4x8
+ {3,1,0,1}, // D_L1_8x8
+ {5,1,1,1,1,1}, // D_BI_4x4
+ {6,1,1,1,0,0,1}, // D_BI_8x4
+ {6,1,1,1,0,1,0}, // D_BI_4x8
+ {5,1,1,0,0,0}, // D_BI_8x8
+ };
+ int len;
+ if( i_sub == D_DIRECT_8x8 )
+ {
+ x264_cabac_encode_decision( cb, 36, 0 );
+ return;
}
-
- switch( i_sub )
+ len = part_bits[i_sub][0];
+ x264_cabac_encode_decision( cb, 36, part_bits[i_sub][1] );
+ x264_cabac_encode_decision( cb, 37, part_bits[i_sub][2] );
+ if( len == 3 )
+ x264_cabac_encode_decision( cb, 39, part_bits[i_sub][3] );
+ else
{
- case D_DIRECT_8x8:
- x264_cabac_encode_decision( cb, 36, 0 );
- break;
- case D_L0_8x8: WRITE_SUB_3(1,0,0); break;
- case D_L1_8x8: WRITE_SUB_3(1,0,1); break;
- case D_BI_8x8: WRITE_SUB_5(1,1,0,0,0); break;
- case D_L0_8x4: WRITE_SUB_5(1,1,0,0,1); break;
- case D_L0_4x8: WRITE_SUB_5(1,1,0,1,0); break;
- case D_L1_8x4: WRITE_SUB_5(1,1,0,1,1); break;
- case D_L1_4x8: WRITE_SUB_6(1,1,1,0,0,0); break;
- case D_BI_8x4: WRITE_SUB_6(1,1,1,0,0,1); break;
- case D_BI_4x8: WRITE_SUB_6(1,1,1,0,1,0); break;
- case D_L0_4x4: WRITE_SUB_6(1,1,1,0,1,1); break;
- case D_L1_4x4: WRITE_SUB_5(1,1,1,1,0); break;
- case D_BI_4x4: WRITE_SUB_5(1,1,1,1,1); break;
+ x264_cabac_encode_decision( cb, 38, part_bits[i_sub][3] );
+ x264_cabac_encode_decision( cb, 39, part_bits[i_sub][4] );
+ x264_cabac_encode_decision( cb, 39, part_bits[i_sub][5] );
+ if( len == 6 )
+ x264_cabac_encode_decision( cb, 39, part_bits[i_sub][6] );
}
}
static inline void x264_cabac_mb_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd )
{
+ static const uint8_t transition[7] = { 3,3,3,4,5,6,6 };
const int amvd = abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 1][l] ) +
abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 8][l] );
const int i_abs = abs( mvd );
const int i_prefix = X264_MIN( i_abs, 9 );
- const int ctxbase = (l == 0 ? 40 : 47);
- int ctx;
+ const int ctxbase = l ? 47 : 40;
+ int ctx = (amvd>2) + (amvd>32);
int i;
-
- if( amvd < 3 )
- ctx = 0;
- else if( amvd > 32 )
- ctx = 2;
- else
- ctx = 1;
-
for( i = 0; i < i_prefix; i++ )
{
x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
- if( ctx < 3 )
- ctx = 3;
- else if( ctx < 6 )
- ctx++;
+ ctx = transition[ctx];
}
if( i_prefix < 9 )
x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
static inline void x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width, int height )
{
- int mvp[2];
+ DECLARE_ALIGNED_4( int16_t mvp[2] );
int mdx, mdy;
/* Calculate mvd */
x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy );
/* save value */
- x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, mdx, mdy );
+ x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, pack16to32_mask(mdx,mdy) );
}
static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int i )
static int x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx )
{
+ /* i_ctxBlockCat: 0-> DC 16x16 i_idx = 0
+ * 1-> AC 16x16 i_idx = luma4x4idx
+ * 2-> Luma4x4 i_idx = luma4x4idx
+ * 3-> DC Chroma i_idx = iCbCr
+ * 4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
+ * 5-> Luma8x8 i_idx = luma8x8idx
+ */
+
int i_mba_xy = -1;
int i_mbb_xy = -1;
int i_nza = 0;
int i_nzb = 0;
- int ctx;
if( i_cat == DCT_LUMA_DC )
{
if( h->mb.i_neighbour & MB_LEFT )
{
i_mba_xy = h->mb.i_mb_xy - 1;
- if( h->mb.i_mb_type_left == I_16x16 )
- i_nza = h->mb.cbp[i_mba_xy] & 0x100;
+ i_nza = h->mb.cbp[i_mba_xy] & 0x100;
}
if( h->mb.i_neighbour & MB_TOP )
{
i_mbb_xy = h->mb.i_mb_top_xy;
- if( h->mb.i_mb_type_top == I_16x16 )
- i_nzb = h->mb.cbp[i_mbb_xy] & 0x100;
+ i_nzb = h->mb.cbp[i_mbb_xy] & 0x100;
}
}
else if( i_cat == DCT_LUMA_AC || i_cat == DCT_LUMA_4x4 )
/* no need to test skip/pcm */
if( i_mba_xy >= 0 )
- i_nza = h->mb.cache.non_zero_count[x264_scan8[16+i_idx] - 1];
+ i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
if( i_mbb_xy >= 0 )
- i_nzb = h->mb.cache.non_zero_count[x264_scan8[16+i_idx] - 8];
+ i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
}
if( IS_INTRA( h->mb.i_type ) )
{
- if( i_mba_xy < 0 )
- i_nza = 1;
- if( i_mbb_xy < 0 )
- i_nzb = 1;
+ i_nza |= i_mba_xy < 0;
+ i_nzb |= i_mbb_xy < 0;
}
- ctx = 4 * i_cat;
- if( i_nza )
- ctx += 1;
- if( i_nzb )
- ctx += 2;
- return ctx;
+ return 4*i_cat + 2*!!i_nzb + !!i_nza;
}
-static const int significant_coeff_flag_offset[2][6] = {
+static const uint16_t significant_coeff_flag_offset[2][6] = {
{ 105, 120, 134, 149, 152, 402 },
{ 277, 292, 306, 321, 324, 436 }
};
-static const int last_coeff_flag_offset[2][6] = {
+static const uint16_t last_coeff_flag_offset[2][6] = {
{ 166, 181, 195, 210, 213, 417 },
{ 338, 353, 367, 382, 385, 451 }
};
-static const int coeff_abs_level_m1_offset[6] =
+static const uint16_t coeff_abs_level_m1_offset[6] =
{ 227, 237, 247, 257, 266, 426 };
-static const int significant_coeff_flag_offset_8x8[2][63] =
+static const uint8_t significant_coeff_flag_offset_8x8[2][63] =
{{
0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14
}};
-static const int last_coeff_flag_offset_8x8[63] = {
+static const uint8_t last_coeff_flag_offset_8x8[63] = {
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
};
-static const int identity[16] =
+static const uint8_t identity[16] =
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
-static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int i_idx, int *l, int i_count )
+// node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
+// 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
+/* map node ctx => cabac ctx for level=1 */
+static const int coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
+/* map node ctx => cabac ctx for level>1 */
+static const int coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
+static const uint8_t coeff_abs_level_transition[2][8] = {
+/* update node ctx after coding a level=1 */
+ { 1, 2, 3, 3, 4, 5, 6, 7 },
+/* update node ctx after coding a level>1 */
+ { 4, 4, 4, 4, 5, 6, 7, 7 }
+};
+
+static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int i_idx, int16_t *l, int i_count )
{
const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
int i_coeff_abs_m1[64];
- int i_coeff_sign[64];
+ int UNUSED i_coeff_sign[64];
int i_coeff = 0;
int i_last = 0;
int i_sigmap_size;
+ int node_ctx = 0;
+ int i, j;
- int i_abslevel1 = 0;
- int i_abslevelgt1 = 0;
-
- int i;
-
- const int *significant_coeff_flag_offset;
- const int *last_coeff_flag_offset;
-
- /* i_ctxBlockCat: 0-> DC 16x16 i_idx = 0
- * 1-> AC 16x16 i_idx = luma4x4idx
- * 2-> Luma4x4 i_idx = luma4x4idx
- * 3-> DC Chroma i_idx = iCbCr
- * 4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
- * 5-> Luma8x8 i_idx = luma8x8idx
- */
-
- for( i = 0; i < i_count; i++ )
- {
- if( l[i] != 0 )
- {
- i_coeff_abs_m1[i_coeff] = abs( l[i] ) - 1;
- i_coeff_sign[i_coeff] = ( l[i] < 0 );
- i_coeff++;
+ const uint8_t *significant_coeff_flag_offset;
+ const uint8_t *last_coeff_flag_offset;
- i_last = i;
- }
- }
+ /* yes this is always aligned, and l[-1] exists in the cases where it's used (ac) */
+ for( j = i_count - 4; j >= -1; j -= 4 )
+ if( *(uint64_t*)(l+j) )
+ break;
if( i_count != 64 )
{
/* coded block flag */
- x264_cabac_encode_decision( cb, 85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx ), i_coeff != 0 );
- if( i_coeff == 0 )
+ int ctx = 85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx );
+ if( j >= -1 )
+ x264_cabac_encode_decision( cb, ctx, 1 );
+ else
+ {
+ x264_cabac_encode_decision( cb, ctx, 0 );
return;
+ }
}
significant_coeff_flag_offset = (i_ctxBlockCat == DCT_LUMA_8x8)
last_coeff_flag_offset = (i_ctxBlockCat == DCT_LUMA_8x8)
? last_coeff_flag_offset_8x8 : identity;
+ for( i = j; i < j+4; i++)
+ if( l[i] )
+ i_last = i;
+
i_sigmap_size = X264_MIN( i_last+1, i_count-1 );
+
for( i = 0; i < i_sigmap_size; i++ )
{
- x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], l[i] != 0 );
- if( l[i] != 0 )
+ if( l[i] )
+ {
+ i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
+#ifndef RDO_SKIP_BS
+ i_coeff_sign[i_coeff] = l[i] < 0;
+#endif
+ i_coeff++;
+ x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], 1 );
x264_cabac_encode_decision( cb, i_ctx_last + last_coeff_flag_offset[i], i == i_last );
+ }
+ else
+ x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], 0 );
+ }
+
+ if( i == i_last )
+ {
+ i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
+#ifndef RDO_SKIP_BS
+ i_coeff_sign[i_coeff] = l[i] < 0;
+#endif
+ i_coeff++;
}
for( i = i_coeff - 1; i >= 0; i-- )
{
/* write coeff_abs - 1 */
- const int i_prefix = X264_MIN( i_coeff_abs_m1[i], 14 );
- const int i_ctxIdxInc = (i_abslevelgt1 ? 0 : X264_MIN( 4, i_abslevel1 + 1 )) + i_ctx_level;
- x264_cabac_encode_decision( cb, i_ctxIdxInc, i_prefix != 0 );
+ int i_prefix = X264_MIN( i_coeff_abs_m1[i], 14 );
+ int ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
- if( i_prefix != 0 )
+ if( i_prefix )
{
- const int i_ctxIdxInc = 5 + X264_MIN( 4, i_abslevelgt1 ) + i_ctx_level;
- int j;
+ x264_cabac_encode_decision( cb, ctx, 1 );
+ ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
+#ifdef RDO_SKIP_BS
+ cb->f8_bits_encoded += cabac_prefix_size[i_prefix][cb->state[ctx]];
+ cb->state[ctx] = cabac_prefix_transition[i_prefix][cb->state[ctx]];
+#else
for( j = 0; j < i_prefix - 1; j++ )
- x264_cabac_encode_decision( cb, i_ctxIdxInc, 1 );
+ x264_cabac_encode_decision( cb, ctx, 1 );
if( i_prefix < 14 )
- x264_cabac_encode_decision( cb, i_ctxIdxInc, 0 );
- else /* suffix */
+ x264_cabac_encode_decision( cb, ctx, 0 );
+#endif
+ if( i_prefix >= 14 )
x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i] - 14 );
- i_abslevelgt1++;
+ node_ctx = coeff_abs_level_transition[1][node_ctx];
}
else
- i_abslevel1++;
+ {
+ x264_cabac_encode_decision( cb, ctx, 0 );
+ node_ctx = coeff_abs_level_transition[0][node_ctx];
+#ifdef RDO_SKIP_BS
+ x264_cabac_encode_bypass( cb, 0 ); // sign
+#endif
+ }
- /* write sign */
+#ifndef RDO_SKIP_BS
x264_cabac_encode_bypass( cb, i_coeff_sign[i] );
+#endif
}
}
/* Write the MB type */
x264_cabac_mb_type( h, cb );
- /* PCM special block type UNTESTED */
+#ifndef RDO_SKIP_BS
if( i_mb_type == I_PCM )
{
-#ifdef RDO_SKIP_BS
- cb->f8_bits_encoded += (384*8) << 8;
-#else
- bs_t *s = cb->s;
- bs_align_0( s ); /* not sure */
- /* Luma */
- for( i = 0; i < 16*16; i++ )
- {
- const int x = 16 * h->mb.i_mb_x + (i % 16);
- const int y = 16 * h->mb.i_mb_y + (i / 16);
- bs_write( s, 8, h->fenc->plane[0][y*h->mb.pic.i_stride[0]+x] );
- }
- /* Cb */
- for( i = 0; i < 8*8; i++ )
- {
- const int x = 8 * h->mb.i_mb_x + (i % 8);
- const int y = 8 * h->mb.i_mb_y + (i / 8);
- bs_write( s, 8, h->fenc->plane[1][y*h->mb.pic.i_stride[1]+x] );
- }
- /* Cr */
- for( i = 0; i < 8*8; i++ )
- {
- const int x = 8 * h->mb.i_mb_x + (i % 8);
- const int y = 8 * h->mb.i_mb_y + (i / 8);
- bs_write( s, 8, h->fenc->plane[2][y*h->mb.pic.i_stride[2]+x] );
- }
- x264_cabac_encode_init( cb, s );
-#endif
+ i_mb_pos_tex = x264_cabac_pos( cb );
+ h->stat.frame.i_hdr_bits += i_mb_pos_tex - i_mb_pos_start;
+
+ memcpy( cb->p, h->mb.pic.p_fenc[0], 256 );
+ cb->p += 256;
+ for( i = 0; i < 8; i++ )
+ memcpy( cb->p + i*8, h->mb.pic.p_fenc[1] + i*FENC_STRIDE, 8 );
+ cb->p += 64;
+ for( i = 0; i < 8; i++ )
+ memcpy( cb->p + i*8, h->mb.pic.p_fenc[2] + i*FENC_STRIDE, 8 );
+ cb->p += 64;
+
+ cb->i_low = 0;
+ cb->i_range = 0x01FE;
+ cb->i_queue = -1;
+ cb->i_bytes_outstanding = 0;
+
+ /* if PCM is chosen, we need to store reconstructed frame data */
+ h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc[0], FENC_STRIDE, 16 );
+ h->mc.copy[PIXEL_8x8] ( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE, 8 );
+ h->mc.copy[PIXEL_8x8] ( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE, 8 );
+
+ h->stat.frame.i_itex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
return;
}
+#endif
if( IS_INTRA( i_mb_type ) )
{
x264_cabac_mb_cbp_chroma( h, cb );
}
- if( h->mb.cache.b_transform_8x8_allowed && h->mb.i_cbp_luma && !IS_INTRA(i_mb_type) )
+ if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
{
x264_cabac_mb_transform_size( h, cb );
}
/* AC Luma */
if( h->mb.i_cbp_luma != 0 )
for( i = 0; i < 16; i++ )
- block_residual_write_cabac( h, cb, DCT_LUMA_AC, i, h->dct.block[i].residual_ac, 15 );
+ block_residual_write_cabac( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 15 );
}
else if( h->mb.b_transform_8x8 )
{
{
for( i = 0; i < 16; i++ )
if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
- block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i, h->dct.block[i].luma4x4, 16 );
+ block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], 16 );
}
if( h->mb.i_cbp_chroma &0x03 ) /* Chroma DC residual present */
}
if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
{
- for( i = 0; i < 8; i++ )
- block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.block[16+i].residual_ac, 15 );
+ for( i = 16; i < 24; i++ )
+ block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );
}
}
{
int i4;
for( i4 = 0; i4 < 4; i4++ )
- block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.block[i4+i8*4].luma4x4, 16 );
+ block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 16 );
}
}
- block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i8, h->dct.block[16+i8 ].residual_ac, 15 );
- block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i8+4, h->dct.block[16+i8+4].residual_ac, 15 );
+ block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 15 );
+ block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 15 );
i8 += x264_pixel_size[i_pixel].h >> 3;
}
const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
i_mode = x264_mb_pred_mode4x4_fix( i_mode );
x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
- block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4, h->dct.block[i4].luma4x4, 16 );
+ block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 16 );
}
static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
if( h->mb.i_cbp_chroma == 2 )
{
int i;
- for( i = 0; i < 8; i++ )
- block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.block[16+i].residual_ac, 15 );
+ for( i = 16; i < 24; i++ )
+ block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );
}
}
}
projects / x264 / blobdiff