1 /*****************************************************************************
2 * cabac.c: h264 encoder library
3 *****************************************************************************
4 * Copyright (C) 2003-2008 x264 project
6 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7 * Loren Merritt <lorenm@u.washington.edu>
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.
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.
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 *****************************************************************************/
24 #include "common/common.h"
25 #include "macroblock.h"
27 static inline void x264_cabac_mb_type_intra( x264_t *h, x264_cabac_t *cb, int i_mb_type,
28 int ctx0, int ctx1, int ctx2, int ctx3, int ctx4, int ctx5 )
30 if( i_mb_type == I_4x4 || i_mb_type == I_8x8 )
32 x264_cabac_encode_decision( cb, ctx0, 0 );
34 else if( i_mb_type == I_PCM )
36 x264_cabac_encode_decision( cb, ctx0, 1 );
37 x264_cabac_encode_flush( h, cb );
41 int i_pred = x264_mb_pred_mode16x16_fix[h->mb.i_intra16x16_pred_mode];
43 x264_cabac_encode_decision( cb, ctx0, 1 );
44 x264_cabac_encode_terminal( cb );
46 x264_cabac_encode_decision( cb, ctx1, !!h->mb.i_cbp_luma );
47 if( h->mb.i_cbp_chroma == 0 )
49 x264_cabac_encode_decision( cb, ctx2, 0 );
53 x264_cabac_encode_decision( cb, ctx2, 1 );
54 x264_cabac_encode_decision( cb, ctx3, h->mb.i_cbp_chroma != 1 );
56 x264_cabac_encode_decision( cb, ctx4, i_pred>>1 );
57 x264_cabac_encode_decision( cb, ctx5, i_pred&1 );
61 static void x264_cabac_mb_type( x264_t *h, x264_cabac_t *cb )
63 const int i_mb_type = h->mb.i_type;
66 (!(h->mb.i_mb_y & 1) || IS_SKIP(h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride])) )
68 x264_cabac_encode_decision( cb, 70 + h->mb.cache.i_neighbour_interlaced, h->mb.b_interlaced );
71 if( h->sh.i_type == SLICE_TYPE_I )
74 if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != I_4x4 )
78 if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != I_4x4 )
83 x264_cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
85 else if( h->sh.i_type == SLICE_TYPE_P )
87 /* prefix: 14, suffix: 17 */
88 if( i_mb_type == P_L0 )
90 if( h->mb.i_partition == D_16x16 )
92 x264_cabac_encode_decision( cb, 14, 0 );
93 x264_cabac_encode_decision( cb, 15, 0 );
94 x264_cabac_encode_decision( cb, 16, 0 );
96 else if( h->mb.i_partition == D_16x8 )
98 x264_cabac_encode_decision( cb, 14, 0 );
99 x264_cabac_encode_decision( cb, 15, 1 );
100 x264_cabac_encode_decision( cb, 17, 1 );
102 else if( h->mb.i_partition == D_8x16 )
104 x264_cabac_encode_decision( cb, 14, 0 );
105 x264_cabac_encode_decision( cb, 15, 1 );
106 x264_cabac_encode_decision( cb, 17, 0 );
109 else if( i_mb_type == P_8x8 )
111 x264_cabac_encode_decision( cb, 14, 0 );
112 x264_cabac_encode_decision( cb, 15, 0 );
113 x264_cabac_encode_decision( cb, 16, 1 );
118 x264_cabac_encode_decision( cb, 14, 1 );
121 x264_cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
124 else if( h->sh.i_type == SLICE_TYPE_B )
127 if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != B_SKIP && h->mb.i_mb_type_left != B_DIRECT )
131 if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
136 if( i_mb_type == B_DIRECT )
138 x264_cabac_encode_decision( cb, 27+ctx, 0 );
140 else if( i_mb_type == B_8x8 )
142 x264_cabac_encode_decision( cb, 27+ctx, 1 );
143 x264_cabac_encode_decision( cb, 27+3, 1 );
144 x264_cabac_encode_decision( cb, 27+4, 1 );
146 x264_cabac_encode_decision( cb, 27+5, 1 );
147 x264_cabac_encode_decision( cb, 27+5, 1 );
148 x264_cabac_encode_decision( cb, 27+5, 1 );
150 else if( IS_INTRA( i_mb_type ) )
153 x264_cabac_encode_decision( cb, 27+ctx, 1 );
154 x264_cabac_encode_decision( cb, 27+3, 1 );
155 x264_cabac_encode_decision( cb, 27+4, 1 );
157 x264_cabac_encode_decision( cb, 27+5, 1 );
158 x264_cabac_encode_decision( cb, 27+5, 0 );
159 x264_cabac_encode_decision( cb, 27+5, 1 );
162 x264_cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
166 static const int i_mb_len[9*3] =
178 static const int i_mb_bits[9*3][7] =
180 { 1,1,0,0,0,1 }, { 1,1,0,0,1,0, }, { 1,0,0 }, /* L0 L0 */
181 { 1,1,0,1,0,1 }, { 1,1,0,1,1,0 }, {0}, /* L0 L1 */
182 { 1,1,1,0,0,0,0 }, { 1,1,1,0,0,0,1 }, {0}, /* L0 BI */
183 { 1,1,0,1,1,1 }, { 1,1,1,1,1,0 }, {0}, /* L1 L0 */
184 { 1,1,0,0,1,1 }, { 1,1,0,1,0,0 }, { 1,0,1 }, /* L1 L1 */
185 { 1,1,1,0,0,1,0 }, { 1,1,1,0,0,1,1 }, {0}, /* L1 BI */
186 { 1,1,1,0,1,0,0 }, { 1,1,1,0,1,0,1 }, {0}, /* BI L0 */
187 { 1,1,1,0,1,1,0 }, { 1,1,1,0,1,1,1 }, {0}, /* BI L1 */
188 { 1,1,1,1,0,0,0 }, { 1,1,1,1,0,0,1 }, { 1,1,0,0,0,0 }, /* BI BI */
191 const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
194 x264_cabac_encode_decision( cb, 27+ctx, i_mb_bits[idx][0] );
195 x264_cabac_encode_decision( cb, 27+3, i_mb_bits[idx][1] );
196 x264_cabac_encode_decision( cb, 27+5-i_mb_bits[idx][1], i_mb_bits[idx][2] );
197 for( i = 3; i < i_mb_len[idx]; i++ )
198 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][i] );
203 x264_log(h, X264_LOG_ERROR, "unknown SLICE_TYPE unsupported in x264_macroblock_write_cabac\n" );
207 static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
209 if( i_pred == i_mode )
211 /* b_prev_intra4x4_pred_mode */
212 x264_cabac_encode_decision( cb, 68, 1 );
216 /* b_prev_intra4x4_pred_mode */
217 x264_cabac_encode_decision( cb, 68, 0 );
218 if( i_mode > i_pred )
222 x264_cabac_encode_decision( cb, 69, (i_mode )&0x01 );
223 x264_cabac_encode_decision( cb, 69, (i_mode >> 1)&0x01 );
224 x264_cabac_encode_decision( cb, 69, (i_mode >> 2)&0x01 );
228 static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
230 const int i_mode = x264_mb_pred_mode8x8c_fix[ h->mb.i_chroma_pred_mode ];
233 /* No need to test for I4x4 or I_16x16 as cache_save handle that */
234 if( (h->mb.i_neighbour & MB_LEFT) && h->mb.chroma_pred_mode[h->mb.i_mb_xy - 1] != 0 )
238 if( (h->mb.i_neighbour & MB_TOP) && h->mb.chroma_pred_mode[h->mb.i_mb_top_xy] != 0 )
243 x264_cabac_encode_decision( cb, 64 + ctx, i_mode > 0 );
246 x264_cabac_encode_decision( cb, 64 + 3, i_mode > 1 );
249 x264_cabac_encode_decision( cb, 64 + 3, i_mode > 2 );
254 static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
256 int cbp = h->mb.i_cbp_luma;
257 int cbp_l = h->mb.i_neighbour & MB_LEFT ? h->mb.cbp[h->mb.i_mb_xy - 1] : -1;
258 int cbp_t = h->mb.i_neighbour & MB_TOP ? h->mb.cbp[h->mb.i_mb_top_xy] : -1;
259 x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 1) & 1) - ((cbp_t >> 1) & 2), (h->mb.i_cbp_luma >> 0) & 1 );
260 x264_cabac_encode_decision( cb, 76 - ((cbp >> 0) & 1) - ((cbp_t >> 2) & 2), (h->mb.i_cbp_luma >> 1) & 1 );
261 x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 3) & 1) - ((cbp << 1) & 2), (h->mb.i_cbp_luma >> 2) & 1 );
262 x264_cabac_encode_decision( cb, 76 - ((cbp >> 2) & 1) - ((cbp >> 0) & 2), (h->mb.i_cbp_luma >> 3) & 1 );
265 static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
271 /* No need to test for SKIP/PCM */
272 if( h->mb.i_neighbour & MB_LEFT )
274 cbp_a = (h->mb.cbp[h->mb.i_mb_xy - 1] >> 4)&0x3;
277 if( h->mb.i_neighbour & MB_TOP )
279 cbp_b = (h->mb.cbp[h->mb.i_mb_top_xy] >> 4)&0x3;
283 if( cbp_a > 0 ) ctx++;
284 if( cbp_b > 0 ) ctx += 2;
285 if( h->mb.i_cbp_chroma == 0 )
287 x264_cabac_encode_decision( cb, 77 + ctx, 0 );
291 x264_cabac_encode_decision( cb, 77 + ctx, 1 );
294 if( cbp_a == 2 ) ctx++;
295 if( cbp_b == 2 ) ctx += 2;
296 x264_cabac_encode_decision( cb, 77 + ctx, h->mb.i_cbp_chroma > 1 );
300 /* TODO check it with != qp per mb */
301 static void x264_cabac_mb_qp_delta( x264_t *h, x264_cabac_t *cb )
303 int i_mbn_xy = h->mb.i_mb_prev_xy;
304 int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
307 /* Avoid writing a delta quant if we have an empty i16x16 block, e.g. in a completely flat background area */
308 if( h->mb.i_type == I_16x16 && !h->mb.cbp[h->mb.i_mb_xy] )
311 h->mb.i_qp = h->mb.i_last_qp;
316 /* No need to test for PCM / SKIP */
317 if( h->mb.i_last_dqp &&
318 ( h->mb.type[i_mbn_xy] == I_16x16 || (h->mb.cbp[i_mbn_xy]&0x3f) ) )
325 int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
326 /* dqp is interpreted modulo 52 */
327 if( val >= 51 && val != 52 )
331 x264_cabac_encode_decision( cb, 60 + ctx, 1 );
338 x264_cabac_encode_decision( cb, 60 + ctx, 0 );
342 void x264_cabac_mb_skip( x264_t *h, int b_skip )
344 int ctx = (h->mb.i_mb_type_left >= 0 && !IS_SKIP( h->mb.i_mb_type_left ))
345 + (h->mb.i_mb_type_top >= 0 && !IS_SKIP( h->mb.i_mb_type_top ))
346 + (h->sh.i_type == SLICE_TYPE_P ? 11 : 24);
347 x264_cabac_encode_decision( &h->cabac, ctx, b_skip );
351 static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
353 if( i_sub == D_L0_8x8 )
355 x264_cabac_encode_decision( cb, 21, 1 );
357 else if( i_sub == D_L0_8x4 )
359 x264_cabac_encode_decision( cb, 21, 0 );
360 x264_cabac_encode_decision( cb, 22, 0 );
362 else if( i_sub == D_L0_4x8 )
364 x264_cabac_encode_decision( cb, 21, 0 );
365 x264_cabac_encode_decision( cb, 22, 1 );
366 x264_cabac_encode_decision( cb, 23, 1 );
368 else if( i_sub == D_L0_4x4 )
370 x264_cabac_encode_decision( cb, 21, 0 );
371 x264_cabac_encode_decision( cb, 22, 1 );
372 x264_cabac_encode_decision( cb, 23, 0 );
376 static NOINLINE void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
378 static const uint8_t part_bits[12][7] = {
379 {6,1,1,1,0,1,1}, // D_L0_4x4
380 {5,1,1,0,0,1}, // D_L0_8x4
381 {5,1,1,0,1,0}, // D_L0_4x8
382 {3,1,0,0}, // D_L0_8x8
383 {5,1,1,1,1,0}, // D_L1_4x4
384 {5,1,1,0,1,1}, // D_L1_8x4
385 {6,1,1,1,0,0,0}, // D_L1_4x8
386 {3,1,0,1}, // D_L1_8x8
387 {5,1,1,1,1,1}, // D_BI_4x4
388 {6,1,1,1,0,0,1}, // D_BI_8x4
389 {6,1,1,1,0,1,0}, // D_BI_4x8
390 {5,1,1,0,0,0}, // D_BI_8x8
393 if( i_sub == D_DIRECT_8x8 )
395 x264_cabac_encode_decision( cb, 36, 0 );
398 len = part_bits[i_sub][0];
399 x264_cabac_encode_decision( cb, 36, part_bits[i_sub][1] );
400 x264_cabac_encode_decision( cb, 37, part_bits[i_sub][2] );
402 x264_cabac_encode_decision( cb, 39, part_bits[i_sub][3] );
405 x264_cabac_encode_decision( cb, 38, part_bits[i_sub][3] );
406 x264_cabac_encode_decision( cb, 39, part_bits[i_sub][4] );
407 x264_cabac_encode_decision( cb, 39, part_bits[i_sub][5] );
409 x264_cabac_encode_decision( cb, 39, part_bits[i_sub][6] );
413 static inline void x264_cabac_mb_transform_size( x264_t *h, x264_cabac_t *cb )
415 int ctx = 399 + h->mb.cache.i_neighbour_transform_size;
416 x264_cabac_encode_decision( cb, ctx, h->mb.b_transform_8x8 );
419 static inline void x264_cabac_mb_ref( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
421 const int i8 = x264_scan8[idx];
422 const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
423 const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
424 int i_ref = h->mb.cache.ref[i_list][i8];
427 if( i_refa > 0 && !h->mb.cache.skip[i8 - 1])
429 if( i_refb > 0 && !h->mb.cache.skip[i8 - 8])
434 x264_cabac_encode_decision( cb, 54 + ctx, 1 );
442 x264_cabac_encode_decision( cb, 54 + ctx, 0 );
447 static inline void x264_cabac_mb_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd )
449 static const uint8_t transition[7] = { 3,3,3,4,5,6,6 };
450 const int amvd = abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 1][l] ) +
451 abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 8][l] );
452 const int i_abs = abs( mvd );
453 const int i_prefix = X264_MIN( i_abs, 9 );
454 const int ctxbase = l ? 47 : 40;
455 int ctx = (amvd>2) + (amvd>32);
458 for( i = 0; i < i_prefix; i++ )
460 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
461 ctx = transition[ctx];
464 x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
466 x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
470 x264_cabac_encode_bypass( cb, mvd < 0 );
473 static inline void x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width, int height )
475 DECLARE_ALIGNED_4( int16_t mvp[2] );
479 x264_mb_predict_mv( h, i_list, idx, width, mvp );
480 mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
481 mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
484 x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 0, mdx );
485 x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy );
488 x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, pack16to32_mask(mdx,mdy) );
491 static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int i )
493 if( !x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
496 switch( h->mb.i_sub_partition[i] )
501 x264_cabac_mb_mvd( h, cb, i_list, 4*i, 2, 2 );
506 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 2, 1 );
507 x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 2, 1 );
512 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 2 );
513 x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 2 );
518 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 1 );
519 x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 1 );
520 x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 1, 1 );
521 x264_cabac_mb_mvd( h, cb, i_list, 4*i+3, 1, 1 );
526 static int x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx )
528 /* i_ctxBlockCat: 0-> DC 16x16 i_idx = 0
529 * 1-> AC 16x16 i_idx = luma4x4idx
530 * 2-> Luma4x4 i_idx = luma4x4idx
531 * 3-> DC Chroma i_idx = iCbCr
532 * 4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
533 * 5-> Luma8x8 i_idx = luma8x8idx
541 if( i_cat == DCT_LUMA_DC )
543 if( h->mb.i_neighbour & MB_LEFT )
545 i_mba_xy = h->mb.i_mb_xy - 1;
546 if( h->mb.i_mb_type_left == I_16x16 )
547 i_nza = h->mb.cbp[i_mba_xy] & 0x100;
549 if( h->mb.i_neighbour & MB_TOP )
551 i_mbb_xy = h->mb.i_mb_top_xy;
552 if( h->mb.i_mb_type_top == I_16x16 )
553 i_nzb = h->mb.cbp[i_mbb_xy] & 0x100;
556 else if( i_cat == DCT_LUMA_AC || i_cat == DCT_LUMA_4x4 )
558 if( i_idx & ~10 ) // block_idx_x > 0
559 i_mba_xy = h->mb.i_mb_xy;
560 else if( h->mb.i_neighbour & MB_LEFT )
561 i_mba_xy = h->mb.i_mb_xy - 1;
563 if( i_idx & ~5 ) // block_idx_y > 0
564 i_mbb_xy = h->mb.i_mb_xy;
565 else if( h->mb.i_neighbour & MB_TOP )
566 i_mbb_xy = h->mb.i_mb_top_xy;
568 /* no need to test for skip/pcm */
570 i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
572 i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
574 else if( i_cat == DCT_CHROMA_DC )
576 /* no need to test skip/pcm */
577 if( h->mb.i_neighbour & MB_LEFT )
579 i_mba_xy = h->mb.i_mb_xy - 1;
580 i_nza = h->mb.cbp[i_mba_xy] & (0x200 << i_idx);
582 if( h->mb.i_neighbour & MB_TOP )
584 i_mbb_xy = h->mb.i_mb_top_xy;
585 i_nzb = h->mb.cbp[i_mbb_xy] & (0x200 << i_idx);
588 else if( i_cat == DCT_CHROMA_AC )
591 i_mba_xy = h->mb.i_mb_xy;
592 else if( h->mb.i_neighbour & MB_LEFT )
593 i_mba_xy = h->mb.i_mb_xy - 1;
596 i_mbb_xy = h->mb.i_mb_xy;
597 else if( h->mb.i_neighbour & MB_TOP )
598 i_mbb_xy = h->mb.i_mb_top_xy;
600 /* no need to test skip/pcm */
602 i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
604 i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
607 if( IS_INTRA( h->mb.i_type ) )
609 i_nza |= i_mba_xy < 0;
610 i_nzb |= i_mbb_xy < 0;
613 return 4*i_cat + 2*!!i_nzb + !!i_nza;
617 static const uint16_t significant_coeff_flag_offset[2][6] = {
618 { 105, 120, 134, 149, 152, 402 },
619 { 277, 292, 306, 321, 324, 436 }
621 static const uint16_t last_coeff_flag_offset[2][6] = {
622 { 166, 181, 195, 210, 213, 417 },
623 { 338, 353, 367, 382, 385, 451 }
625 static const uint16_t coeff_abs_level_m1_offset[6] =
626 { 227, 237, 247, 257, 266, 426 };
627 static const uint8_t significant_coeff_flag_offset_8x8[2][63] =
629 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
630 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
631 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
632 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
634 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
635 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
636 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
637 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14
639 static const uint8_t last_coeff_flag_offset_8x8[63] = {
640 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
641 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
642 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
643 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
645 static const uint8_t identity[16] =
646 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
648 // node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
649 // 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
650 /* map node ctx => cabac ctx for level=1 */
651 static const int coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
652 /* map node ctx => cabac ctx for level>1 */
653 static const int coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
654 static const uint8_t coeff_abs_level_transition[2][8] = {
655 /* update node ctx after coding a level=1 */
656 { 1, 2, 3, 3, 4, 5, 6, 7 },
657 /* update node ctx after coding a level>1 */
658 { 4, 4, 4, 4, 5, 6, 7, 7 }
661 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 )
663 const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
664 const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
665 const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
667 int i_coeff_abs_m1[64];
668 int UNUSED i_coeff_sign[64];
675 const uint8_t *significant_coeff_flag_offset;
676 const uint8_t *last_coeff_flag_offset;
678 /* yes this is always aligned, and l[-1] exists in the cases where it's used (ac) */
679 for( j = i_count - 4; j >= -1; j -= 4 )
680 if( *(uint64_t*)(l+j) )
685 /* coded block flag */
686 int ctx = 85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx );
688 x264_cabac_encode_decision( cb, ctx, 1 );
691 x264_cabac_encode_decision( cb, ctx, 0 );
696 significant_coeff_flag_offset = (i_ctxBlockCat == DCT_LUMA_8x8)
697 ? significant_coeff_flag_offset_8x8[h->mb.b_interlaced]
699 last_coeff_flag_offset = (i_ctxBlockCat == DCT_LUMA_8x8)
700 ? last_coeff_flag_offset_8x8 : identity;
702 for( i = j; i < j+4; i++)
706 i_sigmap_size = X264_MIN( i_last+1, i_count-1 );
708 for( i = 0; i < i_sigmap_size; i++ )
712 i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
714 i_coeff_sign[i_coeff] = l[i] < 0;
717 x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], 1 );
718 x264_cabac_encode_decision( cb, i_ctx_last + last_coeff_flag_offset[i], i == i_last );
721 x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], 0 );
726 i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
728 i_coeff_sign[i_coeff] = l[i] < 0;
733 for( i = i_coeff - 1; i >= 0; i-- )
735 /* write coeff_abs - 1 */
736 int i_prefix = X264_MIN( i_coeff_abs_m1[i], 14 );
737 int ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
741 x264_cabac_encode_decision( cb, ctx, 1 );
742 ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
744 cb->f8_bits_encoded += cabac_prefix_size[i_prefix][cb->state[ctx]];
745 cb->state[ctx] = cabac_prefix_transition[i_prefix][cb->state[ctx]];
747 for( j = 0; j < i_prefix - 1; j++ )
748 x264_cabac_encode_decision( cb, ctx, 1 );
750 x264_cabac_encode_decision( cb, ctx, 0 );
753 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i] - 14 );
755 node_ctx = coeff_abs_level_transition[1][node_ctx];
759 x264_cabac_encode_decision( cb, ctx, 0 );
760 node_ctx = coeff_abs_level_transition[0][node_ctx];
762 x264_cabac_encode_bypass( cb, 0 ); // sign
767 x264_cabac_encode_bypass( cb, i_coeff_sign[i] );
774 void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
776 const int i_mb_type = h->mb.i_type;
781 const int i_mb_pos_start = x264_cabac_pos( cb );
785 /* Write the MB type */
786 x264_cabac_mb_type( h, cb );
788 /* PCM special block type UNTESTED */
789 if( i_mb_type == I_PCM )
792 cb->f8_bits_encoded += (384*8) << 8;
794 if( cb->p + 385 >= cb->p_end )
795 return; //FIXME throw an error
797 for( i = 0; i < 16; i++ )
799 memcpy( cb->p, h->fenc->plane[0] + i*h->mb.pic.i_stride[0], 16 );
803 for( i = 0; i < 8; i++ )
805 memcpy( cb->p, h->fenc->plane[1] + i*h->mb.pic.i_stride[1], 8 );
809 for( i = 0; i < 8; i++ )
811 memcpy( cb->p, h->fenc->plane[2] + i*h->mb.pic.i_stride[2], 8 );
814 x264_cabac_encode_init( cb, cb->p, cb->p_end );
819 if( IS_INTRA( i_mb_type ) )
821 if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
822 x264_cabac_mb_transform_size( h, cb );
824 if( i_mb_type != I_16x16 )
826 int di = (i_mb_type == I_8x8) ? 4 : 1;
827 for( i = 0; i < 16; i += di )
829 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
830 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
831 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
835 x264_cabac_mb_intra_chroma_pred_mode( h, cb );
837 else if( i_mb_type == P_L0 )
839 if( h->mb.i_partition == D_16x16 )
841 if( h->mb.pic.i_fref[0] > 1 )
843 x264_cabac_mb_ref( h, cb, 0, 0 );
845 x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
847 else if( h->mb.i_partition == D_16x8 )
849 if( h->mb.pic.i_fref[0] > 1 )
851 x264_cabac_mb_ref( h, cb, 0, 0 );
852 x264_cabac_mb_ref( h, cb, 0, 8 );
854 x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
855 x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
857 else if( h->mb.i_partition == D_8x16 )
859 if( h->mb.pic.i_fref[0] > 1 )
861 x264_cabac_mb_ref( h, cb, 0, 0 );
862 x264_cabac_mb_ref( h, cb, 0, 4 );
864 x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
865 x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
868 else if( i_mb_type == P_8x8 )
871 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[0] );
872 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[1] );
873 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[2] );
874 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[3] );
877 if( h->mb.pic.i_fref[0] > 1 )
879 x264_cabac_mb_ref( h, cb, 0, 0 );
880 x264_cabac_mb_ref( h, cb, 0, 4 );
881 x264_cabac_mb_ref( h, cb, 0, 8 );
882 x264_cabac_mb_ref( h, cb, 0, 12 );
885 for( i = 0; i < 4; i++ )
886 x264_cabac_mb8x8_mvd( h, cb, 0, i );
888 else if( i_mb_type == B_8x8 )
891 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[0] );
892 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[1] );
893 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[2] );
894 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[3] );
897 for( i_list = 0; i_list < 2; i_list++ )
899 if( ( i_list ? h->mb.pic.i_fref[1] : h->mb.pic.i_fref[0] ) == 1 )
901 for( i = 0; i < 4; i++ )
902 if( x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
903 x264_cabac_mb_ref( h, cb, i_list, 4*i );
906 for( i = 0; i < 4; i++ )
907 x264_cabac_mb8x8_mvd( h, cb, 0, i );
908 for( i = 0; i < 4; i++ )
909 x264_cabac_mb8x8_mvd( h, cb, 1, i );
911 else if( i_mb_type != B_DIRECT )
916 /* init ref list utilisations */
917 for( i = 0; i < 2; i++ )
919 b_list[0][i] = x264_mb_type_list0_table[i_mb_type][i];
920 b_list[1][i] = x264_mb_type_list1_table[i_mb_type][i];
923 for( i_list = 0; i_list < 2; i_list++ )
925 const int i_ref_max = i_list == 0 ? h->mb.pic.i_fref[0] : h->mb.pic.i_fref[1];
929 if( h->mb.i_partition == D_16x16 )
931 if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
933 else if( h->mb.i_partition == D_16x8 )
935 if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
936 if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 8 );
938 else if( h->mb.i_partition == D_8x16 )
940 if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
941 if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 4 );
945 for( i_list = 0; i_list < 2; i_list++ )
947 if( h->mb.i_partition == D_16x16 )
949 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
951 else if( h->mb.i_partition == D_16x8 )
953 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
954 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
956 else if( h->mb.i_partition == D_8x16 )
958 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
959 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
965 i_mb_pos_tex = x264_cabac_pos( cb );
966 h->stat.frame.i_hdr_bits += i_mb_pos_tex - i_mb_pos_start;
969 if( i_mb_type != I_16x16 )
971 x264_cabac_mb_cbp_luma( h, cb );
972 x264_cabac_mb_cbp_chroma( h, cb );
975 if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
977 x264_cabac_mb_transform_size( h, cb );
980 if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
982 x264_cabac_mb_qp_delta( h, cb );
985 if( i_mb_type == I_16x16 )
988 block_residual_write_cabac( h, cb, DCT_LUMA_DC, 0, h->dct.luma16x16_dc, 16 );
991 if( h->mb.i_cbp_luma != 0 )
992 for( i = 0; i < 16; i++ )
993 block_residual_write_cabac( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 15 );
995 else if( h->mb.b_transform_8x8 )
997 for( i = 0; i < 4; i++ )
998 if( h->mb.i_cbp_luma & ( 1 << i ) )
999 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i, h->dct.luma8x8[i], 64 );
1003 for( i = 0; i < 16; i++ )
1004 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
1005 block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], 16 );
1008 if( h->mb.i_cbp_chroma &0x03 ) /* Chroma DC residual present */
1010 block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
1011 block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
1013 if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
1015 for( i = 16; i < 24; i++ )
1016 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );
1021 if( IS_INTRA( i_mb_type ) )
1022 h->stat.frame.i_itex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
1024 h->stat.frame.i_ptex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
1029 /*****************************************************************************
1030 * RD only; doesn't generate a valid bitstream
1031 * doesn't write cbp or chroma dc (I don't know how much this matters)
1032 * works on all partition sizes except 16x16
1033 * for sub8x8, call once per 8x8 block
1034 *****************************************************************************/
1035 void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
1037 const int i_mb_type = h->mb.i_type;
1040 if( i_mb_type == P_8x8 )
1042 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
1043 if( h->mb.pic.i_fref[0] > 1 )
1044 x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1045 x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
1047 else if( i_mb_type == P_L0 )
1049 if( h->mb.pic.i_fref[0] > 1 )
1050 x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1051 if( h->mb.i_partition == D_16x8 )
1052 x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4, 2 );
1054 x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 4 );
1056 else if( i_mb_type == B_8x8 )
1058 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i8] );
1060 if( h->mb.pic.i_fref[0] > 1
1061 && x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
1062 x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1063 if( h->mb.pic.i_fref[1] > 1
1064 && x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
1065 x264_cabac_mb_ref( h, cb, 1, 4*i8 );
1067 x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
1068 x264_cabac_mb8x8_mvd( h, cb, 1, i8 );
1072 x264_log(h, X264_LOG_ERROR, "invalid/unhandled mb_type\n" );
1076 for( j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
1078 if( h->mb.i_cbp_luma & (1 << i8) )
1080 if( h->mb.b_transform_8x8 )
1081 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i8, h->dct.luma8x8[i8], 64 );
1085 for( i4 = 0; i4 < 4; i4++ )
1086 block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 16 );
1090 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 15 );
1091 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 15 );
1093 i8 += x264_pixel_size[i_pixel].h >> 3;
1097 static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
1099 const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
1100 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1101 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1102 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, 4*i8, h->dct.luma8x8[i8], 64 );
1105 static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
1107 const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
1108 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1109 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1110 block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 16 );
1113 static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
1115 x264_cabac_mb_intra_chroma_pred_mode( h, cb );
1116 if( h->mb.i_cbp_chroma > 0 )
1118 block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
1119 block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
1121 if( h->mb.i_cbp_chroma == 2 )
1124 for( i = 16; i < 24; i++ )
1125 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );