FFmpeg  4.0
h264_cavlc.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21 
22 /**
23  * @file
24  * H.264 / AVC / MPEG-4 part10 cavlc bitstream decoding.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27 
28 #define CABAC(h) 0
29 #define UNCHECKED_BITSTREAM_READER 1
30 
31 #include "internal.h"
32 #include "avcodec.h"
33 #include "h264dec.h"
34 #include "h264_mvpred.h"
35 #include "h264data.h"
36 #include "golomb.h"
37 #include "mpegutils.h"
38 #include "libavutil/avassert.h"
39 
40 
42  0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
43 };
44 
46 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
47 };
48 
50  2, 0, 0, 0,
51  6, 1, 0, 0,
52  6, 6, 3, 0,
53  6, 7, 7, 6,
54  6, 8, 8, 7,
55 };
56 
58  1, 0, 0, 0,
59  7, 1, 0, 0,
60  4, 6, 1, 0,
61  3, 3, 2, 5,
62  2, 3, 2, 0,
63 };
64 
66  1, 0, 0, 0,
67  7, 2, 0, 0,
68  7, 7, 3, 0,
69  9, 7, 7, 5,
70  9, 9, 7, 6,
71  10, 10, 9, 7,
72  11, 11, 10, 7,
73  12, 12, 11, 10,
74  13, 12, 12, 11,
75 };
76 
78  1, 0, 0, 0,
79  15, 1, 0, 0,
80  14, 13, 1, 0,
81  7, 12, 11, 1,
82  6, 5, 10, 1,
83  7, 6, 4, 9,
84  7, 6, 5, 8,
85  7, 6, 5, 4,
86  7, 5, 4, 4,
87 };
88 
89 static const uint8_t coeff_token_len[4][4*17]={
90 {
91  1, 0, 0, 0,
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,
96 },
97 {
98  2, 0, 0, 0,
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,
103 },
104 {
105  4, 0, 0, 0,
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,
110 },
111 {
112  6, 0, 0, 0,
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,
117 }
118 };
119 
120 static const uint8_t coeff_token_bits[4][4*17]={
121 {
122  1, 0, 0, 0,
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,
127 },
128 {
129  3, 0, 0, 0,
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,
134 },
135 {
136  15, 0, 0, 0,
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,
141 },
142 {
143  3, 0, 0, 0,
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,
148 }
149 };
150 
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},
159  {6,4,5,3,2,2,3,3,6},
160  {6,6,4,2,2,3,2,5},
161  {5,5,3,2,2,2,4},
162  {4,4,3,3,1,3},
163  {4,4,2,1,3},
164  {3,3,1,2},
165  {2,2,1},
166  {1,1},
167 };
168 
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},
177  {1,1,1,3,3,2,2,1,0},
178  {1,0,1,3,2,1,1,1},
179  {1,0,1,3,2,1,1},
180  {0,1,1,2,1,3},
181  {0,1,1,1,1},
182  {0,1,1,1},
183  {0,1,1},
184  {0,1},
185 };
186 
187 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
188  { 1, 2, 3, 3,},
189  { 1, 2, 2, 0,},
190  { 1, 1, 0, 0,},
191 };
192 
193 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
194  { 1, 1, 1, 0,},
195  { 1, 1, 0, 0,},
196  { 1, 0, 0, 0,},
197 };
198 
200  { 1, 3, 3, 4, 4, 4, 5, 5 },
201  { 3, 2, 3, 3, 3, 3, 3 },
202  { 3, 3, 2, 2, 3, 3 },
203  { 3, 2, 2, 2, 3 },
204  { 2, 2, 2, 2 },
205  { 2, 2, 1 },
206  { 1, 1 },
207 };
208 
210  { 1, 2, 3, 2, 3, 1, 1, 0 },
211  { 0, 1, 1, 4, 5, 6, 7 },
212  { 0, 1, 1, 2, 6, 7 },
213  { 6, 0, 1, 2, 7 },
214  { 0, 1, 2, 3 },
215  { 0, 1, 1 },
216  { 0, 1 },
217 };
218 
219 static const uint8_t run_len[7][16]={
220  {1,1},
221  {1,2,2},
222  {2,2,2,2},
223  {2,2,2,3,3},
224  {2,2,3,3,3,3},
225  {2,3,3,3,3,3,3},
226  {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
227 };
228 
229 static const uint8_t run_bits[7][16]={
230  {1,0},
231  {1,1,0},
232  {3,2,1,0},
233  {3,2,1,1,0},
234  {3,2,3,2,1,0},
235  {3,0,1,3,2,5,4},
236  {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
237 };
238 
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};
242 
246 
250 
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;
254 
258 
262 
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;
266 
267 static VLC run7_vlc;
268 static VLC_TYPE run7_vlc_table[96][2];
269 static const int run7_vlc_table_size = 96;
270 
271 #define LEVEL_TAB_BITS 8
272 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
273 
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
282 
283 /**
284  * Get the predicted number of non-zero coefficients.
285  * @param n block index
286  */
287 static inline int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
288 {
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];
292  int i= left + top;
293 
294  if(i<64) i= (i+1)>>1;
295 
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);
297 
298  return i&31;
299 }
300 
301 static av_cold void init_cavlc_level_tab(void){
302  int suffix_length;
303  unsigned int i;
304 
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);
308 
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;
319  }else{
320  cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
321  cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
322  }
323  }
324  }
325 }
326 
328  static int done = 0;
329 
330  if (!done) {
331  int i;
332  int offset;
333  done = 1;
334 
335  chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
336  chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
337  init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
338  &chroma_dc_coeff_token_len [0], 1, 1,
339  &chroma_dc_coeff_token_bits[0], 1, 1,
341 
342  chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
343  chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
344  init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
345  &chroma422_dc_coeff_token_len [0], 1, 1,
348 
349  offset = 0;
350  for(i=0; i<4; i++){
351  coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
352  coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
353  init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
354  &coeff_token_len [i][0], 1, 1,
355  &coeff_token_bits[i][0], 1, 1,
357  offset += coeff_token_vlc_tables_size[i];
358  }
359  /*
360  * This is a one time safety check to make sure that
361  * the packed static coeff_token_vlc table sizes
362  * were initialized correctly.
363  */
365 
366  for(i=0; i<3; i++){
367  chroma_dc_total_zeros_vlc[i+1].table = chroma_dc_total_zeros_vlc_tables[i];
368  chroma_dc_total_zeros_vlc[i+1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
369  init_vlc(&chroma_dc_total_zeros_vlc[i+1],
371  &chroma_dc_total_zeros_len [i][0], 1, 1,
372  &chroma_dc_total_zeros_bits[i][0], 1, 1,
374  }
375 
376  for(i=0; i<7; i++){
377  chroma422_dc_total_zeros_vlc[i+1].table = chroma422_dc_total_zeros_vlc_tables[i];
378  chroma422_dc_total_zeros_vlc[i+1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
379  init_vlc(&chroma422_dc_total_zeros_vlc[i+1],
381  &chroma422_dc_total_zeros_len [i][0], 1, 1,
382  &chroma422_dc_total_zeros_bits[i][0], 1, 1,
384  }
385 
386  for(i=0; i<15; i++){
387  total_zeros_vlc[i+1].table = total_zeros_vlc_tables[i];
388  total_zeros_vlc[i+1].table_allocated = total_zeros_vlc_tables_size;
389  init_vlc(&total_zeros_vlc[i+1],
391  &total_zeros_len [i][0], 1, 1,
392  &total_zeros_bits[i][0], 1, 1,
394  }
395 
396  for(i=0; i<6; i++){
397  run_vlc[i+1].table = run_vlc_tables[i];
398  run_vlc[i+1].table_allocated = run_vlc_tables_size;
399  init_vlc(&run_vlc[i+1],
400  RUN_VLC_BITS, 7,
401  &run_len [i][0], 1, 1,
402  &run_bits[i][0], 1, 1,
404  }
405  run7_vlc.table = run7_vlc_table,
407  init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
408  &run_len [6][0], 1, 1,
409  &run_bits[6][0], 1, 1,
411 
413  }
414 }
415 
416 static inline int get_level_prefix(GetBitContext *gb){
417  unsigned int buf;
418  int log;
419 
420  OPEN_READER(re, gb);
421  UPDATE_CACHE(re, gb);
422  buf=GET_CACHE(re, gb);
423 
424  log= 32 - av_log2(buf);
425 
426  LAST_SKIP_BITS(re, gb, log);
427  CLOSE_READER(re, gb);
428 
429  return log-1;
430 }
431 
432 /**
433  * Decode a residual block.
434  * @param n block index
435  * @param scantable scantable
436  * @param max_coeff number of coefficients in the block
437  * @return <0 if an error occurred
438  */
440  GetBitContext *gb, int16_t *block, int n,
441  const uint8_t *scantable, const uint32_t *qmul,
442  int max_coeff)
443 {
444  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};
445  int level[16];
446  int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
447 
448  //FIXME put trailing_onex into the context
449 
450  if(max_coeff <= 8){
451  if (max_coeff == 4)
452  coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
453  else
454  coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
455  total_coeff= coeff_token>>2;
456  }else{
457  if(n >= LUMA_DC_BLOCK_INDEX){
458  total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
459  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
460  total_coeff= coeff_token>>2;
461  }else{
462  total_coeff= pred_non_zero_count(h, sl, n);
463  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
464  total_coeff= coeff_token>>2;
465  }
466  }
467  sl->non_zero_count_cache[scan8[n]] = total_coeff;
468 
469  //FIXME set last_non_zero?
470 
471  if(total_coeff==0)
472  return 0;
473  if(total_coeff > (unsigned)max_coeff) {
474  av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
475  return -1;
476  }
477 
478  trailing_ones= coeff_token&3;
479  ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
480  av_assert2(total_coeff<=16);
481 
482  i = show_bits(gb, 3);
483  skip_bits(gb, trailing_ones);
484  level[0] = 1-((i&4)>>1);
485  level[1] = 1-((i&2) );
486  level[2] = 1-((i&1)<<1);
487 
488  if(trailing_ones<total_coeff) {
489  int mask, prefix;
490  int suffix_length = total_coeff > 10 & trailing_ones < 3;
491  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
492  int level_code= cavlc_level_tab[suffix_length][bitsi][0];
493 
494  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
495  if(level_code >= 100){
496  prefix= level_code - 100;
497  if(prefix == LEVEL_TAB_BITS)
498  prefix += get_level_prefix(gb);
499 
500  //first coefficient has suffix_length equal to 0 or 1
501  if(prefix<14){ //FIXME try to build a large unified VLC table for all this
502  if(suffix_length)
503  level_code= (prefix<<1) + get_bits1(gb); //part
504  else
505  level_code= prefix; //part
506  }else if(prefix==14){
507  if(suffix_length)
508  level_code= (prefix<<1) + get_bits1(gb); //part
509  else
510  level_code= prefix + get_bits(gb, 4); //part
511  }else{
512  level_code= 30;
513  if(prefix>=16){
514  if(prefix > 25+3){
515  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
516  return -1;
517  }
518  level_code += (1<<(prefix-3))-4096;
519  }
520  level_code += get_bits(gb, prefix-3); //part
521  }
522 
523  if(trailing_ones < 3) level_code += 2;
524 
525  suffix_length = 2;
526  mask= -(level_code&1);
527  level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
528  }else{
529  level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
530 
531  suffix_length = 1 + (level_code + 3U > 6U);
532  level[trailing_ones]= level_code;
533  }
534 
535  //remaining coefficients have suffix_length > 0
536  for(i=trailing_ones+1;i<total_coeff;i++) {
537  static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
538  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
539  level_code= cavlc_level_tab[suffix_length][bitsi][0];
540 
541  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
542  if(level_code >= 100){
543  prefix= level_code - 100;
544  if(prefix == LEVEL_TAB_BITS){
545  prefix += get_level_prefix(gb);
546  }
547  if(prefix<15){
548  level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
549  }else{
550  level_code = 15<<suffix_length;
551  if (prefix>=16) {
552  if(prefix > 25+3){
553  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
554  return AVERROR_INVALIDDATA;
555  }
556  level_code += (1<<(prefix-3))-4096;
557  }
558  level_code += get_bits(gb, prefix-3);
559  }
560  mask= -(level_code&1);
561  level_code= (((2+level_code)>>1) ^ mask) - mask;
562  }
563  level[i]= level_code;
564  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
565  }
566  }
567 
568  if(total_coeff == max_coeff)
569  zeros_left=0;
570  else{
571  if (max_coeff <= 8) {
572  if (max_coeff == 4)
573  zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
575  else
576  zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
578  } else {
579  zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
580  }
581  }
582 
583 #define STORE_BLOCK(type) \
584  scantable += zeros_left + total_coeff - 1; \
585  if(n >= LUMA_DC_BLOCK_INDEX){ \
586  ((type*)block)[*scantable] = level[0]; \
587  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
588  if(zeros_left < 7) \
589  run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
590  else \
591  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
592  zeros_left -= run_before; \
593  scantable -= 1 + run_before; \
594  ((type*)block)[*scantable]= level[i]; \
595  } \
596  for(;i<total_coeff;i++) { \
597  scantable--; \
598  ((type*)block)[*scantable]= level[i]; \
599  } \
600  }else{ \
601  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
602  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
603  if(zeros_left < 7) \
604  run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
605  else \
606  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
607  zeros_left -= run_before; \
608  scantable -= 1 + run_before; \
609  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
610  } \
611  for(;i<total_coeff;i++) { \
612  scantable--; \
613  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
614  } \
615  }
616 
617  if (h->pixel_shift) {
619  } else {
620  STORE_BLOCK(int16_t)
621  }
622 
623  if(zeros_left<0){
624  av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
625  return -1;
626  }
627 
628  return 0;
629 }
630 
631 static av_always_inline
633  GetBitContext *gb, const uint8_t *scan,
634  const uint8_t *scan8x8, int pixel_shift,
635  int mb_type, int cbp, int p)
636 {
637  int i4x4, i8x8;
638  int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
639  if(IS_INTRA16x16(mb_type)){
640  AV_ZERO128(sl->mb_luma_dc[p]+0);
641  AV_ZERO128(sl->mb_luma_dc[p]+8);
642  AV_ZERO128(sl->mb_luma_dc[p]+16);
643  AV_ZERO128(sl->mb_luma_dc[p]+24);
644  if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
645  return -1; //FIXME continue if partitioned and other return -1 too
646  }
647 
648  av_assert2((cbp&15) == 0 || (cbp&15) == 15);
649 
650  if(cbp&15){
651  for(i8x8=0; i8x8<4; i8x8++){
652  for(i4x4=0; i4x4<4; i4x4++){
653  const int index= i4x4 + 4*i8x8 + p*16;
654  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
655  index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
656  return -1;
657  }
658  }
659  }
660  return 0xf;
661  }else{
662  fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
663  return 0;
664  }
665  }else{
666  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
667  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
668  int new_cbp = 0;
669  for(i8x8=0; i8x8<4; i8x8++){
670  if(cbp & (1<<i8x8)){
671  if(IS_8x8DCT(mb_type)){
672  int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
673  uint8_t *nnz;
674  for(i4x4=0; i4x4<4; i4x4++){
675  const int index= i4x4 + 4*i8x8 + p*16;
676  if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
677  h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
678  return -1;
679  }
680  nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
681  nnz[0] += nnz[1] + nnz[8] + nnz[9];
682  new_cbp |= !!nnz[0] << i8x8;
683  }else{
684  for(i4x4=0; i4x4<4; i4x4++){
685  const int index= i4x4 + 4*i8x8 + p*16;
686  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
687  scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
688  return -1;
689  }
690  new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
691  }
692  }
693  }else{
694  uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
695  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
696  }
697  }
698  return new_cbp;
699  }
700 }
701 
703 {
704  int mb_xy;
705  int partition_count;
706  unsigned int mb_type, cbp;
707  int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
708  const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
709  const int pixel_shift = h->pixel_shift;
710 
711  mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
712 
713  ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->poc.frame_num, sl->mb_x, sl->mb_y);
714  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
715  down the code */
716  if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
717  if (sl->mb_skip_run == -1)
718  sl->mb_skip_run = get_ue_golomb_long(&sl->gb);
719 
720  if (sl->mb_skip_run--) {
721  if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
722  if (sl->mb_skip_run == 0)
723  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
724  }
725  decode_mb_skip(h, sl);
726  return 0;
727  }
728  }
729  if (FRAME_MBAFF(h)) {
730  if ((sl->mb_y & 1) == 0)
731  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
732  }
733 
734  sl->prev_mb_skipped = 0;
735 
736  mb_type= get_ue_golomb(&sl->gb);
737  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
738  if(mb_type < 23){
739  partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
740  mb_type = ff_h264_b_mb_type_info[mb_type].type;
741  }else{
742  mb_type -= 23;
743  goto decode_intra_mb;
744  }
745  } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
746  if(mb_type < 5){
747  partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
748  mb_type = ff_h264_p_mb_type_info[mb_type].type;
749  }else{
750  mb_type -= 5;
751  goto decode_intra_mb;
752  }
753  }else{
755  if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
756  mb_type--;
757 decode_intra_mb:
758  if(mb_type > 25){
759  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);
760  return -1;
761  }
762  partition_count=0;
763  cbp = ff_h264_i_mb_type_info[mb_type].cbp;
765  mb_type = ff_h264_i_mb_type_info[mb_type].type;
766  }
767 
768  if (MB_FIELD(sl))
769  mb_type |= MB_TYPE_INTERLACED;
770 
771  h->slice_table[mb_xy] = sl->slice_num;
772 
773  if(IS_INTRA_PCM(mb_type)){
774  const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
775  h->ps.sps->bit_depth_luma;
776 
777  // We assume these blocks are very rare so we do not optimize it.
778  sl->intra_pcm_ptr = align_get_bits(&sl->gb);
779  if (get_bits_left(&sl->gb) < mb_size) {
780  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
781  return AVERROR_INVALIDDATA;
782  }
783  skip_bits_long(&sl->gb, mb_size);
784 
785  // In deblocking, the quantizer is 0
786  h->cur_pic.qscale_table[mb_xy] = 0;
787  // All coeffs are present
788  memset(h->non_zero_count[mb_xy], 16, 48);
789 
790  h->cur_pic.mb_type[mb_xy] = mb_type;
791  return 0;
792  }
793 
794  fill_decode_neighbors(h, sl, mb_type);
795  fill_decode_caches(h, sl, mb_type);
796 
797  //mb_pred
798  if(IS_INTRA(mb_type)){
799  int pred_mode;
800 // init_top_left_availability(h);
801  if(IS_INTRA4x4(mb_type)){
802  int i;
803  int di = 1;
804  if(dct8x8_allowed && get_bits1(&sl->gb)){
805  mb_type |= MB_TYPE_8x8DCT;
806  di = 4;
807  }
808 
809 // fill_intra4x4_pred_table(h);
810  for(i=0; i<16; i+=di){
811  int mode = pred_intra_mode(h, sl, i);
812 
813  if(!get_bits1(&sl->gb)){
814  const int rem_mode= get_bits(&sl->gb, 3);
815  mode = rem_mode + (rem_mode >= mode);
816  }
817 
818  if(di==4)
819  fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
820  else
822  }
826  return -1;
827  }else{
830  if (sl->intra16x16_pred_mode < 0)
831  return -1;
832  }
833  if(decode_chroma){
836  if(pred_mode < 0)
837  return -1;
838  sl->chroma_pred_mode = pred_mode;
839  } else {
841  }
842  }else if(partition_count==4){
843  int i, j, sub_partition_count[4], list, ref[2][4];
844 
845  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
846  for(i=0; i<4; i++){
847  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
848  if(sl->sub_mb_type[i] >=13){
849  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);
850  return -1;
851  }
852  sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
854  }
855  if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
856  ff_h264_pred_direct_motion(h, sl, &mb_type);
857  sl->ref_cache[0][scan8[4]] =
858  sl->ref_cache[1][scan8[4]] =
859  sl->ref_cache[0][scan8[12]] =
860  sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
861  }
862  }else{
863  av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
864  for(i=0; i<4; i++){
865  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
866  if(sl->sub_mb_type[i] >=4){
867  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);
868  return -1;
869  }
870  sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
872  }
873  }
874 
875  for (list = 0; list < sl->list_count; list++) {
876  int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
877  for(i=0; i<4; i++){
878  if(IS_DIRECT(sl->sub_mb_type[i])) continue;
879  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
880  unsigned int tmp;
881  if(ref_count == 1){
882  tmp= 0;
883  }else if(ref_count == 2){
884  tmp= get_bits1(&sl->gb)^1;
885  }else{
886  tmp= get_ue_golomb_31(&sl->gb);
887  if(tmp>=ref_count){
888  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
889  return -1;
890  }
891  }
892  ref[list][i]= tmp;
893  }else{
894  //FIXME
895  ref[list][i] = -1;
896  }
897  }
898  }
899 
900  if(dct8x8_allowed)
901  dct8x8_allowed = get_dct8x8_allowed(h, sl);
902 
903  for (list = 0; list < sl->list_count; list++) {
904  for(i=0; i<4; i++){
905  if(IS_DIRECT(sl->sub_mb_type[i])) {
906  sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
907  continue;
908  }
909  sl->ref_cache[list][ scan8[4*i] ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
910  sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
911 
912  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
913  const int sub_mb_type= sl->sub_mb_type[i];
914  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
915  for(j=0; j<sub_partition_count[i]; j++){
916  int mx, my;
917  const int index= 4*i + block_width*j;
918  int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
919  pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
920  mx += get_se_golomb(&sl->gb);
921  my += get_se_golomb(&sl->gb);
922  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
923 
924  if(IS_SUB_8X8(sub_mb_type)){
925  mv_cache[ 1 ][0]=
926  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
927  mv_cache[ 1 ][1]=
928  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
929  }else if(IS_SUB_8X4(sub_mb_type)){
930  mv_cache[ 1 ][0]= mx;
931  mv_cache[ 1 ][1]= my;
932  }else if(IS_SUB_4X8(sub_mb_type)){
933  mv_cache[ 8 ][0]= mx;
934  mv_cache[ 8 ][1]= my;
935  }
936  mv_cache[ 0 ][0]= mx;
937  mv_cache[ 0 ][1]= my;
938  }
939  }else{
940  uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
941  p[0] = p[1]=
942  p[8] = p[9]= 0;
943  }
944  }
945  }
946  }else if(IS_DIRECT(mb_type)){
947  ff_h264_pred_direct_motion(h, sl, &mb_type);
948  dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
949  }else{
950  int list, mx, my, i;
951  //FIXME we should set ref_idx_l? to 0 if we use that later ...
952  if(IS_16X16(mb_type)){
953  for (list = 0; list < sl->list_count; list++) {
954  unsigned int val;
955  if(IS_DIR(mb_type, 0, list)){
956  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
957  if (rc == 1) {
958  val= 0;
959  } else if (rc == 2) {
960  val= get_bits1(&sl->gb)^1;
961  }else{
962  val= get_ue_golomb_31(&sl->gb);
963  if (val >= rc) {
964  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
965  return -1;
966  }
967  }
968  fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
969  }
970  }
971  for (list = 0; list < sl->list_count; list++) {
972  if(IS_DIR(mb_type, 0, list)){
973  pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
974  mx += get_se_golomb(&sl->gb);
975  my += get_se_golomb(&sl->gb);
976  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
977 
978  fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
979  }
980  }
981  }
982  else if(IS_16X8(mb_type)){
983  for (list = 0; list < sl->list_count; list++) {
984  for(i=0; i<2; i++){
985  unsigned int val;
986  if(IS_DIR(mb_type, i, list)){
987  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
988  if (rc == 1) {
989  val= 0;
990  } else if (rc == 2) {
991  val= get_bits1(&sl->gb)^1;
992  }else{
993  val= get_ue_golomb_31(&sl->gb);
994  if (val >= rc) {
995  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
996  return -1;
997  }
998  }
999  }else
1000  val= LIST_NOT_USED&0xFF;
1001  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1002  }
1003  }
1004  for (list = 0; list < sl->list_count; list++) {
1005  for(i=0; i<2; i++){
1006  unsigned int val;
1007  if(IS_DIR(mb_type, i, list)){
1008  pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1009  mx += get_se_golomb(&sl->gb);
1010  my += get_se_golomb(&sl->gb);
1011  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1012 
1013  val= pack16to32(mx,my);
1014  }else
1015  val=0;
1016  fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1017  }
1018  }
1019  }else{
1020  av_assert2(IS_8X16(mb_type));
1021  for (list = 0; list < sl->list_count; list++) {
1022  for(i=0; i<2; i++){
1023  unsigned int val;
1024  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1025  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1026  if (rc == 1) {
1027  val= 0;
1028  } else if (rc == 2) {
1029  val= get_bits1(&sl->gb)^1;
1030  }else{
1031  val= get_ue_golomb_31(&sl->gb);
1032  if (val >= rc) {
1033  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1034  return -1;
1035  }
1036  }
1037  }else
1038  val= LIST_NOT_USED&0xFF;
1039  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1040  }
1041  }
1042  for (list = 0; list < sl->list_count; list++) {
1043  for(i=0; i<2; i++){
1044  unsigned int val;
1045  if(IS_DIR(mb_type, i, list)){
1046  pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1047  mx += get_se_golomb(&sl->gb);
1048  my += get_se_golomb(&sl->gb);
1049  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1050 
1051  val= pack16to32(mx,my);
1052  }else
1053  val=0;
1054  fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1055  }
1056  }
1057  }
1058  }
1059 
1060  if(IS_INTER(mb_type))
1061  write_back_motion(h, sl, mb_type);
1062 
1063  if(!IS_INTRA16x16(mb_type)){
1064  cbp= get_ue_golomb(&sl->gb);
1065 
1066  if(decode_chroma){
1067  if(cbp > 47){
1068  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1069  return -1;
1070  }
1071  if (IS_INTRA4x4(mb_type))
1072  cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1073  else
1074  cbp = ff_h264_golomb_to_inter_cbp[cbp];
1075  }else{
1076  if(cbp > 15){
1077  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1078  return -1;
1079  }
1080  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1081  else cbp= golomb_to_inter_cbp_gray[cbp];
1082  }
1083  } else {
1084  if (!decode_chroma && cbp>15) {
1085  av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1086  return AVERROR_INVALIDDATA;
1087  }
1088  }
1089 
1090  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1091  mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1092  }
1093  sl->cbp=
1094  h->cbp_table[mb_xy]= cbp;
1095  h->cur_pic.mb_type[mb_xy] = mb_type;
1096 
1097  if(cbp || IS_INTRA16x16(mb_type)){
1098  int i4x4, i8x8, chroma_idx;
1099  int dquant;
1100  int ret;
1101  GetBitContext *gb = &sl->gb;
1102  const uint8_t *scan, *scan8x8;
1103  const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
1104 
1105  dquant= get_se_golomb(&sl->gb);
1106 
1107  sl->qscale += (unsigned)dquant;
1108 
1109  if (((unsigned)sl->qscale) > max_qp){
1110  if (sl->qscale < 0) sl->qscale += max_qp + 1;
1111  else sl->qscale -= max_qp+1;
1112  if (((unsigned)sl->qscale) > max_qp){
1113  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1114  sl->qscale = max_qp;
1115  return -1;
1116  }
1117  }
1118 
1119  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
1120  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
1121 
1122  if(IS_INTERLACED(mb_type)){
1123  scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1124  scan = sl->qscale ? h->field_scan : h->field_scan_q0;
1125  }else{
1126  scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1127  scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1128  }
1129 
1130  if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1131  return -1;
1132  }
1133  h->cbp_table[mb_xy] |= ret << 12;
1134  if (CHROMA444(h)) {
1135  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1136  return -1;
1137  }
1138  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1139  return -1;
1140  }
1141  } else {
1142  const int num_c8x8 = h->ps.sps->chroma_format_idc;
1143 
1144  if(cbp&0x30){
1145  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1146  if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1147  CHROMA_DC_BLOCK_INDEX + chroma_idx,
1149  NULL, 4 * num_c8x8) < 0) {
1150  return -1;
1151  }
1152  }
1153 
1154  if(cbp&0x20){
1155  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1156  const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1157  int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1158  for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1159  for (i4x4 = 0; i4x4 < 4; i4x4++) {
1160  const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1161  if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1162  return -1;
1163  mb += 16 << pixel_shift;
1164  }
1165  }
1166  }
1167  }else{
1168  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1169  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1170  }
1171  }
1172  }else{
1173  fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1174  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1175  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1176  }
1177  h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1179 
1180  return 0;
1181 }
int chroma_format_idc
Definition: h264_ps.h:47
uint8_t pred_mode
Definition: h264data.h:35
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:271
#define ff_tlog(ctx,...)
Definition: internal.h:75
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define DC_128_PRED8x8
Definition: h264pred.h:76
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:278
int16_t mb[16 *48 *2]
Definition: h264dec.h:307
H264POCContext poc
Definition: h264dec.h:460
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:299
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
float re
Definition: fft.c:82
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:269
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
Definition: h264dec.h:681
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:212
uint16_t * cbp_table
Definition: h264dec.h:413
static VLC total_zeros_vlc[15+1]
Definition: h264_cavlc.c:251
static const int chroma422_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:249
static av_cold void init_cavlc_level_tab(void)
Definition: h264_cavlc.c:301
int prev_mb_skipped
Definition: h264dec.h:199
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
#define MB_TYPE_16x8
Definition: mpegutils.h:55
#define IS_SUB_8X8(a)
Definition: mpegutils.h:90
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264dec.h:423
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
Definition: h264_direct.c:721
H264Context.
Definition: h264dec.h:337
static const uint8_t chroma422_dc_coeff_token_len[4 *9]
Definition: h264_cavlc.c:65
static const int chroma422_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:261
#define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:279
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2]
Definition: h264_cavlc.c:256
static VLC chroma422_dc_coeff_token_vlc
Definition: h264_cavlc.c:247
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
static const uint8_t coeff_token_len[4][4 *17]
Definition: h264_cavlc.c:89
static const uint8_t chroma422_dc_coeff_token_bits[4 *9]
Definition: h264_cavlc.c:77
static const uint8_t chroma422_dc_total_zeros_len[7][8]
Definition: h264_cavlc.c:199
uint8_t partition_count
Definition: h264data.h:43
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:267
static int decode_residual(const H264Context *h, H264SliceContext *sl, GetBitContext *gb, int16_t *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff)
Decode a residual block.
Definition: h264_cavlc.c:439
Switching Intra.
Definition: avutil.h:278
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:219
static int16_t block[64]
Definition: dct.c:115
static const uint8_t chroma_dc_coeff_token_bits[4 *5]
Definition: h264_cavlc.c:57
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static const uint8_t golomb_to_intra4x4_cbp_gray[16]
Definition: h264_cavlc.c:45
uint16_t sub_mb_type[4]
as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
Definition: h264dec.h:304
const PPS * pps
Definition: h264_ps.h:144
static const uint8_t coeff_token_bits[4][4 *17]
Definition: h264_cavlc.c:120
uint8_t
#define av_cold
Definition: attributes.h:82
#define mb
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
#define MB_MBAFF(h)
Definition: h264dec.h:71
static const int chroma_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:257
#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:275
#define MB_FIELD(sl)
Definition: h264dec.h:72
#define MB_TYPE_16x16
Definition: mpegutils.h:54
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
const uint8_t ff_h264_chroma_dc_scan[4]
Definition: h264data.c:54
#define IS_DIR(a, part, list)
Definition: mpegutils.h:96
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264_ps.h:133
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264_ps.h:134
const IMbInfo ff_h264_i_mb_type_info[26]
Definition: h264data.c:66
static int8_t cavlc_level_tab[7][1<< LEVEL_TAB_BITS][2]
Definition: h264_cavlc.c:272
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:88
static const uint8_t total_zeros_len[16][16]
Definition: h264_cavlc.c:151
static av_always_inline int pred_intra_mode(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264dec.h:689
const uint8_t ff_h264_golomb_to_inter_cbp[48]
Definition: h264data.c:48
int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx, int top_samples_available, int left_samples_available)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264_parse.c:131
static VLC run_vlc[6+1]
Definition: h264_cavlc.c:263
int chroma_qp[2]
Definition: h264dec.h:188
#define av_log(a,...)
uint16_t type
Definition: h264data.h:42
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2]
Definition: h264_cavlc.c:240
const PMbInfo ff_h264_p_mb_type_info[5]
Definition: h264data.c:95
static av_always_inline void write_back_motion(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264dec.h:777
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:596
#define RUN7_VLC_BITS
Definition: h264_cavlc.c:281
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:161
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
static const uint16_t mask[17]
Definition: lzw.c:38
const uint8_t ff_h264_chroma422_dc_scan[8]
Definition: h264data.c:59
static const struct endianess table[]
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264dec.h:205
static const uint8_t chroma_dc_total_zeros_bits[3][4]
Definition: h264_cavlc.c:193
static av_always_inline void pred_16x8_motion(const H264Context *const h, H264SliceContext *sl, int n, int list, int ref, int *const mx, int *const my)
Get the directionally predicted 16x8 MV.
Definition: h264_mvpred.h:160
simple assert() macros that are a bit more flexible than ISO C assert().
unsigned int top_samples_available
Definition: h264dec.h:222
static VLC chroma_dc_coeff_token_vlc
Definition: h264_cavlc.c:243
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define CLOSE_READER(name, gb)
Definition: get_bits.h:132
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:184
Definition: vlc.h:26
#define COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:276
int16_t mb_luma_dc[3][16 *2]
as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too lar...
Definition: h264dec.h:308
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:804
static const int chroma_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:245
#define IS_INTRA_PCM(a)
Definition: mpegutils.h:82
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:169
#define IS_16X8(a)
Definition: mpegutils.h:87
int chroma_pred_mode
Definition: h264dec.h:202
#define IS_SUB_4X8(a)
Definition: mpegutils.h:92
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264dec.h:403
uint8_t field_scan8x8_cavlc[64]
Definition: h264dec.h:426
#define IS_DIRECT(a)
Definition: mpegutils.h:84
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:260
#define IS_REF0(a)
Definition: h264dec.h:103
static av_always_inline void pred_8x16_motion(const H264Context *const h, H264SliceContext *sl, int n, int list, int ref, int *const mx, int *const my)
Get the directionally predicted 8x16 MV.
Definition: h264_mvpred.h:201
static VLC coeff_token_vlc[4]
Definition: h264_cavlc.c:239
static VLC_TYPE total_zeros_vlc_tables[15][512][2]
Definition: h264_cavlc.c:252
uint32_t * mb_type
Definition: h264dec.h:139
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:304
#define CHROMA_DC_BLOCK_INDEX
Definition: h264dec.h:641
H.264 / AVC / MPEG-4 part10 codec.
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:182
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:563
int direct_8x8_inference_flag
Definition: h264_ps.h:63
int n
Definition: avisynth_c.h:684
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:822
#define LUMA_DC_BLOCK_INDEX
Definition: h264dec.h:640
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:58
#define FF_ARRAY_ELEMS(a)
#define av_log2
Definition: intmath.h:83
#define IS_INTRA16x16(a)
Definition: mpegutils.h:76
static const uint8_t chroma_dc_coeff_token_len[4 *5]
Definition: h264_cavlc.c:49
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:85
int table_allocated
Definition: vlc.h:29
uint8_t zigzag_scan_q0[16]
Definition: h264dec.h:427
int intra16x16_pred_mode
Definition: h264dec.h:203
int mb_stride
Definition: h264dec.h:436
#define IS_INTERLACED(a)
Definition: mpegutils.h:83
AVCodecContext * avctx
Definition: h264dec.h:339
#define IS_SUB_8X4(a)
Definition: mpegutils.h:91
Libavcodec external API header.
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:100
#define OPEN_READER(name, gb)
Definition: get_bits.h:121
void * buf
Definition: avisynth_c.h:690
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
int8_t * qscale_table
Definition: h264dec.h:133
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:644
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:321
const uint8_t ff_h264_golomb_to_intra4x4_cbp[48]
Definition: h264data.c:42
#define IS_16X16(a)
Definition: mpegutils.h:86
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:314
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:294
int index
Definition: gxfenc.c:89
#define FRAME_MBAFF(h)
Definition: h264dec.h:73
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:660
#define IS_8X16(a)
Definition: mpegutils.h:88
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:327
int pixel_shift
0 for 8-bit H.264, 1 for high-bit-depth H.264
Definition: h264dec.h:356
#define GET_CACHE(name, gb)
Definition: get_bits.h:198
#define LIST_NOT_USED
Definition: h264dec.h:390
static const int total_zeros_vlc_tables_size
Definition: h264_cavlc.c:253
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:242
#define IS_INTER(a)
Definition: mpegutils.h:79
static const uint8_t chroma422_dc_total_zeros_bits[7][8]
Definition: h264_cavlc.c:209
static void fill_decode_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:445
const SPS * sps
Definition: h264_ps.h:145
static const int coeff_token_vlc_tables_size[4]
Definition: h264_cavlc.c:241
static const int run7_vlc_table_size
Definition: h264_cavlc.c:269
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264_ps.h:123
#define CHROMA444(h)
Definition: h264dec.h:99
uint8_t zigzag_scan[16]
Definition: h264dec.h:421
unsigned int list_count
Definition: h264dec.h:268
uint8_t level
Definition: svq3.c:207
#define AV_ZERO128(d)
Definition: intreadwrite.h:622
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2]
Definition: h264_cavlc.c:248
static av_always_inline void write_back_non_zero_count(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:717
#define IS_8x8DCT(a)
Definition: h264dec.h:104
uint8_t cbp
Definition: h264data.h:36
common internal api header.
const PMbInfo ff_h264_b_mb_type_info[23]
Definition: h264data.c:110
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available, int left_samples_available, int mode, int is_chroma)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264_parse.c:179
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
const PMbInfo ff_h264_p_sub_mb_type_info[4]
Definition: h264data.c:103
H264ParamSets ps
Definition: h264dec.h:456
H.264 / AVC / MPEG-4 part10 motion vector prediction.
Bi-dir predicted.
Definition: avutil.h:276
static void fill_decode_neighbors(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:356
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:702
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264_ps.h:97
static int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted number of non-zero coefficients.
Definition: h264_cavlc.c:287
#define IS_INTRA(x, y)
#define CHROMA_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:274
#define IS_INTRA4x4(a)
Definition: mpegutils.h:75
static VLC run7_vlc
Definition: h264_cavlc.c:267
uint8_t zigzag_scan8x8_cavlc_q0[64]
Definition: h264dec.h:429
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:300
static const int run_vlc_tables_size
Definition: h264_cavlc.c:265
#define CHROMA422(h)
Definition: h264dec.h:98
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
H264Picture cur_pic
Definition: h264dec.h:347
#define PART_NOT_AVAILABLE
Definition: h264dec.h:391
static const uint8_t chroma_dc_total_zeros_len[3][4]
Definition: h264_cavlc.c:187
static void av_unused decode_mb_skip(const H264Context *h, H264SliceContext *sl)
decodes a P_SKIP or B_SKIP macroblock
Definition: h264_mvpred.h:803
static int get_level_prefix(GetBitContext *gb)
Definition: h264_cavlc.c:416
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:472
uint8_t field_scan8x8_cavlc_q0[64]
Definition: h264dec.h:432
const uint8_t * intra_pcm_ptr
Definition: h264dec.h:280
uint16_t type
Definition: h264data.h:34
unsigned int left_samples_available
Definition: h264dec.h:224
#define av_always_inline
Definition: attributes.h:39
static const uint8_t golomb_to_inter_cbp_gray[16]
Definition: h264_cavlc.c:41
const PMbInfo ff_h264_b_sub_mb_type_info[13]
Definition: h264data.c:136
#define VLC_TYPE
Definition: vlc.h:24
static VLC chroma_dc_total_zeros_vlc[3+1]
Definition: h264_cavlc.c:255
static VLC_TYPE run_vlc_tables[6][8][2]
Definition: h264_cavlc.c:264
uint8_t field_scan_q0[16]
Definition: h264dec.h:430
int mb_field_decoding_flag
Definition: h264dec.h:241
uint8_t(* non_zero_count)[48]
Definition: h264dec.h:388
exp golomb vlc stuff
static av_always_inline int decode_luma_residual(const H264Context *h, H264SliceContext *sl, GetBitContext *gb, const uint8_t *scan, const uint8_t *scan8x8, int pixel_shift, int mb_type, int cbp, int p)
Definition: h264_cavlc.c:632
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:244
#define MB_TYPE_8x8DCT
Definition: h264dec.h:102
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
static VLC chroma422_dc_total_zeros_vlc[7+1]
Definition: h264_cavlc.c:259
GetBitContext gb
Definition: h264dec.h:179
uint8_t field_scan[16]
Definition: h264dec.h:424
Predicted.
Definition: avutil.h:275
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:58
#define STORE_BLOCK(type)
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:705
static av_always_inline void pred_motion(const H264Context *const h, H264SliceContext *sl, int n, int part_width, int list, int ref, int *const mx, int *const my)
Get the predicted MV.
Definition: h264_mvpred.h:95
static uint8_t tmp[11]
Definition: aes_ctr.c:26