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"
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 );
43 else if( i_mb_type
== I_PCM
)
45 x264_cabac_encode_decision_noup( cb
, ctx0
, 1 );
46 x264_cabac_encode_flush( h
, cb
);
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 );
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 );
70 static void cabac_field_decoding_flag( x264_t
*h
, x264_cabac_t
*cb
)
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
;
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 );
89 x264_cabac_encode_decision( cb
, 68, 0 );
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
];
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 )
106 if( (h
->mb
.i_neighbour
& MB_TOP
) && h
->mb
.chroma_pred_mode
[h
->mb
.i_mb_top_xy
] != 0 )
109 x264_cabac_encode_decision_noup( cb
, 64 + ctx
, i_mode
> 0 );
112 x264_cabac_encode_decision( cb
, 64 + 3, 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;
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 );
141 x264_cabac_encode_decision_noup( cb
, 77 + ctx
, 1 );
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
;
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
)
161 h
->mb
.i_qp
= h
->mb
.i_last_qp
;
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));
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. */
174 if( val
< 0 ) val
= i_dqp
;
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 );
185 x264_cabac_encode_decision_noup( cb
, 60 + ctx
, 0 );
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
)
194 x264_cabac_encode_decision( &h
->cabac
, ctx
, b_skip
);
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 );
205 x264_cabac_encode_decision( cb
, 21, 0 );
206 if( i_sub
== D_L0_8x4
)
207 x264_cabac_encode_decision( cb
, 22, 0 );
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 );
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 );
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];
248 if( i_refa
> 0 && (!bframe
|| !h
->mb
.cache
.skip
[i8
- 1]) )
250 if( i_refb
> 0 && (!bframe
|| !h
->mb
.cache
.skip
[i8
- 8]) )
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 );
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;
276 x264_cabac_encode_decision( cb
, ctxbase
+ ctx
, 0 );
280 int i_abs
= abs( mvd
);
281 x264_cabac_encode_decision( cb
, ctxbase
+ ctx
, 1 );
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 );
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 );
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]];
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 );
308 static const uint8_t ctxes
[8] = { 3,4,5,6,6,6,6,6 };
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 );
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 );
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] );
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]);
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 );\
355 static inline void cabac_8x8_mvd( x264_t
*h
, x264_cabac_t
*cb
, int i
)
357 switch( h
->mb
.i_sub_partition
[i
] )
360 cabac_mvd( h
, cb
, 0, 4*i
, 2, 2 );
363 cabac_mvd( h
, cb
, 0, 4*i
+0, 2, 1 );
364 cabac_mvd( h
, cb
, 0, 4*i
+2, 2, 1 );
367 cabac_mvd( h
, cb
, 0, 4*i
+0, 1, 2 );
368 cabac_mvd( h
, cb
, 0, 4*i
+1, 1, 2 );
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 );
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
)
386 if( (h
->mb
.i_neighbour
& MB_LEFT
) && h
->mb
.i_mb_type_left
[0] != I_4x4
)
388 if( (h
->mb
.i_neighbour
& MB_TOP
) && h
->mb
.i_mb_type_top
!= I_4x4
)
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
)
396 x264_cabac_encode_decision_noup( cb
, 14, 1 );
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
)
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 );
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
)
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
);
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 );
480 for( int i
= 0; i
< 4; i
++ )
481 cabac_subpartition_p( cb
, h
->mb
.i_sub_partition
[i
] );
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
);
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
)
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
)
504 if( (h
->mb
.i_neighbour
& MB_TOP
) && h
->mb
.i_mb_type_top
!= B_SKIP
&& h
->mb
.i_mb_type_top
!= B_DIRECT
)
507 if( i_mb_type
== B_DIRECT
)
509 x264_cabac_encode_decision_noup( cb
, 27+ctx
, 0 );
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 );
523 for( int i
= 0; i
< 4; i
++ )
524 cabac_subpartition_b( cb
, h
->mb
.i_sub_partition
[i
] );
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
)
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;
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;
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 )
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 )
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 );
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};
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
;
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
;
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);
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 }
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
;
675 #define WRITE_SIGMAP( sig_off, last_off )\
682 coeffs[++coeff_idx] = l[i];\
683 x264_cabac_encode_decision( cb, ctx_sig + sig_off, 1 );\
686 x264_cabac_encode_decision( cb, ctx_last + last_off, 1 );\
690 x264_cabac_encode_decision( cb, ctx_last + last_off, 0 );\
693 x264_cabac_encode_decision( cb, ctx_sig + sig_off, 0 );\
694 if( ++i == count_m1 )\
696 coeffs[++coeff_idx] = l[i];\
705 WRITE_SIGMAP( x264_coeff_flag_offset_chroma_422_dc
[i
], x264_coeff_flag_offset_chroma_422_dc
[i
] )
709 int count_m1
= x264_count_cat_m1
[ctx_block_cat
];
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
] )
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
;
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 );
734 x264_cabac_encode_decision( cb
, ctx
, 0 );
736 x264_cabac_encode_ue_bypass( cb
, 0, abs_coeff
- 15 );
738 node_ctx
= coeff_abs_level_transition
[1][node_ctx
];
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
);
760 x264_cabac_block_residual_c( h
, cb
, ctx_block_cat
, l
);
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 )
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
;
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 );
797 x264_cabac_encode_decision( cb
, ctx
, 1 );
798 ctx
= levelgt1_ctx
[0] + ctx_level
;
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
]];
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];
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
-- )
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
;
832 x264_cabac_encode_decision( cb
, ctx
, 1 );
833 ctx
= levelgt1_ctx
[node_ctx
] + ctx_level
;
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
]];
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
];
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 );
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
);
874 x264_cabac_block_residual_8x8_rd_c( h
, cb
, ctx_block_cat
, l
);
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
);
882 x264_cabac_block_residual_rd_c( h
, cb
, ctx_block_cat
, l
);
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 );
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 );\
902 x264_cabac_encode_decision( cb, ctxidxinc, 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
;
922 const int i_mb_pos_start
= x264_cabac_pos( cb
);
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
);
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
);
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
)
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
] );
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
] );
959 x264_cabac_encode_init_core( cb
);
961 h
->stat
.frame
.i_tex_bits
+= x264_cabac_pos( cb
) - i_mb_pos_tex
;
966 if( i_mb_type
!= I_16x16
)
968 cabac_cbp_luma( h
, cb
);
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
);
984 if( i_mb_type
== I_16x16
)
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 );
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 )\
1009 #define RESTORE( dst, src, res )\
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
)
1048 FOREACH_BIT( i
, 0, h
->mb
.i_cbp_luma
)
1049 cabac_block_residual_8x8( h
, cb
, DCT_LUMA_8x8
, h
->dct
.luma8x8
[i
] );
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
);
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
);
1084 h
->stat
.frame
.i_tex_bits
+= x264_cabac_pos( cb
) - i_mb_pos_tex
;
1088 void x264_macroblock_write_cabac( x264_t
*h
, x264_cabac_t
*cb
)
1091 macroblock_write_cabac_internal( h
, cb
, 3, 0 );
1092 else if( CHROMA_FORMAT
)
1093 macroblock_write_cabac_internal( h
, cb
, 1, 1 );
1095 macroblock_write_cabac_internal( h
, cb
, 1, 0 );
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
)
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 );
1142 cabac_block_residual_8x8( h
, cb
, DCT_LUMA_8x8
, h
->dct
.luma8x8
[i8
] );
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 );
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 );
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
) )
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 );
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 );
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 );