FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 / MPEG4 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 "h264.h"
34 #include "h264data.h" // FIXME FIXME FIXME
35 #include "h264_mvpred.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];
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];
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].table = chroma_dc_total_zeros_vlc_tables[i];
368  chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
369  init_vlc(&chroma_dc_total_zeros_vlc[i],
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].table = chroma422_dc_total_zeros_vlc_tables[i];
378  chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
379  init_vlc(&chroma422_dc_total_zeros_vlc[i],
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].table = total_zeros_vlc_tables[i];
388  total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
389  init_vlc(&total_zeros_vlc[i],
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].table = run_vlc_tables[i];
399  init_vlc(&run_vlc[i],
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 /**
417  *
418  */
419 static inline int get_level_prefix(GetBitContext *gb){
420  unsigned int buf;
421  int log;
422 
423  OPEN_READER(re, gb);
424  UPDATE_CACHE(re, gb);
425  buf=GET_CACHE(re, gb);
426 
427  log= 32 - av_log2(buf);
428 #ifdef TRACE
429  print_bin(buf>>(32-log), log);
430  av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
431 #endif
432 
433  LAST_SKIP_BITS(re, gb, log);
434  CLOSE_READER(re, gb);
435 
436  return log-1;
437 }
438 
439 /**
440  * Decode a residual block.
441  * @param n block index
442  * @param scantable scantable
443  * @param max_coeff number of coefficients in the block
444  * @return <0 if an error occurred
445  */
447  GetBitContext *gb, int16_t *block, int n,
448  const uint8_t *scantable, const uint32_t *qmul,
449  int max_coeff)
450 {
451  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};
452  int level[16];
453  int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
454 
455  //FIXME put trailing_onex into the context
456 
457  if(max_coeff <= 8){
458  if (max_coeff == 4)
459  coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
460  else
461  coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
462  total_coeff= coeff_token>>2;
463  }else{
464  if(n >= LUMA_DC_BLOCK_INDEX){
465  total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
466  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
467  total_coeff= coeff_token>>2;
468  }else{
469  total_coeff= pred_non_zero_count(h, sl, n);
470  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
471  total_coeff= coeff_token>>2;
472  }
473  }
474  sl->non_zero_count_cache[scan8[n]] = total_coeff;
475 
476  //FIXME set last_non_zero?
477 
478  if(total_coeff==0)
479  return 0;
480  if(total_coeff > (unsigned)max_coeff) {
481  av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
482  return -1;
483  }
484 
485  trailing_ones= coeff_token&3;
486  ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
487  av_assert2(total_coeff<=16);
488 
489  i = show_bits(gb, 3);
490  skip_bits(gb, trailing_ones);
491  level[0] = 1-((i&4)>>1);
492  level[1] = 1-((i&2) );
493  level[2] = 1-((i&1)<<1);
494 
495  if(trailing_ones<total_coeff) {
496  int mask, prefix;
497  int suffix_length = total_coeff > 10 & trailing_ones < 3;
498  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
499  int level_code= cavlc_level_tab[suffix_length][bitsi][0];
500 
501  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
502  if(level_code >= 100){
503  prefix= level_code - 100;
504  if(prefix == LEVEL_TAB_BITS)
505  prefix += get_level_prefix(gb);
506 
507  //first coefficient has suffix_length equal to 0 or 1
508  if(prefix<14){ //FIXME try to build a large unified VLC table for all this
509  if(suffix_length)
510  level_code= (prefix<<1) + get_bits1(gb); //part
511  else
512  level_code= prefix; //part
513  }else if(prefix==14){
514  if(suffix_length)
515  level_code= (prefix<<1) + get_bits1(gb); //part
516  else
517  level_code= prefix + get_bits(gb, 4); //part
518  }else{
519  level_code= 30;
520  if(prefix>=16){
521  if(prefix > 25+3){
522  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
523  return -1;
524  }
525  level_code += (1<<(prefix-3))-4096;
526  }
527  level_code += get_bits(gb, prefix-3); //part
528  }
529 
530  if(trailing_ones < 3) level_code += 2;
531 
532  suffix_length = 2;
533  mask= -(level_code&1);
534  level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
535  }else{
536  level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
537 
538  suffix_length = 1 + (level_code + 3U > 6U);
539  level[trailing_ones]= level_code;
540  }
541 
542  //remaining coefficients have suffix_length > 0
543  for(i=trailing_ones+1;i<total_coeff;i++) {
544  static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
545  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
546  level_code= cavlc_level_tab[suffix_length][bitsi][0];
547 
548  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
549  if(level_code >= 100){
550  prefix= level_code - 100;
551  if(prefix == LEVEL_TAB_BITS){
552  prefix += get_level_prefix(gb);
553  }
554  if(prefix<15){
555  level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
556  }else{
557  level_code = 15<<suffix_length;
558  if (prefix>=16) {
559  if(prefix > 25+3){
560  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
561  return AVERROR_INVALIDDATA;
562  }
563  level_code += (1<<(prefix-3))-4096;
564  }
565  level_code += get_bits(gb, prefix-3);
566  }
567  mask= -(level_code&1);
568  level_code= (((2+level_code)>>1) ^ mask) - mask;
569  }
570  level[i]= level_code;
571  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
572  }
573  }
574 
575  if(total_coeff == max_coeff)
576  zeros_left=0;
577  else{
578  if (max_coeff <= 8) {
579  if (max_coeff == 4)
580  zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
582  else
583  zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
585  } else {
586  zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
587  }
588  }
589 
590 #define STORE_BLOCK(type) \
591  scantable += zeros_left + total_coeff - 1; \
592  if(n >= LUMA_DC_BLOCK_INDEX){ \
593  ((type*)block)[*scantable] = level[0]; \
594  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
595  if(zeros_left < 7) \
596  run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
597  else \
598  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
599  zeros_left -= run_before; \
600  scantable -= 1 + run_before; \
601  ((type*)block)[*scantable]= level[i]; \
602  } \
603  for(;i<total_coeff;i++) { \
604  scantable--; \
605  ((type*)block)[*scantable]= level[i]; \
606  } \
607  }else{ \
608  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
609  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
610  if(zeros_left < 7) \
611  run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
612  else \
613  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
614  zeros_left -= run_before; \
615  scantable -= 1 + run_before; \
616  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
617  } \
618  for(;i<total_coeff;i++) { \
619  scantable--; \
620  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
621  } \
622  }
623 
624  if (h->pixel_shift) {
626  } else {
627  STORE_BLOCK(int16_t)
628  }
629 
630  if(zeros_left<0){
631  av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
632  return -1;
633  }
634 
635  return 0;
636 }
637 
638 static av_always_inline
640  GetBitContext *gb, const uint8_t *scan,
641  const uint8_t *scan8x8, int pixel_shift,
642  int mb_type, int cbp, int p)
643 {
644  int i4x4, i8x8;
645  int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
646  if(IS_INTRA16x16(mb_type)){
647  AV_ZERO128(sl->mb_luma_dc[p]+0);
648  AV_ZERO128(sl->mb_luma_dc[p]+8);
649  AV_ZERO128(sl->mb_luma_dc[p]+16);
650  AV_ZERO128(sl->mb_luma_dc[p]+24);
651  if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
652  return -1; //FIXME continue if partitioned and other return -1 too
653  }
654 
655  av_assert2((cbp&15) == 0 || (cbp&15) == 15);
656 
657  if(cbp&15){
658  for(i8x8=0; i8x8<4; i8x8++){
659  for(i4x4=0; i4x4<4; i4x4++){
660  const int index= i4x4 + 4*i8x8 + p*16;
661  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
662  index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
663  return -1;
664  }
665  }
666  }
667  return 0xf;
668  }else{
669  fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
670  return 0;
671  }
672  }else{
673  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
674  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
675  int new_cbp = 0;
676  for(i8x8=0; i8x8<4; i8x8++){
677  if(cbp & (1<<i8x8)){
678  if(IS_8x8DCT(mb_type)){
679  int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
680  uint8_t *nnz;
681  for(i4x4=0; i4x4<4; i4x4++){
682  const int index= i4x4 + 4*i8x8 + p*16;
683  if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
684  h->dequant8_coeff[cqm][qscale], 16) < 0 )
685  return -1;
686  }
687  nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
688  nnz[0] += nnz[1] + nnz[8] + nnz[9];
689  new_cbp |= !!nnz[0] << i8x8;
690  }else{
691  for(i4x4=0; i4x4<4; i4x4++){
692  const int index= i4x4 + 4*i8x8 + p*16;
693  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
694  scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
695  return -1;
696  }
697  new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
698  }
699  }
700  }else{
701  uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
702  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
703  }
704  }
705  return new_cbp;
706  }
707 }
708 
710 {
711  int mb_xy;
712  int partition_count;
713  unsigned int mb_type, cbp;
714  int dct8x8_allowed= h->pps.transform_8x8_mode;
715  int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
716  const int pixel_shift = h->pixel_shift;
717 
718  mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
719 
720  ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, sl->mb_x, sl->mb_y);
721  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
722  down the code */
723  if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
724  if (sl->mb_skip_run == -1)
725  sl->mb_skip_run = get_ue_golomb_long(&sl->gb);
726 
727  if (sl->mb_skip_run--) {
728  if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
729  if (sl->mb_skip_run == 0)
730  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
731  }
732  decode_mb_skip(h, sl);
733  return 0;
734  }
735  }
736  if (FRAME_MBAFF(h)) {
737  if ((sl->mb_y & 1) == 0)
738  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
739  }
740 
741  sl->prev_mb_skipped = 0;
742 
743  mb_type= get_ue_golomb(&sl->gb);
744  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
745  if(mb_type < 23){
746  partition_count= b_mb_type_info[mb_type].partition_count;
747  mb_type= b_mb_type_info[mb_type].type;
748  }else{
749  mb_type -= 23;
750  goto decode_intra_mb;
751  }
752  } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
753  if(mb_type < 5){
754  partition_count= p_mb_type_info[mb_type].partition_count;
755  mb_type= p_mb_type_info[mb_type].type;
756  }else{
757  mb_type -= 5;
758  goto decode_intra_mb;
759  }
760  }else{
762  if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
763  mb_type--;
764 decode_intra_mb:
765  if(mb_type > 25){
766  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);
767  return -1;
768  }
769  partition_count=0;
770  cbp= i_mb_type_info[mb_type].cbp;
772  mb_type= i_mb_type_info[mb_type].type;
773  }
774 
775  if (MB_FIELD(sl))
776  mb_type |= MB_TYPE_INTERLACED;
777 
778  h->slice_table[mb_xy] = sl->slice_num;
779 
780  if(IS_INTRA_PCM(mb_type)){
781  const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
782  h->sps.bit_depth_luma;
783 
784  // We assume these blocks are very rare so we do not optimize it.
785  sl->intra_pcm_ptr = align_get_bits(&sl->gb);
786  if (get_bits_left(&sl->gb) < mb_size) {
787  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
788  return AVERROR_INVALIDDATA;
789  }
790  skip_bits_long(&sl->gb, mb_size);
791 
792  // In deblocking, the quantizer is 0
793  h->cur_pic.qscale_table[mb_xy] = 0;
794  // All coeffs are present
795  memset(h->non_zero_count[mb_xy], 16, 48);
796 
797  h->cur_pic.mb_type[mb_xy] = mb_type;
798  return 0;
799  }
800 
801  fill_decode_neighbors(h, sl, mb_type);
802  fill_decode_caches(h, sl, mb_type);
803 
804  //mb_pred
805  if(IS_INTRA(mb_type)){
806  int pred_mode;
807 // init_top_left_availability(h);
808  if(IS_INTRA4x4(mb_type)){
809  int i;
810  int di = 1;
811  if(dct8x8_allowed && get_bits1(&sl->gb)){
812  mb_type |= MB_TYPE_8x8DCT;
813  di = 4;
814  }
815 
816 // fill_intra4x4_pred_table(h);
817  for(i=0; i<16; i+=di){
818  int mode = pred_intra_mode(h, sl, i);
819 
820  if(!get_bits1(&sl->gb)){
821  const int rem_mode= get_bits(&sl->gb, 3);
822  mode = rem_mode + (rem_mode >= mode);
823  }
824 
825  if(di==4)
826  fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
827  else
829  }
831  if (ff_h264_check_intra4x4_pred_mode(h, sl) < 0)
832  return -1;
833  }else{
835  if (sl->intra16x16_pred_mode < 0)
836  return -1;
837  }
838  if(decode_chroma){
839  pred_mode= ff_h264_check_intra_pred_mode(h, sl, get_ue_golomb_31(&sl->gb), 1);
840  if(pred_mode < 0)
841  return -1;
842  sl->chroma_pred_mode = pred_mode;
843  } else {
845  }
846  }else if(partition_count==4){
847  int i, j, sub_partition_count[4], list, ref[2][4];
848 
849  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
850  for(i=0; i<4; i++){
851  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
852  if(sl->sub_mb_type[i] >=13){
853  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);
854  return -1;
855  }
856  sub_partition_count[i]= b_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
858  }
859  if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
860  ff_h264_pred_direct_motion(h, sl, &mb_type);
861  sl->ref_cache[0][scan8[4]] =
862  sl->ref_cache[1][scan8[4]] =
863  sl->ref_cache[0][scan8[12]] =
864  sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
865  }
866  }else{
867  av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
868  for(i=0; i<4; i++){
869  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
870  if(sl->sub_mb_type[i] >=4){
871  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);
872  return -1;
873  }
874  sub_partition_count[i]= p_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
876  }
877  }
878 
879  for (list = 0; list < sl->list_count; list++) {
880  int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
881  for(i=0; i<4; i++){
882  if(IS_DIRECT(sl->sub_mb_type[i])) continue;
883  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
884  unsigned int tmp;
885  if(ref_count == 1){
886  tmp= 0;
887  }else if(ref_count == 2){
888  tmp= get_bits1(&sl->gb)^1;
889  }else{
890  tmp= get_ue_golomb_31(&sl->gb);
891  if(tmp>=ref_count){
892  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
893  return -1;
894  }
895  }
896  ref[list][i]= tmp;
897  }else{
898  //FIXME
899  ref[list][i] = -1;
900  }
901  }
902  }
903 
904  if(dct8x8_allowed)
905  dct8x8_allowed = get_dct8x8_allowed(h, sl);
906 
907  for (list = 0; list < sl->list_count; list++) {
908  for(i=0; i<4; i++){
909  if(IS_DIRECT(sl->sub_mb_type[i])) {
910  sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
911  continue;
912  }
913  sl->ref_cache[list][ scan8[4*i] ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
914  sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
915 
916  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
917  const int sub_mb_type= sl->sub_mb_type[i];
918  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
919  for(j=0; j<sub_partition_count[i]; j++){
920  int mx, my;
921  const int index= 4*i + block_width*j;
922  int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
923  pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
924  mx += get_se_golomb(&sl->gb);
925  my += get_se_golomb(&sl->gb);
926  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
927 
928  if(IS_SUB_8X8(sub_mb_type)){
929  mv_cache[ 1 ][0]=
930  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
931  mv_cache[ 1 ][1]=
932  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
933  }else if(IS_SUB_8X4(sub_mb_type)){
934  mv_cache[ 1 ][0]= mx;
935  mv_cache[ 1 ][1]= my;
936  }else if(IS_SUB_4X8(sub_mb_type)){
937  mv_cache[ 8 ][0]= mx;
938  mv_cache[ 8 ][1]= my;
939  }
940  mv_cache[ 0 ][0]= mx;
941  mv_cache[ 0 ][1]= my;
942  }
943  }else{
944  uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
945  p[0] = p[1]=
946  p[8] = p[9]= 0;
947  }
948  }
949  }
950  }else if(IS_DIRECT(mb_type)){
951  ff_h264_pred_direct_motion(h, sl, &mb_type);
952  dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
953  }else{
954  int list, mx, my, i;
955  //FIXME we should set ref_idx_l? to 0 if we use that later ...
956  if(IS_16X16(mb_type)){
957  for (list = 0; list < sl->list_count; list++) {
958  unsigned int val;
959  if(IS_DIR(mb_type, 0, list)){
960  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
961  if (rc == 1) {
962  val= 0;
963  } else if (rc == 2) {
964  val= get_bits1(&sl->gb)^1;
965  }else{
966  val= get_ue_golomb_31(&sl->gb);
967  if (val >= rc) {
968  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
969  return -1;
970  }
971  }
972  fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
973  }
974  }
975  for (list = 0; list < sl->list_count; list++) {
976  if(IS_DIR(mb_type, 0, list)){
977  pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
978  mx += get_se_golomb(&sl->gb);
979  my += get_se_golomb(&sl->gb);
980  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
981 
982  fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
983  }
984  }
985  }
986  else if(IS_16X8(mb_type)){
987  for (list = 0; list < sl->list_count; list++) {
988  for(i=0; i<2; i++){
989  unsigned int val;
990  if(IS_DIR(mb_type, i, list)){
991  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
992  if (rc == 1) {
993  val= 0;
994  } else if (rc == 2) {
995  val= get_bits1(&sl->gb)^1;
996  }else{
997  val= get_ue_golomb_31(&sl->gb);
998  if (val >= rc) {
999  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1000  return -1;
1001  }
1002  }
1003  }else
1004  val= LIST_NOT_USED&0xFF;
1005  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1006  }
1007  }
1008  for (list = 0; list < sl->list_count; list++) {
1009  for(i=0; i<2; i++){
1010  unsigned int val;
1011  if(IS_DIR(mb_type, i, list)){
1012  pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1013  mx += get_se_golomb(&sl->gb);
1014  my += get_se_golomb(&sl->gb);
1015  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1016 
1017  val= pack16to32(mx,my);
1018  }else
1019  val=0;
1020  fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1021  }
1022  }
1023  }else{
1024  av_assert2(IS_8X16(mb_type));
1025  for (list = 0; list < sl->list_count; list++) {
1026  for(i=0; i<2; i++){
1027  unsigned int val;
1028  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1029  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1030  if (rc == 1) {
1031  val= 0;
1032  } else if (rc == 2) {
1033  val= get_bits1(&sl->gb)^1;
1034  }else{
1035  val= get_ue_golomb_31(&sl->gb);
1036  if (val >= rc) {
1037  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1038  return -1;
1039  }
1040  }
1041  }else
1042  val= LIST_NOT_USED&0xFF;
1043  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1044  }
1045  }
1046  for (list = 0; list < sl->list_count; list++) {
1047  for(i=0; i<2; i++){
1048  unsigned int val;
1049  if(IS_DIR(mb_type, i, list)){
1050  pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1051  mx += get_se_golomb(&sl->gb);
1052  my += get_se_golomb(&sl->gb);
1053  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1054 
1055  val= pack16to32(mx,my);
1056  }else
1057  val=0;
1058  fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1059  }
1060  }
1061  }
1062  }
1063 
1064  if(IS_INTER(mb_type))
1065  write_back_motion(h, sl, mb_type);
1066 
1067  if(!IS_INTRA16x16(mb_type)){
1068  cbp= get_ue_golomb(&sl->gb);
1069 
1070  if(decode_chroma){
1071  if(cbp > 47){
1072  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1073  return -1;
1074  }
1075  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
1076  else cbp= golomb_to_inter_cbp [cbp];
1077  }else{
1078  if(cbp > 15){
1079  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1080  return -1;
1081  }
1082  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1083  else cbp= golomb_to_inter_cbp_gray[cbp];
1084  }
1085  } else {
1086  if (!decode_chroma && cbp>15) {
1087  av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1088  return AVERROR_INVALIDDATA;
1089  }
1090  }
1091 
1092  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1093  mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1094  }
1095  sl->cbp=
1096  h->cbp_table[mb_xy]= cbp;
1097  h->cur_pic.mb_type[mb_xy] = mb_type;
1098 
1099  if(cbp || IS_INTRA16x16(mb_type)){
1100  int i4x4, i8x8, chroma_idx;
1101  int dquant;
1102  int ret;
1103  GetBitContext *gb = &sl->gb;
1104  const uint8_t *scan, *scan8x8;
1105  const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1106 
1107  if(IS_INTERLACED(mb_type)){
1108  scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1109  scan = sl->qscale ? h->field_scan : h->field_scan_q0;
1110  }else{
1111  scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1112  scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1113  }
1114 
1115  dquant= get_se_golomb(&sl->gb);
1116 
1117  sl->qscale += dquant;
1118 
1119  if (((unsigned)sl->qscale) > max_qp){
1120  if (sl->qscale < 0) sl->qscale += max_qp + 1;
1121  else sl->qscale -= max_qp+1;
1122  if (((unsigned)sl->qscale) > max_qp){
1123  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1124  return -1;
1125  }
1126  }
1127 
1128  sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
1129  sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
1130 
1131  if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1132  return -1;
1133  }
1134  h->cbp_table[mb_xy] |= ret << 12;
1135  if (CHROMA444(h)) {
1136  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1137  return -1;
1138  }
1139  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1140  return -1;
1141  }
1142  } else {
1143  const int num_c8x8 = h->sps.chroma_format_idc;
1144 
1145  if(cbp&0x30){
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,
1150  NULL, 4*num_c8x8) < 0) {
1151  return -1;
1152  }
1153  }
1154 
1155  if(cbp&0x20){
1156  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1157  const uint32_t *qmul = h->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)
1163  return -1;
1164  mb += 16 << pixel_shift;
1165  }
1166  }
1167  }
1168  }else{
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);
1171  }
1172  }
1173  }else{
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);
1177  }
1178  h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1180 
1181  return 0;
1182 }
int chroma_format_idc
Definition: h264.h:177
uint8_t pred_mode
Definition: h264data.h:75
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:271
#define ff_tlog(ctx,...)
Definition: internal.h:60
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:634
int ff_h264_check_intra_pred_mode(const H264Context *h, H264SliceContext *sl, 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.c:184
#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: h264.h:476
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264.h:468
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
#define CHROMA444(h)
Definition: h264.h:99
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
static const uint8_t chroma422_dc_scan[8]
Definition: h264data.h:66
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:217
uint16_t * cbp_table
Definition: h264.h:570
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: h264.h:377
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
#define IS_SUB_8X8(a)
Definition: mpegutils.h:86
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264.h:579
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
#define VLC_TYPE
Definition: get_bits.h:61
#define FF_ARRAY_ELEMS(a)
H264Context.
Definition: h264.h:499
static const uint8_t chroma422_dc_coeff_token_len[4 *9]
Definition: h264_cavlc.c:65
static av_always_inline void write_back_motion(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264.h:1097
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 av_always_inline void write_back_non_zero_count(const H264Context *h, H264SliceContext *sl)
Definition: h264.h:1037
static VLC chroma422_dc_coeff_token_vlc
Definition: h264_cavlc.c:247
#define IS_REF0(a)
Definition: h264.h:105
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:110
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:442
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:446
static const PMbInfo b_sub_mb_type_info[13]
Definition: h264data.h:154
Switching Intra.
Definition: avutil.h:271
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:219
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
Definition: h264_direct.c:702
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 VLC chroma422_dc_total_zeros_vlc[7]
Definition: h264_cavlc.c:259
#define IS_8x8DCT(a)
Definition: h264.h:106
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: h264.h:473
#define MB_FIELD(sl)
Definition: h264.h:72
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264.h:557
static const uint8_t coeff_token_bits[4][4 *17]
Definition: h264_cavlc.c:120
uint8_t
#define av_cold
Definition: attributes.h:74
#define mb
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
mode
Definition: f_perms.c:27
int slice_type
Definition: h264.h:351
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 LUMA_DC_BLOCK_INDEX
Definition: h264.h:960
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
#define IS_DIR(a, part, list)
Definition: mpegutils.h:92
static av_always_inline int pred_intra_mode(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264.h:1009
static const IMbInfo i_mb_type_info[26]
Definition: h264data.h:79
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
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:84
static const uint8_t total_zeros_len[16][16]
Definition: h264_cavlc.c:151
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color, int update)
Definition: ffplay.c:780
int chroma_qp[2]
Definition: h264.h:356
#define av_log(a,...)
uint16_t type
Definition: h264data.h:109
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2]
Definition: h264_cavlc.c:240
static VLC total_zeros_vlc[15]
Definition: h264_cavlc.c:251
H.264 / AVC / MPEG4 part10 codec.
static VLC chroma_dc_total_zeros_vlc[3]
Definition: h264_cavlc.c:255
int slice_num
Definition: h264.h:350
#define U(x)
Definition: vp56_arith.h:37
int frame_num
Definition: h264.h:624
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:588
#define RUN7_VLC_BITS
Definition: h264_cavlc.c:281
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:173
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int get_ue_golomb(GetBitContext *gb)
read unsigned exp golomb code.
Definition: golomb.h:53
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
Definition: h264.h:1124
static const uint16_t mask[17]
Definition: lzw.c:38
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
Definition: h264.h:1025
#define CHROMA_DC_BLOCK_INDEX
Definition: h264.h:961
static const struct endianess table[]
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264.h:383
static const uint8_t chroma_dc_total_zeros_bits[3][4]
Definition: h264_cavlc.c:193
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
PPS pps
current pps
Definition: h264.h:551
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().
static VLC chroma_dc_coeff_token_vlc
Definition: h264_cavlc.c:243
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264.h:980
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define CLOSE_READER(name, gb)
Definition: get_bits.h:144
Libavcodec external API header.
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264.h:352
Definition: get_bits.h:63
int mb_skip_run
Definition: h264.h:413
static const uint8_t scan8[16 *3+3]
Definition: h264.h:964
#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: h264.h:477
static const int chroma_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:245
#define IS_INTRA_PCM(a)
Definition: mpegutils.h:78
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:169
#define IS_16X8(a)
Definition: mpegutils.h:83
int chroma_pred_mode
Definition: h264.h:380
#define IS_SUB_4X8(a)
Definition: mpegutils.h:88
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264.h:560
uint8_t field_scan8x8_cavlc[64]
Definition: h264.h:582
#define IS_DIRECT(a)
Definition: mpegutils.h:80
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:260
ret
Definition: avfilter.c:974
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
#define MB_TYPE_INTERLACED
Definition: avcodec.h:901
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: h264.h:303
SPS sps
current sps
Definition: h264.h:550
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:287
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:194
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:555
int direct_8x8_inference_flag
Definition: h264.h:192
int n
Definition: avisynth_c.h:547
static const uint8_t golomb_to_intra4x4_cbp[48]
Definition: h264data.h:42
#define MB_MBAFF(h)
Definition: h264.h:71
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:474
#define PART_NOT_AVAILABLE
Definition: h264.h:536
#define IS_INTRA16x16(a)
Definition: mpegutils.h:72
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: get_bits.h:66
uint8_t zigzag_scan_q0[16]
Definition: h264.h:583
int intra16x16_pred_mode
Definition: h264.h:381
int mb_stride
Definition: h264.h:594
#define IS_INTERLACED(a)
Definition: mpegutils.h:79
AVCodecContext * avctx
Definition: h264.h:501
#define IS_SUB_8X4(a)
Definition: mpegutils.h:87
H264 / AVC / MPEG4 part10 codec data table
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:133
int ff_h264_check_intra4x4_pred_mode(const H264Context *h, H264SliceContext *sl)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264.c:137
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:457
void * buf
Definition: avisynth_c.h:553
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
int8_t * qscale_table
Definition: h264.h:297
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
#define IS_16X16(a)
Definition: mpegutils.h:82
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
#define CHROMA422(h)
Definition: h264.h:98
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264.h:463
int index
Definition: gxfenc.c:89
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264.h:558
static const uint8_t chroma_dc_scan[4]
Definition: h264data.h:61
#define IS_8X16(a)
Definition: mpegutils.h:84
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:327
int pixel_shift
0 for 8-bit H264, 1 for high-bit-depth H264
Definition: h264.h:516
#define GET_CACHE(name, gb)
Definition: get_bits.h:210
#define MB_TYPE_16x16
Definition: avcodec.h:897
static const int total_zeros_vlc_tables_size
Definition: h264_cavlc.c:253
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264.h:417
#define IS_INTER(a)
Definition: mpegutils.h:75
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
static const PMbInfo b_mb_type_info[23]
Definition: h264data.h:128
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
static const PMbInfo p_mb_type_info[5]
Definition: h264data.h:113
static const PMbInfo p_sub_mb_type_info[4]
Definition: h264data.h:121
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264.h:251
uint8_t zigzag_scan[16]
Definition: h264.h:577
unsigned int list_count
Definition: h264.h:443
uint8_t level
Definition: svq3.c:150
#define AV_ZERO128(d)
Definition: intreadwrite.h:622
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2]
Definition: h264_cavlc.c:248
uint8_t cbp
Definition: h264data.h:76
common internal api header.
H.264 / AVC / MPEG4 part10 motion vector predicion.
Bi-dir predicted.
Definition: avutil.h:269
static void fill_decode_neighbors(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:356
static const uint8_t golomb_to_inter_cbp[48]
Definition: h264data.h:48
#define MB_TYPE_16x8
Definition: avcodec.h:898
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:709
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:226
static av_always_inline int get_chroma_qp(const H264Context *h, int t, int qscale)
Get the chroma qp.
Definition: h264.h:1001
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:71
static VLC run7_vlc
Definition: h264_cavlc.c:267
float re
Definition: fft-test.c:73
uint8_t zigzag_scan8x8_cavlc_q0[64]
Definition: h264.h:585
int8_t ref_cache[2][5 *8]
Definition: h264.h:469
#define FRAME_MBAFF(h)
Definition: h264.h:73
const uint16_t ff_h264_mb_sizes[4]
Definition: h264.c:54
static const int run_vlc_tables_size
Definition: h264_cavlc.c:265
#define av_log2
Definition: intmath.h:105
static VLC run_vlc[6]
Definition: h264_cavlc.c:263
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
H264Picture cur_pic
Definition: h264.h:510
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:419
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:449
uint8_t field_scan8x8_cavlc_q0[64]
Definition: h264.h:588
const uint8_t * intra_pcm_ptr
Definition: h264.h:449
uint16_t type
Definition: h264data.h:74
#define av_always_inline
Definition: attributes.h:37
static const uint8_t golomb_to_inter_cbp_gray[16]
Definition: h264_cavlc.c:41
static VLC_TYPE run_vlc_tables[6][8][2]
Definition: h264_cavlc.c:264
uint8_t field_scan_q0[16]
Definition: h264.h:586
#define LIST_NOT_USED
Definition: h264.h:535
int mb_field_decoding_flag
Definition: h264.h:416
uint8_t(* non_zero_count)[48]
Definition: h264.h:533
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:639
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:244
GetBitContext gb
Definition: h264.h:347
uint8_t field_scan[16]
Definition: h264.h:580
Predicted.
Definition: avutil.h:268
#define MB_TYPE_8x8DCT
Definition: h264.h:104
#define STORE_BLOCK(type)
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 int16_t block[64]
Definition: dct-test.c:110