2 * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * H.264 / AVC / MPEG-4 part10 cavlc bitstream decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
29 #define UNCHECKED_BITSTREAM_READER 1
34 #include "h264_mvpred.h"
37 #include "mpegutils.h"
38 #include "libavutil/avassert.h"
41 static const uint8_t golomb_to_inter_cbp_gray[16]={
42 0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
45 static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
46 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
49 static const uint8_t chroma_dc_coeff_token_len[4*5]={
57 static const uint8_t chroma_dc_coeff_token_bits[4*5]={
65 static const uint8_t chroma422_dc_coeff_token_len[4*9]={
77 static const uint8_t chroma422_dc_coeff_token_bits[4*9]={
89 static const uint8_t coeff_token_len[4][4*17]={
92 6, 2, 0, 0, 8, 6, 3, 0, 9, 8, 7, 5, 10, 9, 8, 6,
93 11,10, 9, 7, 13,11,10, 8, 13,13,11, 9, 13,13,13,10,
94 14,14,13,11, 14,14,14,13, 15,15,14,14, 15,15,15,14,
95 16,15,15,15, 16,16,16,15, 16,16,16,16, 16,16,16,16,
99 6, 2, 0, 0, 6, 5, 3, 0, 7, 6, 6, 4, 8, 6, 6, 4,
100 8, 7, 7, 5, 9, 8, 8, 6, 11, 9, 9, 6, 11,11,11, 7,
101 12,11,11, 9, 12,12,12,11, 12,12,12,11, 13,13,13,12,
102 13,13,13,13, 13,14,13,13, 14,14,14,13, 14,14,14,14,
106 6, 4, 0, 0, 6, 5, 4, 0, 6, 5, 5, 4, 7, 5, 5, 4,
107 7, 5, 5, 4, 7, 6, 6, 4, 7, 6, 6, 4, 8, 7, 7, 5,
108 8, 8, 7, 6, 9, 8, 8, 7, 9, 9, 8, 8, 9, 9, 9, 8,
109 10, 9, 9, 9, 10,10,10,10, 10,10,10,10, 10,10,10,10,
113 6, 6, 0, 0, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6,
114 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
115 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
116 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
120 static const uint8_t coeff_token_bits[4][4*17]={
123 5, 1, 0, 0, 7, 4, 1, 0, 7, 6, 5, 3, 7, 6, 5, 3,
124 7, 6, 5, 4, 15, 6, 5, 4, 11,14, 5, 4, 8,10,13, 4,
125 15,14, 9, 4, 11,10,13,12, 15,14, 9,12, 11,10,13, 8,
126 15, 1, 9,12, 11,14,13, 8, 7,10, 9,12, 4, 6, 5, 8,
130 11, 2, 0, 0, 7, 7, 3, 0, 7,10, 9, 5, 7, 6, 5, 4,
131 4, 6, 5, 6, 7, 6, 5, 8, 15, 6, 5, 4, 11,14,13, 4,
132 15,10, 9, 4, 11,14,13,12, 8,10, 9, 8, 15,14,13,12,
133 11,10, 9,12, 7,11, 6, 8, 9, 8,10, 1, 7, 6, 5, 4,
137 15,14, 0, 0, 11,15,13, 0, 8,12,14,12, 15,10,11,11,
138 11, 8, 9,10, 9,14,13, 9, 8,10, 9, 8, 15,14,13,13,
139 11,14,10,12, 15,10,13,12, 11,14, 9,12, 8,10,13, 8,
140 13, 7, 9,12, 9,12,11,10, 5, 8, 7, 6, 1, 4, 3, 2,
144 0, 1, 0, 0, 4, 5, 6, 0, 8, 9,10,11, 12,13,14,15,
145 16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31,
146 32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47,
147 48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63,
151 static const uint8_t total_zeros_len[16][16]= {
152 {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
153 {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
154 {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
155 {5,3,4,4,3,3,3,4,3,4,5,5,5},
156 {4,4,4,3,3,3,3,3,4,5,4,5},
157 {6,5,3,3,3,3,3,3,4,3,6},
158 {6,5,3,3,3,2,3,4,3,6},
169 static const uint8_t total_zeros_bits[16][16]= {
170 {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
171 {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
172 {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
173 {3,7,5,4,6,5,4,3,3,2,2,1,0},
174 {5,4,3,7,6,5,4,3,2,1,1,0},
175 {1,1,7,6,5,4,3,2,1,1,0},
176 {1,1,5,4,3,3,2,1,1,0},
187 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
193 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
199 static const uint8_t chroma422_dc_total_zeros_len[7][8]= {
200 { 1, 3, 3, 4, 4, 4, 5, 5 },
201 { 3, 2, 3, 3, 3, 3, 3 },
202 { 3, 3, 2, 2, 3, 3 },
209 static const uint8_t chroma422_dc_total_zeros_bits[7][8]= {
210 { 1, 2, 3, 2, 3, 1, 1, 0 },
211 { 0, 1, 1, 4, 5, 6, 7 },
212 { 0, 1, 1, 2, 6, 7 },
219 static const uint8_t run_len[7][16]={
226 {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
229 static const uint8_t run_bits[7][16]={
236 {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
239 static VLC coeff_token_vlc[4];
240 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
241 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
243 static VLC chroma_dc_coeff_token_vlc;
244 static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
245 static const int chroma_dc_coeff_token_vlc_table_size = 256;
247 static VLC chroma422_dc_coeff_token_vlc;
248 static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
249 static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
251 static VLC total_zeros_vlc[15+1];
252 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
253 static const int total_zeros_vlc_tables_size = 512;
255 static VLC chroma_dc_total_zeros_vlc[3+1];
256 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
257 static const int chroma_dc_total_zeros_vlc_tables_size = 8;
259 static VLC chroma422_dc_total_zeros_vlc[7+1];
260 static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
261 static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
263 static VLC run_vlc[6+1];
264 static VLC_TYPE run_vlc_tables[6][8][2];
265 static const int run_vlc_tables_size = 8;
268 static VLC_TYPE run7_vlc_table[96][2];
269 static const int run7_vlc_table_size = 96;
271 #define LEVEL_TAB_BITS 8
272 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
274 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
275 #define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
276 #define COEFF_TOKEN_VLC_BITS 8
277 #define TOTAL_ZEROS_VLC_BITS 9
278 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
279 #define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
280 #define RUN_VLC_BITS 3
281 #define RUN7_VLC_BITS 6
284 * Get the predicted number of non-zero coefficients.
285 * @param n block index
287 static inline int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
289 const int index8= scan8[n];
290 const int left = sl->non_zero_count_cache[index8 - 1];
291 const int top = sl->non_zero_count_cache[index8 - 8];
294 if(i<64) i= (i+1)>>1;
296 ff_tlog(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
301 static av_cold void init_cavlc_level_tab(void){
305 for(suffix_length=0; suffix_length<7; suffix_length++){
306 for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
307 int prefix= LEVEL_TAB_BITS - av_log2(2*i);
309 if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
310 int level_code = (prefix << suffix_length) +
311 (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
312 int mask = -(level_code&1);
313 level_code = (((2 + level_code) >> 1) ^ mask) - mask;
314 cavlc_level_tab[suffix_length][i][0]= level_code;
315 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
316 }else if(prefix + 1 <= LEVEL_TAB_BITS){
317 cavlc_level_tab[suffix_length][i][0]= prefix+100;
318 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
320 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
321 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
327 av_cold void ff_h264_decode_init_vlc(void)
331 chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
332 chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
333 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
334 &chroma_dc_coeff_token_len [0], 1, 1,
335 &chroma_dc_coeff_token_bits[0], 1, 1,
336 INIT_VLC_USE_NEW_STATIC);
338 chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
339 chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
340 init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
341 &chroma422_dc_coeff_token_len [0], 1, 1,
342 &chroma422_dc_coeff_token_bits[0], 1, 1,
343 INIT_VLC_USE_NEW_STATIC);
346 for (int i = 0; i < 4; i++) {
347 coeff_token_vlc[i].table = coeff_token_vlc_tables + offset;
348 coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
349 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
350 &coeff_token_len [i][0], 1, 1,
351 &coeff_token_bits[i][0], 1, 1,
352 INIT_VLC_USE_NEW_STATIC);
353 offset += coeff_token_vlc_tables_size[i];
356 * This is a one time safety check to make sure that
357 * the packed static coeff_token_vlc table sizes
358 * were initialized correctly.
360 av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
362 for (int i = 0; i < 3; i++) {
363 chroma_dc_total_zeros_vlc[i + 1].table = chroma_dc_total_zeros_vlc_tables[i];
364 chroma_dc_total_zeros_vlc[i + 1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
365 init_vlc(&chroma_dc_total_zeros_vlc[i + 1],
366 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
367 &chroma_dc_total_zeros_len [i][0], 1, 1,
368 &chroma_dc_total_zeros_bits[i][0], 1, 1,
369 INIT_VLC_USE_NEW_STATIC);
372 for (int i = 0; i < 7; i++) {
373 chroma422_dc_total_zeros_vlc[i + 1].table = chroma422_dc_total_zeros_vlc_tables[i];
374 chroma422_dc_total_zeros_vlc[i + 1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
375 init_vlc(&chroma422_dc_total_zeros_vlc[i + 1],
376 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
377 &chroma422_dc_total_zeros_len [i][0], 1, 1,
378 &chroma422_dc_total_zeros_bits[i][0], 1, 1,
379 INIT_VLC_USE_NEW_STATIC);
382 for (int i = 0; i < 15; i++) {
383 total_zeros_vlc[i + 1].table = total_zeros_vlc_tables[i];
384 total_zeros_vlc[i + 1].table_allocated = total_zeros_vlc_tables_size;
385 init_vlc(&total_zeros_vlc[i + 1],
386 TOTAL_ZEROS_VLC_BITS, 16,
387 &total_zeros_len [i][0], 1, 1,
388 &total_zeros_bits[i][0], 1, 1,
389 INIT_VLC_USE_NEW_STATIC);
392 for (int i = 0; i < 6; i++) {
393 run_vlc[i + 1].table = run_vlc_tables[i];
394 run_vlc[i + 1].table_allocated = run_vlc_tables_size;
395 init_vlc(&run_vlc[i + 1],
397 &run_len [i][0], 1, 1,
398 &run_bits[i][0], 1, 1,
399 INIT_VLC_USE_NEW_STATIC);
401 run7_vlc.table = run7_vlc_table;
402 run7_vlc.table_allocated = run7_vlc_table_size;
403 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
404 &run_len [6][0], 1, 1,
405 &run_bits[6][0], 1, 1,
406 INIT_VLC_USE_NEW_STATIC);
408 init_cavlc_level_tab();
411 static inline int get_level_prefix(GetBitContext *gb){
416 UPDATE_CACHE(re, gb);
417 buf=GET_CACHE(re, gb);
419 log= 32 - av_log2(buf);
421 LAST_SKIP_BITS(re, gb, log);
422 CLOSE_READER(re, gb);
428 * Decode a residual block.
429 * @param n block index
430 * @param scantable scantable
431 * @param max_coeff number of coefficients in the block
432 * @return <0 if an error occurred
434 static int decode_residual(const H264Context *h, H264SliceContext *sl,
435 GetBitContext *gb, int16_t *block, int n,
436 const uint8_t *scantable, const uint32_t *qmul,
439 static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
441 int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
443 //FIXME put trailing_onex into the context
447 coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
449 coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
450 total_coeff= coeff_token>>2;
452 if(n >= LUMA_DC_BLOCK_INDEX){
453 total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
454 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
455 total_coeff= coeff_token>>2;
457 total_coeff= pred_non_zero_count(h, sl, n);
458 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
459 total_coeff= coeff_token>>2;
462 sl->non_zero_count_cache[scan8[n]] = total_coeff;
464 //FIXME set last_non_zero?
468 if(total_coeff > (unsigned)max_coeff) {
469 av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
473 trailing_ones= coeff_token&3;
474 ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
475 av_assert2(total_coeff<=16);
477 i = show_bits(gb, 3);
478 skip_bits(gb, trailing_ones);
479 level[0] = 1-((i&4)>>1);
480 level[1] = 1-((i&2) );
481 level[2] = 1-((i&1)<<1);
483 if(trailing_ones<total_coeff) {
485 int suffix_length = total_coeff > 10 & trailing_ones < 3;
486 int bitsi= show_bits(gb, LEVEL_TAB_BITS);
487 int level_code= cavlc_level_tab[suffix_length][bitsi][0];
489 skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
490 if(level_code >= 100){
491 prefix= level_code - 100;
492 if(prefix == LEVEL_TAB_BITS)
493 prefix += get_level_prefix(gb);
495 //first coefficient has suffix_length equal to 0 or 1
496 if(prefix<14){ //FIXME try to build a large unified VLC table for all this
498 level_code= (prefix<<1) + get_bits1(gb); //part
500 level_code= prefix; //part
501 }else if(prefix==14){
503 level_code= (prefix<<1) + get_bits1(gb); //part
505 level_code= prefix + get_bits(gb, 4); //part
510 av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
513 level_code += (1<<(prefix-3))-4096;
515 level_code += get_bits(gb, prefix-3); //part
518 if(trailing_ones < 3) level_code += 2;
521 mask= -(level_code&1);
522 level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
524 level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
526 suffix_length = 1 + (level_code + 3U > 6U);
527 level[trailing_ones]= level_code;
530 //remaining coefficients have suffix_length > 0
531 for(i=trailing_ones+1;i<total_coeff;i++) {
532 static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
533 int bitsi= show_bits(gb, LEVEL_TAB_BITS);
534 level_code= cavlc_level_tab[suffix_length][bitsi][0];
536 skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
537 if(level_code >= 100){
538 prefix= level_code - 100;
539 if(prefix == LEVEL_TAB_BITS){
540 prefix += get_level_prefix(gb);
543 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
545 level_code = 15<<suffix_length;
548 av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
549 return AVERROR_INVALIDDATA;
551 level_code += (1<<(prefix-3))-4096;
553 level_code += get_bits(gb, prefix-3);
555 mask= -(level_code&1);
556 level_code= (((2+level_code)>>1) ^ mask) - mask;
558 level[i]= level_code;
559 suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
563 if(total_coeff == max_coeff)
566 if (max_coeff <= 8) {
568 zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
569 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
571 zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
572 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
574 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
578 #define STORE_BLOCK(type) \
579 scantable += zeros_left + total_coeff - 1; \
580 if(n >= LUMA_DC_BLOCK_INDEX){ \
581 ((type*)block)[*scantable] = level[0]; \
582 for(i=1;i<total_coeff && zeros_left > 0;i++) { \
584 run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
586 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
587 zeros_left -= run_before; \
588 scantable -= 1 + run_before; \
589 ((type*)block)[*scantable]= level[i]; \
591 for(;i<total_coeff;i++) { \
593 ((type*)block)[*scantable]= level[i]; \
596 ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
597 for(i=1;i<total_coeff && zeros_left > 0;i++) { \
599 run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
601 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
602 zeros_left -= run_before; \
603 scantable -= 1 + run_before; \
604 ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
606 for(;i<total_coeff;i++) { \
608 ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
612 if (h->pixel_shift) {
619 av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
626 static av_always_inline
627 int decode_luma_residual(const H264Context *h, H264SliceContext *sl,
628 GetBitContext *gb, const uint8_t *scan,
629 const uint8_t *scan8x8, int pixel_shift,
630 int mb_type, int cbp, int p)
633 int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
634 if(IS_INTRA16x16(mb_type)){
635 AV_ZERO128(sl->mb_luma_dc[p]+0);
636 AV_ZERO128(sl->mb_luma_dc[p]+8);
637 AV_ZERO128(sl->mb_luma_dc[p]+16);
638 AV_ZERO128(sl->mb_luma_dc[p]+24);
639 if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
640 return -1; //FIXME continue if partitioned and other return -1 too
643 av_assert2((cbp&15) == 0 || (cbp&15) == 15);
646 for(i8x8=0; i8x8<4; i8x8++){
647 for(i4x4=0; i4x4<4; i4x4++){
648 const int index= i4x4 + 4*i8x8 + p*16;
649 if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
650 index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
657 fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
661 int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
662 /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
664 for(i8x8=0; i8x8<4; i8x8++){
666 if(IS_8x8DCT(mb_type)){
667 int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
669 for(i4x4=0; i4x4<4; i4x4++){
670 const int index= i4x4 + 4*i8x8 + p*16;
671 if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
672 h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
675 nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
676 nnz[0] += nnz[1] + nnz[8] + nnz[9];
677 new_cbp |= !!nnz[0] << i8x8;
679 for(i4x4=0; i4x4<4; i4x4++){
680 const int index= i4x4 + 4*i8x8 + p*16;
681 if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
682 scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
685 new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
689 uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
690 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
697 int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
701 unsigned int mb_type, cbp;
702 int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
703 const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
704 const int pixel_shift = h->pixel_shift;
706 mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
708 ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->poc.frame_num, sl->mb_x, sl->mb_y);
709 cbp = 0; /* avoid warning. FIXME: find a solution without slowing
711 if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
712 if (sl->mb_skip_run == -1) {
713 unsigned mb_skip_run = get_ue_golomb_long(&sl->gb);
714 if (mb_skip_run > h->mb_num) {
715 av_log(h->avctx, AV_LOG_ERROR, "mb_skip_run %d is invalid\n", mb_skip_run);
716 return AVERROR_INVALIDDATA;
718 sl->mb_skip_run = mb_skip_run;
721 if (sl->mb_skip_run--) {
722 if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
723 if (sl->mb_skip_run == 0)
724 sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
726 decode_mb_skip(h, sl);
730 if (FRAME_MBAFF(h)) {
731 if ((sl->mb_y & 1) == 0)
732 sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
735 sl->prev_mb_skipped = 0;
737 mb_type= get_ue_golomb(&sl->gb);
738 if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
740 partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
741 mb_type = ff_h264_b_mb_type_info[mb_type].type;
744 goto decode_intra_mb;
746 } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
748 partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
749 mb_type = ff_h264_p_mb_type_info[mb_type].type;
752 goto decode_intra_mb;
755 av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
756 if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
760 av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(sl->slice_type), sl->mb_x, sl->mb_y);
764 cbp = ff_h264_i_mb_type_info[mb_type].cbp;
765 sl->intra16x16_pred_mode = ff_h264_i_mb_type_info[mb_type].pred_mode;
766 mb_type = ff_h264_i_mb_type_info[mb_type].type;
770 mb_type |= MB_TYPE_INTERLACED;
772 h->slice_table[mb_xy] = sl->slice_num;
774 if(IS_INTRA_PCM(mb_type)){
775 const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
776 h->ps.sps->bit_depth_luma;
778 // We assume these blocks are very rare so we do not optimize it.
779 sl->intra_pcm_ptr = align_get_bits(&sl->gb);
780 if (get_bits_left(&sl->gb) < mb_size) {
781 av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
782 return AVERROR_INVALIDDATA;
784 skip_bits_long(&sl->gb, mb_size);
786 // In deblocking, the quantizer is 0
787 h->cur_pic.qscale_table[mb_xy] = 0;
788 // All coeffs are present
789 memset(h->non_zero_count[mb_xy], 16, 48);
791 h->cur_pic.mb_type[mb_xy] = mb_type;
795 fill_decode_neighbors(h, sl, mb_type);
796 fill_decode_caches(h, sl, mb_type);
799 if(IS_INTRA(mb_type)){
801 // init_top_left_availability(h);
802 if(IS_INTRA4x4(mb_type)){
805 if(dct8x8_allowed && get_bits1(&sl->gb)){
806 mb_type |= MB_TYPE_8x8DCT;
810 // fill_intra4x4_pred_table(h);
811 for(i=0; i<16; i+=di){
812 int mode = pred_intra_mode(h, sl, i);
814 if(!get_bits1(&sl->gb)){
815 const int rem_mode= get_bits(&sl->gb, 3);
816 mode = rem_mode + (rem_mode >= mode);
820 fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
822 sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
824 write_back_intra_pred_mode(h, sl);
825 if (ff_h264_check_intra4x4_pred_mode(sl->intra4x4_pred_mode_cache, h->avctx,
826 sl->top_samples_available, sl->left_samples_available) < 0)
829 sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
830 sl->left_samples_available, sl->intra16x16_pred_mode, 0);
831 if (sl->intra16x16_pred_mode < 0)
835 pred_mode= ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
836 sl->left_samples_available, get_ue_golomb_31(&sl->gb), 1);
839 sl->chroma_pred_mode = pred_mode;
841 sl->chroma_pred_mode = DC_128_PRED8x8;
843 }else if(partition_count==4){
844 int i, j, sub_partition_count[4], list, ref[2][4];
846 if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
848 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
849 if(sl->sub_mb_type[i] >=13){
850 av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
853 sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
854 sl->sub_mb_type[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].type;
856 if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
857 ff_h264_pred_direct_motion(h, sl, &mb_type);
858 sl->ref_cache[0][scan8[4]] =
859 sl->ref_cache[1][scan8[4]] =
860 sl->ref_cache[0][scan8[12]] =
861 sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
864 av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
866 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
867 if(sl->sub_mb_type[i] >=4){
868 av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
871 sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
872 sl->sub_mb_type[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].type;
876 for (list = 0; list < sl->list_count; list++) {
877 int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
879 if(IS_DIRECT(sl->sub_mb_type[i])) continue;
880 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
884 }else if(ref_count == 2){
885 tmp= get_bits1(&sl->gb)^1;
887 tmp= get_ue_golomb_31(&sl->gb);
889 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
902 dct8x8_allowed = get_dct8x8_allowed(h, sl);
904 for (list = 0; list < sl->list_count; list++) {
906 if(IS_DIRECT(sl->sub_mb_type[i])) {
907 sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
910 sl->ref_cache[list][ scan8[4*i] ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
911 sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
913 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
914 const int sub_mb_type= sl->sub_mb_type[i];
915 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
916 for(j=0; j<sub_partition_count[i]; j++){
918 const int index= 4*i + block_width*j;
919 int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
920 pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
921 mx += (unsigned)get_se_golomb(&sl->gb);
922 my += (unsigned)get_se_golomb(&sl->gb);
923 ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
925 if(IS_SUB_8X8(sub_mb_type)){
927 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
929 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
930 }else if(IS_SUB_8X4(sub_mb_type)){
931 mv_cache[ 1 ][0]= mx;
932 mv_cache[ 1 ][1]= my;
933 }else if(IS_SUB_4X8(sub_mb_type)){
934 mv_cache[ 8 ][0]= mx;
935 mv_cache[ 8 ][1]= my;
937 mv_cache[ 0 ][0]= mx;
938 mv_cache[ 0 ][1]= my;
941 uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
947 }else if(IS_DIRECT(mb_type)){
948 ff_h264_pred_direct_motion(h, sl, &mb_type);
949 dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
952 //FIXME we should set ref_idx_l? to 0 if we use that later ...
953 if(IS_16X16(mb_type)){
954 for (list = 0; list < sl->list_count; list++) {
956 if(IS_DIR(mb_type, 0, list)){
957 unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
960 } else if (rc == 2) {
961 val= get_bits1(&sl->gb)^1;
963 val= get_ue_golomb_31(&sl->gb);
965 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
969 fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
972 for (list = 0; list < sl->list_count; list++) {
973 if(IS_DIR(mb_type, 0, list)){
974 pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
975 mx += (unsigned)get_se_golomb(&sl->gb);
976 my += (unsigned)get_se_golomb(&sl->gb);
977 ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
979 fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
983 else if(IS_16X8(mb_type)){
984 for (list = 0; list < sl->list_count; list++) {
987 if(IS_DIR(mb_type, i, list)){
988 unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
991 } else if (rc == 2) {
992 val= get_bits1(&sl->gb)^1;
994 val= get_ue_golomb_31(&sl->gb);
996 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1001 val= LIST_NOT_USED&0xFF;
1002 fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1005 for (list = 0; list < sl->list_count; list++) {
1008 if(IS_DIR(mb_type, i, list)){
1009 pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1010 mx += (unsigned)get_se_golomb(&sl->gb);
1011 my += (unsigned)get_se_golomb(&sl->gb);
1012 ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1014 val= pack16to32(mx,my);
1017 fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1021 av_assert2(IS_8X16(mb_type));
1022 for (list = 0; list < sl->list_count; list++) {
1025 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1026 unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1029 } else if (rc == 2) {
1030 val= get_bits1(&sl->gb)^1;
1032 val= get_ue_golomb_31(&sl->gb);
1034 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1039 val= LIST_NOT_USED&0xFF;
1040 fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1043 for (list = 0; list < sl->list_count; list++) {
1046 if(IS_DIR(mb_type, i, list)){
1047 pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1048 mx += (unsigned)get_se_golomb(&sl->gb);
1049 my += (unsigned)get_se_golomb(&sl->gb);
1050 ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1052 val= pack16to32(mx,my);
1055 fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1061 if(IS_INTER(mb_type))
1062 write_back_motion(h, sl, mb_type);
1064 if(!IS_INTRA16x16(mb_type)){
1065 cbp= get_ue_golomb(&sl->gb);
1069 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1072 if (IS_INTRA4x4(mb_type))
1073 cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1075 cbp = ff_h264_golomb_to_inter_cbp[cbp];
1078 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1081 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1082 else cbp= golomb_to_inter_cbp_gray[cbp];
1085 if (!decode_chroma && cbp>15) {
1086 av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1087 return AVERROR_INVALIDDATA;
1091 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1092 mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1095 h->cbp_table[mb_xy]= cbp;
1096 h->cur_pic.mb_type[mb_xy] = mb_type;
1098 if(cbp || IS_INTRA16x16(mb_type)){
1099 int i4x4, i8x8, chroma_idx;
1102 GetBitContext *gb = &sl->gb;
1103 const uint8_t *scan, *scan8x8;
1104 const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
1106 dquant= get_se_golomb(&sl->gb);
1108 sl->qscale += (unsigned)dquant;
1110 if (((unsigned)sl->qscale) > max_qp){
1111 if (sl->qscale < 0) sl->qscale += max_qp + 1;
1112 else sl->qscale -= max_qp+1;
1113 if (((unsigned)sl->qscale) > max_qp){
1114 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1115 sl->qscale = max_qp;
1120 sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
1121 sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
1123 if(IS_INTERLACED(mb_type)){
1124 scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1125 scan = sl->qscale ? h->field_scan : h->field_scan_q0;
1127 scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1128 scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1131 if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1134 h->cbp_table[mb_xy] |= ret << 12;
1136 if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1139 if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1143 const int num_c8x8 = h->ps.sps->chroma_format_idc;
1146 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1147 if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1148 CHROMA_DC_BLOCK_INDEX + chroma_idx,
1149 CHROMA422(h) ? ff_h264_chroma422_dc_scan : ff_h264_chroma_dc_scan,
1150 NULL, 4 * num_c8x8) < 0) {
1156 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1157 const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1158 int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1159 for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1160 for (i4x4 = 0; i4x4 < 4; i4x4++) {
1161 const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1162 if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1164 mb += 16 << pixel_shift;
1169 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1170 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1174 fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1175 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1176 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1178 h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1179 write_back_non_zero_count(h, sl);