Remove compatibility workarounds
[x264.git] / encoder / cabac.c
blobb76ff130638277022ae1fa63a5762040d8ca9786
1 /*****************************************************************************
2 * cabac.c: cabac bitstream writing
3 *****************************************************************************
4 * Copyright (C) 2003-2019 x264 project
6 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7 * Loren Merritt <lorenm@u.washington.edu>
8 * Fiona Glaser <fiona@x264.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
24 * This program is also available under a commercial proprietary license.
25 * For more information, contact us at licensing@x264.com.
26 *****************************************************************************/
28 #include "common/common.h"
29 #include "macroblock.h"
31 #ifndef RDO_SKIP_BS
32 #define RDO_SKIP_BS 0
33 #endif
35 static inline void cabac_mb_type_intra( x264_t *h, x264_cabac_t *cb, int i_mb_type,
36 int ctx0, int ctx1, int ctx2, int ctx3, int ctx4, int ctx5 )
38 if( i_mb_type == I_4x4 || i_mb_type == I_8x8 )
40 x264_cabac_encode_decision_noup( cb, ctx0, 0 );
42 #if !RDO_SKIP_BS
43 else if( i_mb_type == I_PCM )
45 x264_cabac_encode_decision_noup( cb, ctx0, 1 );
46 x264_cabac_encode_flush( h, cb );
48 #endif
49 else
51 int i_pred = x264_mb_pred_mode16x16_fix[h->mb.i_intra16x16_pred_mode];
53 x264_cabac_encode_decision_noup( cb, ctx0, 1 );
54 x264_cabac_encode_terminal( cb );
56 x264_cabac_encode_decision_noup( cb, ctx1, !!h->mb.i_cbp_luma );
57 if( h->mb.i_cbp_chroma == 0 )
58 x264_cabac_encode_decision_noup( cb, ctx2, 0 );
59 else
61 x264_cabac_encode_decision( cb, ctx2, 1 );
62 x264_cabac_encode_decision_noup( cb, ctx3, h->mb.i_cbp_chroma>>1 );
64 x264_cabac_encode_decision( cb, ctx4, i_pred>>1 );
65 x264_cabac_encode_decision_noup( cb, ctx5, i_pred&1 );
69 #if !RDO_SKIP_BS
70 static void cabac_field_decoding_flag( x264_t *h, x264_cabac_t *cb )
72 int ctx = 0;
73 ctx += h->mb.field_decoding_flag & !!h->mb.i_mb_x;
74 ctx += (h->mb.i_mb_top_mbpair_xy >= 0
75 && h->mb.slice_table[h->mb.i_mb_top_mbpair_xy] == h->sh.i_first_mb
76 && h->mb.field[h->mb.i_mb_top_mbpair_xy]);
78 x264_cabac_encode_decision_noup( cb, 70 + ctx, MB_INTERLACED );
79 h->mb.field_decoding_flag = MB_INTERLACED;
81 #endif
83 static void cabac_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
85 if( i_pred == i_mode )
86 x264_cabac_encode_decision( cb, 68, 1 );
87 else
89 x264_cabac_encode_decision( cb, 68, 0 );
90 if( i_mode > i_pred )
91 i_mode--;
92 x264_cabac_encode_decision( cb, 69, (i_mode )&0x01 );
93 x264_cabac_encode_decision( cb, 69, (i_mode >> 1)&0x01 );
94 x264_cabac_encode_decision( cb, 69, (i_mode >> 2) );
98 static void cabac_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
100 int i_mode = x264_mb_chroma_pred_mode_fix[h->mb.i_chroma_pred_mode];
101 int ctx = 0;
103 /* No need to test for I4x4 or I_16x16 as cache_save handle that */
104 if( (h->mb.i_neighbour & MB_LEFT) && h->mb.chroma_pred_mode[h->mb.i_mb_left_xy[0]] != 0 )
105 ctx++;
106 if( (h->mb.i_neighbour & MB_TOP) && h->mb.chroma_pred_mode[h->mb.i_mb_top_xy] != 0 )
107 ctx++;
109 x264_cabac_encode_decision_noup( cb, 64 + ctx, i_mode > 0 );
110 if( i_mode > 0 )
112 x264_cabac_encode_decision( cb, 64 + 3, i_mode > 1 );
113 if( i_mode > 1 )
114 x264_cabac_encode_decision_noup( cb, 64 + 3, i_mode > 2 );
118 static void cabac_cbp_luma( x264_t *h, x264_cabac_t *cb )
120 int cbp = h->mb.i_cbp_luma;
121 int cbp_l = h->mb.cache.i_cbp_left;
122 int cbp_t = h->mb.cache.i_cbp_top;
123 x264_cabac_encode_decision ( cb, 76 - ((cbp_l >> 1) & 1) - ((cbp_t >> 1) & 2), (cbp >> 0) & 1 );
124 x264_cabac_encode_decision ( cb, 76 - ((cbp >> 0) & 1) - ((cbp_t >> 2) & 2), (cbp >> 1) & 1 );
125 x264_cabac_encode_decision ( cb, 76 - ((cbp_l >> 3) & 1) - ((cbp << 1) & 2), (cbp >> 2) & 1 );
126 x264_cabac_encode_decision_noup( cb, 76 - ((cbp >> 2) & 1) - ((cbp >> 0) & 2), (cbp >> 3) & 1 );
129 static void cabac_cbp_chroma( x264_t *h, x264_cabac_t *cb )
131 int cbp_a = h->mb.cache.i_cbp_left & 0x30;
132 int cbp_b = h->mb.cache.i_cbp_top & 0x30;
133 int ctx = 0;
135 if( cbp_a && h->mb.cache.i_cbp_left != -1 ) ctx++;
136 if( cbp_b && h->mb.cache.i_cbp_top != -1 ) ctx+=2;
137 if( h->mb.i_cbp_chroma == 0 )
138 x264_cabac_encode_decision_noup( cb, 77 + ctx, 0 );
139 else
141 x264_cabac_encode_decision_noup( cb, 77 + ctx, 1 );
143 ctx = 4;
144 if( cbp_a == 0x20 ) ctx++;
145 if( cbp_b == 0x20 ) ctx += 2;
146 x264_cabac_encode_decision_noup( cb, 77 + ctx, h->mb.i_cbp_chroma >> 1 );
150 static void cabac_qp_delta( x264_t *h, x264_cabac_t *cb )
152 int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
153 int ctx;
155 /* Avoid writing a delta quant if we have an empty i16x16 block, e.g. in a completely
156 * flat background area. Don't do this if it would raise the quantizer, since that could
157 * cause unexpected deblocking artifacts. */
158 if( h->mb.i_type == I_16x16 && !h->mb.cbp[h->mb.i_mb_xy] && h->mb.i_qp > h->mb.i_last_qp )
160 #if !RDO_SKIP_BS
161 h->mb.i_qp = h->mb.i_last_qp;
162 #endif
163 i_dqp = 0;
166 ctx = h->mb.i_last_dqp && (h->mb.type[h->mb.i_mb_prev_xy] == I_16x16 || (h->mb.cbp[h->mb.i_mb_prev_xy]&0x3f));
168 if( i_dqp != 0 )
170 /* Faster than (i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp-1)).
171 * If you so much as sneeze on these lines, gcc will compile this suboptimally. */
172 i_dqp *= 2;
173 int val = 1 - i_dqp;
174 if( val < 0 ) val = i_dqp;
175 val--;
176 /* dqp is interpreted modulo (QP_MAX_SPEC+1) */
177 if( val >= QP_MAX_SPEC && val != QP_MAX_SPEC+1 )
178 val = 2*QP_MAX_SPEC+1 - val;
181 x264_cabac_encode_decision( cb, 60 + ctx, 1 );
182 ctx = 2+(ctx>>1);
183 } while( --val );
185 x264_cabac_encode_decision_noup( cb, 60 + ctx, 0 );
188 #if !RDO_SKIP_BS
189 void x264_cabac_mb_skip( x264_t *h, int b_skip )
191 int ctx = h->mb.cache.i_neighbour_skip + 11;
192 if( h->sh.i_type != SLICE_TYPE_P )
193 ctx += 13;
194 x264_cabac_encode_decision( &h->cabac, ctx, b_skip );
196 #endif
198 static inline void cabac_subpartition_p( x264_cabac_t *cb, int i_sub )
200 if( i_sub == D_L0_8x8 )
202 x264_cabac_encode_decision( cb, 21, 1 );
203 return;
205 x264_cabac_encode_decision( cb, 21, 0 );
206 if( i_sub == D_L0_8x4 )
207 x264_cabac_encode_decision( cb, 22, 0 );
208 else
210 x264_cabac_encode_decision( cb, 22, 1 );
211 x264_cabac_encode_decision( cb, 23, i_sub == D_L0_4x8 );
215 static ALWAYS_INLINE void cabac_subpartition_b( x264_cabac_t *cb, int i_sub )
217 if( i_sub == D_DIRECT_8x8 )
219 x264_cabac_encode_decision( cb, 36, 0 );
220 return;
222 x264_cabac_encode_decision( cb, 36, 1 );
223 if( i_sub == D_BI_8x8 )
225 x264_cabac_encode_decision( cb, 37, 1 );
226 x264_cabac_encode_decision( cb, 38, 0 );
227 x264_cabac_encode_decision( cb, 39, 0 );
228 x264_cabac_encode_decision( cb, 39, 0 );
229 return;
231 x264_cabac_encode_decision( cb, 37, 0 );
232 x264_cabac_encode_decision( cb, 39, i_sub == D_L1_8x8 );
235 static ALWAYS_INLINE void cabac_transform_size( x264_t *h, x264_cabac_t *cb )
237 int ctx = 399 + h->mb.cache.i_neighbour_transform_size;
238 x264_cabac_encode_decision_noup( cb, ctx, h->mb.b_transform_8x8 );
241 static ALWAYS_INLINE void cabac_ref_internal( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int bframe )
243 const int i8 = x264_scan8[idx];
244 const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
245 const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
246 int ctx = 0;
248 if( i_refa > 0 && (!bframe || !h->mb.cache.skip[i8 - 1]) )
249 ctx++;
250 if( i_refb > 0 && (!bframe || !h->mb.cache.skip[i8 - 8]) )
251 ctx += 2;
253 for( int i_ref = h->mb.cache.ref[i_list][i8]; i_ref > 0; i_ref-- )
255 x264_cabac_encode_decision( cb, 54 + ctx, 1 );
256 ctx = (ctx>>2)+4;
258 x264_cabac_encode_decision( cb, 54 + ctx, 0 );
261 static NOINLINE void cabac_ref_p( x264_t *h, x264_cabac_t *cb, int idx )
263 cabac_ref_internal( h, cb, 0, idx, 0 );
265 static NOINLINE void cabac_ref_b( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
267 cabac_ref_internal( h, cb, i_list, idx, 1 );
270 static ALWAYS_INLINE int cabac_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd, int ctx )
272 int ctxbase = l ? 47 : 40;
274 if( mvd == 0 )
276 x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
277 return 0;
280 int i_abs = abs( mvd );
281 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
282 #if RDO_SKIP_BS
283 if( i_abs <= 3 )
285 for( int i = 1; i < i_abs; i++ )
286 x264_cabac_encode_decision( cb, ctxbase + i + 2, 1 );
287 x264_cabac_encode_decision( cb, ctxbase + i_abs + 2, 0 );
288 x264_cabac_encode_bypass( cb, mvd >> 31 );
290 else
292 x264_cabac_encode_decision( cb, ctxbase + 3, 1 );
293 x264_cabac_encode_decision( cb, ctxbase + 4, 1 );
294 x264_cabac_encode_decision( cb, ctxbase + 5, 1 );
295 if( i_abs < 9 )
297 cb->f8_bits_encoded += x264_cabac_size_unary[i_abs - 3][cb->state[ctxbase+6]];
298 cb->state[ctxbase+6] = x264_cabac_transition_unary[i_abs - 3][cb->state[ctxbase+6]];
300 else
302 cb->f8_bits_encoded += cabac_size_5ones[cb->state[ctxbase+6]];
303 cb->state[ctxbase+6] = cabac_transition_5ones[cb->state[ctxbase+6]];
304 x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
307 #else
308 static const uint8_t ctxes[8] = { 3,4,5,6,6,6,6,6 };
310 if( i_abs < 9 )
312 for( int i = 1; i < i_abs; i++ )
313 x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
314 x264_cabac_encode_decision( cb, ctxbase + ctxes[i_abs-1], 0 );
316 else
318 for( int i = 1; i < 9; i++ )
319 x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
320 x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
322 x264_cabac_encode_bypass( cb, mvd >> 31 );
323 #endif
324 /* Since we don't need to keep track of MVDs larger than 66, just cap the value.
325 * This lets us store MVDs as 8-bit values instead of 16-bit. */
326 return X264_MIN( i_abs, 66 );
329 static NOINLINE uint16_t cabac_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width )
331 ALIGNED_4( int16_t mvp[2] );
332 int mdx, mdy;
334 /* Calculate mvd */
335 x264_mb_predict_mv( h, i_list, idx, width, mvp );
336 mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
337 mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
338 uint16_t amvd = x264_cabac_mvd_sum(h->mb.cache.mvd[i_list][x264_scan8[idx] - 1],
339 h->mb.cache.mvd[i_list][x264_scan8[idx] - 8]);
341 /* encode */
342 mdx = cabac_mvd_cpn( h, cb, i_list, idx, 0, mdx, amvd&0xFF );
343 mdy = cabac_mvd_cpn( h, cb, i_list, idx, 1, mdy, amvd>>8 );
345 return pack8to16(mdx,mdy);
348 #define cabac_mvd(h,cb,i_list,idx,width,height)\
351 uint16_t mvd = cabac_mvd(h,cb,i_list,idx,width);\
352 x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, mvd );\
353 } while( 0 )
355 static inline void cabac_8x8_mvd( x264_t *h, x264_cabac_t *cb, int i )
357 switch( h->mb.i_sub_partition[i] )
359 case D_L0_8x8:
360 cabac_mvd( h, cb, 0, 4*i, 2, 2 );
361 break;
362 case D_L0_8x4:
363 cabac_mvd( h, cb, 0, 4*i+0, 2, 1 );
364 cabac_mvd( h, cb, 0, 4*i+2, 2, 1 );
365 break;
366 case D_L0_4x8:
367 cabac_mvd( h, cb, 0, 4*i+0, 1, 2 );
368 cabac_mvd( h, cb, 0, 4*i+1, 1, 2 );
369 break;
370 case D_L0_4x4:
371 cabac_mvd( h, cb, 0, 4*i+0, 1, 1 );
372 cabac_mvd( h, cb, 0, 4*i+1, 1, 1 );
373 cabac_mvd( h, cb, 0, 4*i+2, 1, 1 );
374 cabac_mvd( h, cb, 0, 4*i+3, 1, 1 );
375 break;
376 default:
377 assert(0);
381 static ALWAYS_INLINE void cabac_mb_header_i( x264_t *h, x264_cabac_t *cb, int i_mb_type, int slice_type, int chroma )
383 if( slice_type == SLICE_TYPE_I )
385 int ctx = 0;
386 if( (h->mb.i_neighbour & MB_LEFT) && h->mb.i_mb_type_left[0] != I_4x4 )
387 ctx++;
388 if( (h->mb.i_neighbour & MB_TOP) && h->mb.i_mb_type_top != I_4x4 )
389 ctx++;
391 cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
393 else if( slice_type == SLICE_TYPE_P )
395 /* prefix */
396 x264_cabac_encode_decision_noup( cb, 14, 1 );
398 /* suffix */
399 cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
401 else if( slice_type == SLICE_TYPE_B )
403 /* prefix */
404 x264_cabac_encode_decision_noup( cb, 27+3, 1 );
405 x264_cabac_encode_decision_noup( cb, 27+4, 1 );
406 x264_cabac_encode_decision( cb, 27+5, 1 );
407 x264_cabac_encode_decision( cb, 27+5, 0 );
408 x264_cabac_encode_decision( cb, 27+5, 1 );
410 /* suffix */
411 cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
414 if( i_mb_type == I_PCM )
415 return;
417 if( i_mb_type != I_16x16 )
419 if( h->pps->b_transform_8x8_mode )
420 cabac_transform_size( h, cb );
422 int di = h->mb.b_transform_8x8 ? 4 : 1;
423 for( int i = 0; i < 16; i += di )
425 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
426 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
427 cabac_intra4x4_pred_mode( cb, i_pred, i_mode );
431 if( chroma )
432 cabac_intra_chroma_pred_mode( h, cb );
435 static ALWAYS_INLINE void cabac_mb_header_p( x264_t *h, x264_cabac_t *cb, int i_mb_type, int chroma )
437 if( i_mb_type == P_L0 )
439 x264_cabac_encode_decision_noup( cb, 14, 0 );
440 if( h->mb.i_partition == D_16x16 )
442 x264_cabac_encode_decision_noup( cb, 15, 0 );
443 x264_cabac_encode_decision_noup( cb, 16, 0 );
444 if( h->mb.pic.i_fref[0] > 1 )
445 cabac_ref_p( h, cb, 0 );
446 cabac_mvd( h, cb, 0, 0, 4, 4 );
448 else if( h->mb.i_partition == D_16x8 )
450 x264_cabac_encode_decision_noup( cb, 15, 1 );
451 x264_cabac_encode_decision_noup( cb, 17, 1 );
452 if( h->mb.pic.i_fref[0] > 1 )
454 cabac_ref_p( h, cb, 0 );
455 cabac_ref_p( h, cb, 8 );
457 cabac_mvd( h, cb, 0, 0, 4, 2 );
458 cabac_mvd( h, cb, 0, 8, 4, 2 );
460 else //if( h->mb.i_partition == D_8x16 )
462 x264_cabac_encode_decision_noup( cb, 15, 1 );
463 x264_cabac_encode_decision_noup( cb, 17, 0 );
464 if( h->mb.pic.i_fref[0] > 1 )
466 cabac_ref_p( h, cb, 0 );
467 cabac_ref_p( h, cb, 4 );
469 cabac_mvd( h, cb, 0, 0, 2, 4 );
470 cabac_mvd( h, cb, 0, 4, 2, 4 );
473 else if( i_mb_type == P_8x8 )
475 x264_cabac_encode_decision_noup( cb, 14, 0 );
476 x264_cabac_encode_decision_noup( cb, 15, 0 );
477 x264_cabac_encode_decision_noup( cb, 16, 1 );
479 /* sub mb type */
480 for( int i = 0; i < 4; i++ )
481 cabac_subpartition_p( cb, h->mb.i_sub_partition[i] );
483 /* ref 0 */
484 if( h->mb.pic.i_fref[0] > 1 )
486 cabac_ref_p( h, cb, 0 );
487 cabac_ref_p( h, cb, 4 );
488 cabac_ref_p( h, cb, 8 );
489 cabac_ref_p( h, cb, 12 );
492 for( int i = 0; i < 4; i++ )
493 cabac_8x8_mvd( h, cb, i );
495 else /* intra */
496 cabac_mb_header_i( h, cb, i_mb_type, SLICE_TYPE_P, chroma );
499 static ALWAYS_INLINE void cabac_mb_header_b( x264_t *h, x264_cabac_t *cb, int i_mb_type, int chroma )
501 int ctx = 0;
502 if( (h->mb.i_neighbour & MB_LEFT) && h->mb.i_mb_type_left[0] != B_SKIP && h->mb.i_mb_type_left[0] != B_DIRECT )
503 ctx++;
504 if( (h->mb.i_neighbour & MB_TOP) && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
505 ctx++;
507 if( i_mb_type == B_DIRECT )
509 x264_cabac_encode_decision_noup( cb, 27+ctx, 0 );
510 return;
512 x264_cabac_encode_decision_noup( cb, 27+ctx, 1 );
514 if( i_mb_type == B_8x8 )
516 x264_cabac_encode_decision_noup( cb, 27+3, 1 );
517 x264_cabac_encode_decision_noup( cb, 27+4, 1 );
518 x264_cabac_encode_decision( cb, 27+5, 1 );
519 x264_cabac_encode_decision( cb, 27+5, 1 );
520 x264_cabac_encode_decision_noup( cb, 27+5, 1 );
522 /* sub mb type */
523 for( int i = 0; i < 4; i++ )
524 cabac_subpartition_b( cb, h->mb.i_sub_partition[i] );
526 /* ref */
527 if( h->mb.pic.i_fref[0] > 1 )
528 for( int i = 0; i < 4; i++ )
529 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
530 cabac_ref_b( h, cb, 0, 4*i );
532 if( h->mb.pic.i_fref[1] > 1 )
533 for( int i = 0; i < 4; i++ )
534 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
535 cabac_ref_b( h, cb, 1, 4*i );
537 for( int i = 0; i < 4; i++ )
538 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
539 cabac_mvd( h, cb, 0, 4*i, 2, 2 );
541 for( int i = 0; i < 4; i++ )
542 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
543 cabac_mvd( h, cb, 1, 4*i, 2, 2 );
545 else if( i_mb_type >= B_L0_L0 && i_mb_type <= B_BI_BI )
547 /* All B modes */
548 static const uint8_t i_mb_bits[9*3] =
550 0x31, 0x29, 0x4, /* L0 L0 */
551 0x35, 0x2d, 0, /* L0 L1 */
552 0x43, 0x63, 0, /* L0 BI */
553 0x3d, 0x2f, 0, /* L1 L0 */
554 0x39, 0x25, 0x6, /* L1 L1 */
555 0x53, 0x73, 0, /* L1 BI */
556 0x4b, 0x6b, 0, /* BI L0 */
557 0x5b, 0x7b, 0, /* BI L1 */
558 0x47, 0x67, 0x21 /* BI BI */
561 const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
562 int bits = i_mb_bits[idx];
564 x264_cabac_encode_decision_noup( cb, 27+3, bits&1 );
565 x264_cabac_encode_decision( cb, 27+5-(bits&1), (bits>>1)&1 ); bits >>= 2;
566 if( bits != 1 )
568 x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
569 x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
570 x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
571 if( bits != 1 )
572 x264_cabac_encode_decision_noup( cb, 27+5, bits&1 );
575 const uint8_t (*b_list)[2] = x264_mb_type_list_table[i_mb_type];
576 if( h->mb.pic.i_fref[0] > 1 )
578 if( b_list[0][0] )
579 cabac_ref_b( h, cb, 0, 0 );
580 if( b_list[0][1] && h->mb.i_partition != D_16x16 )
581 cabac_ref_b( h, cb, 0, 8 >> (h->mb.i_partition == D_8x16) );
583 if( h->mb.pic.i_fref[1] > 1 )
585 if( b_list[1][0] )
586 cabac_ref_b( h, cb, 1, 0 );
587 if( b_list[1][1] && h->mb.i_partition != D_16x16 )
588 cabac_ref_b( h, cb, 1, 8 >> (h->mb.i_partition == D_8x16) );
590 for( int i_list = 0; i_list < 2; i_list++ )
592 if( h->mb.i_partition == D_16x16 )
594 if( b_list[i_list][0] ) cabac_mvd( h, cb, i_list, 0, 4, 4 );
596 else if( h->mb.i_partition == D_16x8 )
598 if( b_list[i_list][0] ) cabac_mvd( h, cb, i_list, 0, 4, 2 );
599 if( b_list[i_list][1] ) cabac_mvd( h, cb, i_list, 8, 4, 2 );
601 else //if( h->mb.i_partition == D_8x16 )
603 if( b_list[i_list][0] ) cabac_mvd( h, cb, i_list, 0, 2, 4 );
604 if( b_list[i_list][1] ) cabac_mvd( h, cb, i_list, 4, 2, 4 );
608 else /* intra */
609 cabac_mb_header_i( h, cb, i_mb_type, SLICE_TYPE_B, chroma );
612 static ALWAYS_INLINE int cabac_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx, int b_intra, int b_dc )
614 static const uint16_t base_ctx[14] = {85,89,93,97,101,1012,460,464,468,1016,472,476,480,1020};
616 if( b_dc )
618 i_idx -= LUMA_DC;
619 if( i_cat == DCT_CHROMA_DC )
621 int i_nza = h->mb.cache.i_cbp_left != -1 ? (h->mb.cache.i_cbp_left >> (8 + i_idx)) & 1 : b_intra;
622 int i_nzb = h->mb.cache.i_cbp_top != -1 ? (h->mb.cache.i_cbp_top >> (8 + i_idx)) & 1 : b_intra;
623 return base_ctx[i_cat] + 2*i_nzb + i_nza;
625 else
627 int i_nza = (h->mb.cache.i_cbp_left >> (8 + i_idx)) & 1;
628 int i_nzb = (h->mb.cache.i_cbp_top >> (8 + i_idx)) & 1;
629 return base_ctx[i_cat] + 2*i_nzb + i_nza;
632 else
634 int i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
635 int i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
636 if( x264_constant_p(b_intra) && !b_intra )
637 return base_ctx[i_cat] + ((2*i_nzb + i_nza)&0x7f);
638 else
640 i_nza &= 0x7f + (b_intra << 7);
641 i_nzb &= 0x7f + (b_intra << 7);
642 return base_ctx[i_cat] + 2*!!i_nzb + !!i_nza;
647 // node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
648 // 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
649 /* map node ctx => cabac ctx for level=1 */
650 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
651 /* map node ctx => cabac ctx for level>1 */
652 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
653 /* 4:2:2 chroma dc uses a slightly different state machine for some reason, also note that
654 * 4:2:0 chroma dc doesn't use the last state so it has identical output with both arrays. */
655 static const uint8_t coeff_abs_levelgt1_ctx_chroma_dc[8] = { 5, 5, 5, 5, 6, 7, 8, 8 };
657 static const uint8_t coeff_abs_level_transition[2][8] = {
658 /* update node ctx after coding a level=1 */
659 { 1, 2, 3, 3, 4, 5, 6, 7 },
660 /* update node ctx after coding a level>1 */
661 { 4, 4, 4, 4, 5, 6, 7, 7 }
664 #if !RDO_SKIP_BS
665 static ALWAYS_INLINE void cabac_block_residual_internal( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l, int chroma422dc )
667 int ctx_sig = x264_significant_coeff_flag_offset[MB_INTERLACED][ctx_block_cat];
668 int ctx_last = x264_last_coeff_flag_offset[MB_INTERLACED][ctx_block_cat];
669 int ctx_level = x264_coeff_abs_level_m1_offset[ctx_block_cat];
670 int coeff_idx = -1, node_ctx = 0;
671 int last = h->quantf.coeff_last[ctx_block_cat]( l );
672 const uint8_t *levelgt1_ctx = chroma422dc ? coeff_abs_levelgt1_ctx_chroma_dc : coeff_abs_levelgt1_ctx;
673 dctcoef coeffs[64];
675 #define WRITE_SIGMAP( sig_off, last_off )\
677 int i = 0;\
678 while( 1 )\
680 if( l[i] )\
682 coeffs[++coeff_idx] = l[i];\
683 x264_cabac_encode_decision( cb, ctx_sig + sig_off, 1 );\
684 if( i == last )\
686 x264_cabac_encode_decision( cb, ctx_last + last_off, 1 );\
687 break;\
689 else\
690 x264_cabac_encode_decision( cb, ctx_last + last_off, 0 );\
692 else\
693 x264_cabac_encode_decision( cb, ctx_sig + sig_off, 0 );\
694 if( ++i == count_m1 )\
696 coeffs[++coeff_idx] = l[i];\
697 break;\
702 if( chroma422dc )
704 int count_m1 = 7;
705 WRITE_SIGMAP( x264_coeff_flag_offset_chroma_422_dc[i], x264_coeff_flag_offset_chroma_422_dc[i] )
707 else
709 int count_m1 = x264_count_cat_m1[ctx_block_cat];
710 if( count_m1 == 63 )
712 const uint8_t *sig_offset = x264_significant_coeff_flag_offset_8x8[MB_INTERLACED];
713 WRITE_SIGMAP( sig_offset[i], x264_last_coeff_flag_offset_8x8[i] )
715 else
716 WRITE_SIGMAP( i, i )
721 /* write coeff_abs - 1 */
722 int coeff = coeffs[coeff_idx];
723 int abs_coeff = abs(coeff);
724 int coeff_sign = coeff >> 31;
725 int ctx = coeff_abs_level1_ctx[node_ctx] + ctx_level;
727 if( abs_coeff > 1 )
729 x264_cabac_encode_decision( cb, ctx, 1 );
730 ctx = levelgt1_ctx[node_ctx] + ctx_level;
731 for( int i = X264_MIN( abs_coeff, 15 ) - 2; i > 0; i-- )
732 x264_cabac_encode_decision( cb, ctx, 1 );
733 if( abs_coeff < 15 )
734 x264_cabac_encode_decision( cb, ctx, 0 );
735 else
736 x264_cabac_encode_ue_bypass( cb, 0, abs_coeff - 15 );
738 node_ctx = coeff_abs_level_transition[1][node_ctx];
740 else
742 x264_cabac_encode_decision( cb, ctx, 0 );
743 node_ctx = coeff_abs_level_transition[0][node_ctx];
746 x264_cabac_encode_bypass( cb, coeff_sign );
747 } while( --coeff_idx >= 0 );
750 void x264_cabac_block_residual_c( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
752 cabac_block_residual_internal( h, cb, ctx_block_cat, l, 0 );
755 static ALWAYS_INLINE void cabac_block_residual( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
757 #if ARCH_X86_64 && HAVE_MMX && !defined( __MACH__ )
758 h->bsf.cabac_block_residual_internal( l, MB_INTERLACED, ctx_block_cat, cb );
759 #else
760 x264_cabac_block_residual_c( h, cb, ctx_block_cat, l );
761 #endif
763 static void cabac_block_residual_422_dc( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
765 /* Template a version specifically for chroma 4:2:2 DC in order to avoid
766 * slowing down everything else due to the added complexity. */
767 cabac_block_residual_internal( h, cb, DCT_CHROMA_DC, l, 1 );
769 #define cabac_block_residual_8x8( h, cb, cat, l ) cabac_block_residual( h, cb, cat, l )
770 #else
772 /* Faster RDO by merging sigmap and level coding. Note that for 8x8dct and chroma 4:2:2 dc this is
773 * slightly incorrect because the sigmap is not reversible (contexts are repeated). However, there
774 * is nearly no quality penalty for this (~0.001db) and the speed boost (~30%) is worth it. */
775 static ALWAYS_INLINE void cabac_block_residual_internal( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l, int b_8x8, int chroma422dc )
777 const uint8_t *sig_offset = x264_significant_coeff_flag_offset_8x8[MB_INTERLACED];
778 int ctx_sig = x264_significant_coeff_flag_offset[MB_INTERLACED][ctx_block_cat];
779 int ctx_last = x264_last_coeff_flag_offset[MB_INTERLACED][ctx_block_cat];
780 int ctx_level = x264_coeff_abs_level_m1_offset[ctx_block_cat];
781 int last = h->quantf.coeff_last[ctx_block_cat]( l );
782 int coeff_abs = abs(l[last]);
783 int ctx = coeff_abs_level1_ctx[0] + ctx_level;
784 int node_ctx;
785 const uint8_t *levelgt1_ctx = chroma422dc ? coeff_abs_levelgt1_ctx_chroma_dc : coeff_abs_levelgt1_ctx;
787 if( last != (b_8x8 ? 63 : chroma422dc ? 7 : x264_count_cat_m1[ctx_block_cat]) )
789 x264_cabac_encode_decision( cb, ctx_sig + (b_8x8 ? sig_offset[last] :
790 chroma422dc ? x264_coeff_flag_offset_chroma_422_dc[last] : last), 1 );
791 x264_cabac_encode_decision( cb, ctx_last + (b_8x8 ? x264_last_coeff_flag_offset_8x8[last] :
792 chroma422dc ? x264_coeff_flag_offset_chroma_422_dc[last] : last), 1 );
795 if( coeff_abs > 1 )
797 x264_cabac_encode_decision( cb, ctx, 1 );
798 ctx = levelgt1_ctx[0] + ctx_level;
799 if( coeff_abs < 15 )
801 cb->f8_bits_encoded += x264_cabac_size_unary[coeff_abs-1][cb->state[ctx]];
802 cb->state[ctx] = x264_cabac_transition_unary[coeff_abs-1][cb->state[ctx]];
804 else
806 cb->f8_bits_encoded += x264_cabac_size_unary[14][cb->state[ctx]];
807 cb->state[ctx] = x264_cabac_transition_unary[14][cb->state[ctx]];
808 x264_cabac_encode_ue_bypass( cb, 0, coeff_abs - 15 );
810 node_ctx = coeff_abs_level_transition[1][0];
812 else
814 x264_cabac_encode_decision( cb, ctx, 0 );
815 node_ctx = coeff_abs_level_transition[0][0];
816 x264_cabac_encode_bypass( cb, 0 ); // sign
819 for( int i = last-1; i >= 0; i-- )
821 if( l[i] )
823 coeff_abs = abs(l[i]);
824 x264_cabac_encode_decision( cb, ctx_sig + (b_8x8 ? sig_offset[i] :
825 chroma422dc ? x264_coeff_flag_offset_chroma_422_dc[i] : i), 1 );
826 x264_cabac_encode_decision( cb, ctx_last + (b_8x8 ? x264_last_coeff_flag_offset_8x8[i] :
827 chroma422dc ? x264_coeff_flag_offset_chroma_422_dc[i] : i), 0 );
828 ctx = coeff_abs_level1_ctx[node_ctx] + ctx_level;
830 if( coeff_abs > 1 )
832 x264_cabac_encode_decision( cb, ctx, 1 );
833 ctx = levelgt1_ctx[node_ctx] + ctx_level;
834 if( coeff_abs < 15 )
836 cb->f8_bits_encoded += x264_cabac_size_unary[coeff_abs-1][cb->state[ctx]];
837 cb->state[ctx] = x264_cabac_transition_unary[coeff_abs-1][cb->state[ctx]];
839 else
841 cb->f8_bits_encoded += x264_cabac_size_unary[14][cb->state[ctx]];
842 cb->state[ctx] = x264_cabac_transition_unary[14][cb->state[ctx]];
843 x264_cabac_encode_ue_bypass( cb, 0, coeff_abs - 15 );
845 node_ctx = coeff_abs_level_transition[1][node_ctx];
847 else
849 x264_cabac_encode_decision( cb, ctx, 0 );
850 node_ctx = coeff_abs_level_transition[0][node_ctx];
851 x264_cabac_encode_bypass( cb, 0 );
854 else
855 x264_cabac_encode_decision( cb, ctx_sig + (b_8x8 ? sig_offset[i] :
856 chroma422dc ? x264_coeff_flag_offset_chroma_422_dc[i] : i), 0 );
860 void x264_cabac_block_residual_8x8_rd_c( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
862 cabac_block_residual_internal( h, cb, ctx_block_cat, l, 1, 0 );
864 void x264_cabac_block_residual_rd_c( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
866 cabac_block_residual_internal( h, cb, ctx_block_cat, l, 0, 0 );
869 static ALWAYS_INLINE void cabac_block_residual_8x8( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
871 #if ARCH_X86_64 && HAVE_MMX && !defined( __MACH__ )
872 h->bsf.cabac_block_residual_8x8_rd_internal( l, MB_INTERLACED, ctx_block_cat, cb );
873 #else
874 x264_cabac_block_residual_8x8_rd_c( h, cb, ctx_block_cat, l );
875 #endif
877 static ALWAYS_INLINE void cabac_block_residual( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
879 #if ARCH_X86_64 && HAVE_MMX && !defined( __MACH__ )
880 h->bsf.cabac_block_residual_rd_internal( l, MB_INTERLACED, ctx_block_cat, cb );
881 #else
882 x264_cabac_block_residual_rd_c( h, cb, ctx_block_cat, l );
883 #endif
886 static void cabac_block_residual_422_dc( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
888 cabac_block_residual_internal( h, cb, DCT_CHROMA_DC, l, 0, 1 );
890 #endif
892 #define cabac_block_residual_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, b_dc, name )\
895 int ctxidxinc = cabac_cbf_ctxidxinc( h, ctx_block_cat, i_idx, b_intra, b_dc );\
896 if( h->mb.cache.non_zero_count[x264_scan8[i_idx]] )\
898 x264_cabac_encode_decision( cb, ctxidxinc, 1 );\
899 cabac_block_residual##name( h, cb, ctx_block_cat, l );\
901 else\
902 x264_cabac_encode_decision( cb, ctxidxinc, 0 );\
903 } while( 0 )
905 #define cabac_block_residual_dc_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
906 cabac_block_residual_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, 1, )
908 #define cabac_block_residual_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
909 cabac_block_residual_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, 0, )
911 #define cabac_block_residual_8x8_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
912 cabac_block_residual_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, 0, _8x8 )
914 #define cabac_block_residual_422_dc_cbf( h, cb, ch, b_intra )\
915 cabac_block_residual_cbf_internal( h, cb, DCT_CHROMA_DC, CHROMA_DC+(ch), h->dct.chroma_dc[ch], b_intra, 1, _422_dc )
917 static ALWAYS_INLINE void macroblock_write_cabac_internal( x264_t *h, x264_cabac_t *cb, int plane_count, int chroma )
919 const int i_mb_type = h->mb.i_type;
921 #if !RDO_SKIP_BS
922 const int i_mb_pos_start = x264_cabac_pos( cb );
923 int i_mb_pos_tex;
925 if( SLICE_MBAFF &&
926 (!(h->mb.i_mb_y & 1) || IS_SKIP(h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride])) )
928 cabac_field_decoding_flag( h, cb );
930 #endif
932 if( h->sh.i_type == SLICE_TYPE_P )
933 cabac_mb_header_p( h, cb, i_mb_type, chroma );
934 else if( h->sh.i_type == SLICE_TYPE_B )
935 cabac_mb_header_b( h, cb, i_mb_type, chroma );
936 else //if( h->sh.i_type == SLICE_TYPE_I )
937 cabac_mb_header_i( h, cb, i_mb_type, SLICE_TYPE_I, chroma );
939 #if !RDO_SKIP_BS
940 i_mb_pos_tex = x264_cabac_pos( cb );
941 h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
943 if( i_mb_type == I_PCM )
945 bs_t s;
946 bs_init( &s, cb->p, cb->p_end - cb->p );
948 for( int p = 0; p < plane_count; p++ )
949 for( int i = 0; i < 256; i++ )
950 bs_write( &s, BIT_DEPTH, h->mb.pic.p_fenc[p][i] );
951 if( chroma )
952 for( int ch = 1; ch < 3; ch++ )
953 for( int i = 0; i < 16>>CHROMA_V_SHIFT; i++ )
954 for( int j = 0; j < 8; j++ )
955 bs_write( &s, BIT_DEPTH, h->mb.pic.p_fenc[ch][i*FENC_STRIDE+j] );
957 bs_flush( &s );
958 cb->p = s.p;
959 x264_cabac_encode_init_core( cb );
961 h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
962 return;
964 #endif
966 if( i_mb_type != I_16x16 )
968 cabac_cbp_luma( h, cb );
969 if( chroma )
970 cabac_cbp_chroma( h, cb );
973 if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
975 cabac_transform_size( h, cb );
978 if( h->mb.i_cbp_luma || (chroma && h->mb.i_cbp_chroma) || i_mb_type == I_16x16 )
980 const int b_intra = IS_INTRA( i_mb_type );
981 cabac_qp_delta( h, cb );
983 /* write residual */
984 if( i_mb_type == I_16x16 )
986 /* DC Luma */
987 for( int p = 0; p < plane_count; p++ )
989 cabac_block_residual_dc_cbf( h, cb, ctx_cat_plane[DCT_LUMA_DC][p], LUMA_DC+p, h->dct.luma16x16_dc[p], 1 );
991 /* AC Luma */
992 if( h->mb.i_cbp_luma )
993 for( int i = p*16; i < p*16+16; i++ )
994 cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_AC][p], i, h->dct.luma4x4[i]+1, 1 );
997 else if( h->mb.b_transform_8x8 )
999 if( plane_count == 3 )
1001 ALIGNED_4( uint8_t nnzbak[3][8] );
1003 /* Stupid nnz munging in the case that neighbors don't have
1004 * 8x8 transform enabled. */
1005 #define BACKUP( dst, src, res )\
1006 dst = src;\
1007 src = res;
1009 #define RESTORE( dst, src, res )\
1010 src = dst;
1012 #define MUNGE_8x8_NNZ( MUNGE )\
1013 if( (h->mb.i_neighbour & MB_LEFT) && !h->mb.mb_transform_size[h->mb.i_mb_left_xy[0]] && !(h->mb.cbp[h->mb.i_mb_left_xy[0]] & 0x1000) )\
1015 MUNGE( nnzbak[0][0], h->mb.cache.non_zero_count[x264_scan8[16*0+ 0] - 1], 0x00 )\
1016 MUNGE( nnzbak[0][1], h->mb.cache.non_zero_count[x264_scan8[16*0+ 2] - 1], 0x00 )\
1017 MUNGE( nnzbak[1][0], h->mb.cache.non_zero_count[x264_scan8[16*1+ 0] - 1], 0x00 )\
1018 MUNGE( nnzbak[1][1], h->mb.cache.non_zero_count[x264_scan8[16*1+ 2] - 1], 0x00 )\
1019 MUNGE( nnzbak[2][0], h->mb.cache.non_zero_count[x264_scan8[16*2+ 0] - 1], 0x00 )\
1020 MUNGE( nnzbak[2][1], h->mb.cache.non_zero_count[x264_scan8[16*2+ 2] - 1], 0x00 )\
1022 if( (h->mb.i_neighbour & MB_LEFT) && !h->mb.mb_transform_size[h->mb.i_mb_left_xy[1]] && !(h->mb.cbp[h->mb.i_mb_left_xy[1]] & 0x1000) )\
1024 MUNGE( nnzbak[0][2], h->mb.cache.non_zero_count[x264_scan8[16*0+ 8] - 1], 0x00 )\
1025 MUNGE( nnzbak[0][3], h->mb.cache.non_zero_count[x264_scan8[16*0+10] - 1], 0x00 )\
1026 MUNGE( nnzbak[1][2], h->mb.cache.non_zero_count[x264_scan8[16*1+ 8] - 1], 0x00 )\
1027 MUNGE( nnzbak[1][3], h->mb.cache.non_zero_count[x264_scan8[16*1+10] - 1], 0x00 )\
1028 MUNGE( nnzbak[2][2], h->mb.cache.non_zero_count[x264_scan8[16*2+ 8] - 1], 0x00 )\
1029 MUNGE( nnzbak[2][3], h->mb.cache.non_zero_count[x264_scan8[16*2+10] - 1], 0x00 )\
1031 if( (h->mb.i_neighbour & MB_TOP) && !h->mb.mb_transform_size[h->mb.i_mb_top_xy] && !(h->mb.cbp[h->mb.i_mb_top_xy] & 0x1000) )\
1033 MUNGE( M32( &nnzbak[0][4] ), M32( &h->mb.cache.non_zero_count[x264_scan8[16*0] - 8] ), 0x00000000U )\
1034 MUNGE( M32( &nnzbak[1][4] ), M32( &h->mb.cache.non_zero_count[x264_scan8[16*1] - 8] ), 0x00000000U )\
1035 MUNGE( M32( &nnzbak[2][4] ), M32( &h->mb.cache.non_zero_count[x264_scan8[16*2] - 8] ), 0x00000000U )\
1038 MUNGE_8x8_NNZ( BACKUP )
1040 for( int p = 0; p < 3; p++ )
1041 FOREACH_BIT( i, 0, h->mb.i_cbp_luma )
1042 cabac_block_residual_8x8_cbf( h, cb, ctx_cat_plane[DCT_LUMA_8x8][p], i*4+p*16, h->dct.luma8x8[i+p*4], b_intra );
1044 MUNGE_8x8_NNZ( RESTORE )
1046 else
1048 FOREACH_BIT( i, 0, h->mb.i_cbp_luma )
1049 cabac_block_residual_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i] );
1052 else
1054 for( int p = 0; p < plane_count; p++ )
1055 FOREACH_BIT( i8x8, 0, h->mb.i_cbp_luma )
1056 for( int i = 0; i < 4; i++ )
1057 cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], i+i8x8*4+p*16, h->dct.luma4x4[i+i8x8*4+p*16], b_intra );
1060 if( chroma && h->mb.i_cbp_chroma ) /* Chroma DC residual present */
1062 if( CHROMA_FORMAT == CHROMA_422 )
1064 cabac_block_residual_422_dc_cbf( h, cb, 0, b_intra );
1065 cabac_block_residual_422_dc_cbf( h, cb, 1, b_intra );
1067 else
1069 cabac_block_residual_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+0, h->dct.chroma_dc[0], b_intra );
1070 cabac_block_residual_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+1, h->dct.chroma_dc[1], b_intra );
1073 if( h->mb.i_cbp_chroma == 2 ) /* Chroma AC residual present */
1075 int step = 8 << CHROMA_V_SHIFT;
1076 for( int i = 16; i < 3*16; i += step )
1077 for( int j = i; j < i+4; j++ )
1078 cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, j, h->dct.luma4x4[j]+1, b_intra );
1083 #if !RDO_SKIP_BS
1084 h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
1085 #endif
1088 void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
1090 if( CHROMA444 )
1091 macroblock_write_cabac_internal( h, cb, 3, 0 );
1092 else if( CHROMA_FORMAT )
1093 macroblock_write_cabac_internal( h, cb, 1, 1 );
1094 else
1095 macroblock_write_cabac_internal( h, cb, 1, 0 );
1098 #if RDO_SKIP_BS
1099 /*****************************************************************************
1100 * RD only; doesn't generate a valid bitstream
1101 * doesn't write cbp or chroma dc (I don't know how much this matters)
1102 * doesn't write ref (never varies between calls, so no point in doing so)
1103 * only writes subpartition for p8x8, needed for sub-8x8 mode decision RDO
1104 * works on all partition sizes except 16x16
1105 *****************************************************************************/
1106 static void partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
1108 const int i_mb_type = h->mb.i_type;
1109 int b_8x16 = h->mb.i_partition == D_8x16;
1110 int plane_count = CHROMA444 ? 3 : 1;
1112 if( i_mb_type == P_8x8 )
1114 cabac_8x8_mvd( h, cb, i8 );
1115 cabac_subpartition_p( cb, h->mb.i_sub_partition[i8] );
1117 else if( i_mb_type == P_L0 )
1118 cabac_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
1119 else if( i_mb_type > B_DIRECT && i_mb_type < B_8x8 )
1121 if( x264_mb_type_list_table[ i_mb_type ][0][!!i8] ) cabac_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
1122 if( x264_mb_type_list_table[ i_mb_type ][1][!!i8] ) cabac_mvd( h, cb, 1, 4*i8, 4>>b_8x16, 2<<b_8x16 );
1124 else //if( i_mb_type == B_8x8 )
1126 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
1127 cabac_mvd( h, cb, 0, 4*i8, 2, 2 );
1128 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
1129 cabac_mvd( h, cb, 1, 4*i8, 2, 2 );
1132 for( int j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
1134 if( h->mb.i_cbp_luma & (1 << i8) )
1136 if( h->mb.b_transform_8x8 )
1138 if( CHROMA444 )
1139 for( int p = 0; p < 3; p++ )
1140 cabac_block_residual_8x8_cbf( h, cb, ctx_cat_plane[DCT_LUMA_8x8][p], i8*4+p*16, h->dct.luma8x8[i8+p*4], 0 );
1141 else
1142 cabac_block_residual_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i8] );
1144 else
1145 for( int p = 0; p < plane_count; p++ )
1146 for( int i4 = 0; i4 < 4; i4++ )
1147 cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], i4+i8*4+p*16, h->dct.luma4x4[i4+i8*4+p*16], 0 );
1150 if( h->mb.i_cbp_chroma )
1152 if( CHROMA_FORMAT == CHROMA_422 )
1154 int offset = (5*i8) & 0x09;
1155 cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 16+offset, h->dct.luma4x4[16+offset]+1, 0 );
1156 cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 18+offset, h->dct.luma4x4[18+offset]+1, 0 );
1157 cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 32+offset, h->dct.luma4x4[32+offset]+1, 0 );
1158 cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 34+offset, h->dct.luma4x4[34+offset]+1, 0 );
1160 else
1162 cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 0 );
1163 cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 32+i8, h->dct.luma4x4[32+i8]+1, 0 );
1167 i8 += x264_pixel_size[i_pixel].h >> 3;
1171 static void subpartition_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_pixel )
1173 int b_8x4 = i_pixel == PIXEL_8x4;
1174 int plane_count = CHROMA444 ? 3 : 1;
1175 if( i_pixel == PIXEL_4x4 )
1176 cabac_mvd( h, cb, 0, i4, 1, 1 );
1177 else
1178 cabac_mvd( h, cb, 0, i4, 1+b_8x4, 2-b_8x4 );
1179 for( int p = 0; p < plane_count; p++ )
1181 cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], p*16+i4, h->dct.luma4x4[p*16+i4], 0 );
1182 if( i_pixel != PIXEL_4x4 )
1183 cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], p*16+i4+2-b_8x4, h->dct.luma4x4[p*16+i4+2-b_8x4], 0 );
1187 static void partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
1189 const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
1190 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1191 cabac_intra4x4_pred_mode( cb, i_pred, i_mode );
1192 cabac_cbp_luma( h, cb );
1193 if( h->mb.i_cbp_luma & (1 << i8) )
1195 if( CHROMA444 )
1196 for( int p = 0; p < 3; p++ )
1197 cabac_block_residual_8x8_cbf( h, cb, ctx_cat_plane[DCT_LUMA_8x8][p], i8*4+p*16, h->dct.luma8x8[i8+p*4], 1 );
1198 else
1199 cabac_block_residual_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i8] );
1203 static void partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
1205 const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
1206 int plane_count = CHROMA444 ? 3 : 1;
1207 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1208 cabac_intra4x4_pred_mode( cb, i_pred, i_mode );
1209 for( int p = 0; p < plane_count; p++ )
1210 cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], i4+p*16, h->dct.luma4x4[i4+p*16], 1 );
1213 static void chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
1215 cabac_intra_chroma_pred_mode( h, cb );
1216 cabac_cbp_chroma( h, cb );
1217 if( h->mb.i_cbp_chroma )
1219 if( CHROMA_FORMAT == CHROMA_422 )
1221 cabac_block_residual_422_dc_cbf( h, cb, 0, 1 );
1222 cabac_block_residual_422_dc_cbf( h, cb, 1, 1 );
1224 else
1226 cabac_block_residual_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+0, h->dct.chroma_dc[0], 1 );
1227 cabac_block_residual_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+1, h->dct.chroma_dc[1], 1 );
1230 if( h->mb.i_cbp_chroma == 2 )
1232 int step = 8 << CHROMA_V_SHIFT;
1233 for( int i = 16; i < 3*16; i += step )
1234 for( int j = i; j < i+4; j++ )
1235 cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, j, h->dct.luma4x4[j]+1, 1 );
1239 #endif