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 "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];
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 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 #ifdef TRACE
426  print_bin(buf>>(32-log), log);
427  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__);
428 #endif
429 
430  LAST_SKIP_BITS(re, gb, log);
431  CLOSE_READER(re, gb);
432 
433  return log-1;
434 }
435 
436 /**
437  * Decode a residual block.
438  * @param n block index
439  * @param scantable scantable
440  * @param max_coeff number of coefficients in the block
441  * @return <0 if an error occurred
442  */
444  GetBitContext *gb, int16_t *block, int n,
445  const uint8_t *scantable, const uint32_t *qmul,
446  int max_coeff)
447 {
448  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};
449  int level[16];
450  int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
451 
452  //FIXME put trailing_onex into the context
453 
454  if(max_coeff <= 8){
455  if (max_coeff == 4)
456  coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
457  else
458  coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
459  total_coeff= coeff_token>>2;
460  }else{
461  if(n >= LUMA_DC_BLOCK_INDEX){
462  total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
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  }else{
466  total_coeff= pred_non_zero_count(h, sl, n);
467  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
468  total_coeff= coeff_token>>2;
469  }
470  }
471  sl->non_zero_count_cache[scan8[n]] = total_coeff;
472 
473  //FIXME set last_non_zero?
474 
475  if(total_coeff==0)
476  return 0;
477  if(total_coeff > (unsigned)max_coeff) {
478  av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
479  return -1;
480  }
481 
482  trailing_ones= coeff_token&3;
483  ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
484  av_assert2(total_coeff<=16);
485 
486  i = show_bits(gb, 3);
487  skip_bits(gb, trailing_ones);
488  level[0] = 1-((i&4)>>1);
489  level[1] = 1-((i&2) );
490  level[2] = 1-((i&1)<<1);
491 
492  if(trailing_ones<total_coeff) {
493  int mask, prefix;
494  int suffix_length = total_coeff > 10 & trailing_ones < 3;
495  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
496  int level_code= cavlc_level_tab[suffix_length][bitsi][0];
497 
498  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
499  if(level_code >= 100){
500  prefix= level_code - 100;
501  if(prefix == LEVEL_TAB_BITS)
502  prefix += get_level_prefix(gb);
503 
504  //first coefficient has suffix_length equal to 0 or 1
505  if(prefix<14){ //FIXME try to build a large unified VLC table for all this
506  if(suffix_length)
507  level_code= (prefix<<1) + get_bits1(gb); //part
508  else
509  level_code= prefix; //part
510  }else if(prefix==14){
511  if(suffix_length)
512  level_code= (prefix<<1) + get_bits1(gb); //part
513  else
514  level_code= prefix + get_bits(gb, 4); //part
515  }else{
516  level_code= 30;
517  if(prefix>=16){
518  if(prefix > 25+3){
519  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
520  return -1;
521  }
522  level_code += (1<<(prefix-3))-4096;
523  }
524  level_code += get_bits(gb, prefix-3); //part
525  }
526 
527  if(trailing_ones < 3) level_code += 2;
528 
529  suffix_length = 2;
530  mask= -(level_code&1);
531  level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
532  }else{
533  level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
534 
535  suffix_length = 1 + (level_code + 3U > 6U);
536  level[trailing_ones]= level_code;
537  }
538 
539  //remaining coefficients have suffix_length > 0
540  for(i=trailing_ones+1;i<total_coeff;i++) {
541  static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
542  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
543  level_code= cavlc_level_tab[suffix_length][bitsi][0];
544 
545  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
546  if(level_code >= 100){
547  prefix= level_code - 100;
548  if(prefix == LEVEL_TAB_BITS){
549  prefix += get_level_prefix(gb);
550  }
551  if(prefix<15){
552  level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
553  }else{
554  level_code = 15<<suffix_length;
555  if (prefix>=16) {
556  if(prefix > 25+3){
557  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
558  return AVERROR_INVALIDDATA;
559  }
560  level_code += (1<<(prefix-3))-4096;
561  }
562  level_code += get_bits(gb, prefix-3);
563  }
564  mask= -(level_code&1);
565  level_code= (((2+level_code)>>1) ^ mask) - mask;
566  }
567  level[i]= level_code;
568  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
569  }
570  }
571 
572  if(total_coeff == max_coeff)
573  zeros_left=0;
574  else{
575  if (max_coeff <= 8) {
576  if (max_coeff == 4)
577  zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
579  else
580  zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
582  } else {
583  zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
584  }
585  }
586 
587 #define STORE_BLOCK(type) \
588  scantable += zeros_left + total_coeff - 1; \
589  if(n >= LUMA_DC_BLOCK_INDEX){ \
590  ((type*)block)[*scantable] = level[0]; \
591  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
592  if(zeros_left < 7) \
593  run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
594  else \
595  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
596  zeros_left -= run_before; \
597  scantable -= 1 + run_before; \
598  ((type*)block)[*scantable]= level[i]; \
599  } \
600  for(;i<total_coeff;i++) { \
601  scantable--; \
602  ((type*)block)[*scantable]= level[i]; \
603  } \
604  }else{ \
605  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
606  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
607  if(zeros_left < 7) \
608  run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
609  else \
610  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
611  zeros_left -= run_before; \
612  scantable -= 1 + run_before; \
613  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
614  } \
615  for(;i<total_coeff;i++) { \
616  scantable--; \
617  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
618  } \
619  }
620 
621  if (h->pixel_shift) {
623  } else {
624  STORE_BLOCK(int16_t)
625  }
626 
627  if(zeros_left<0){
628  av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
629  return -1;
630  }
631 
632  return 0;
633 }
634 
635 static av_always_inline
637  GetBitContext *gb, const uint8_t *scan,
638  const uint8_t *scan8x8, int pixel_shift,
639  int mb_type, int cbp, int p)
640 {
641  int i4x4, i8x8;
642  int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
643  if(IS_INTRA16x16(mb_type)){
644  AV_ZERO128(sl->mb_luma_dc[p]+0);
645  AV_ZERO128(sl->mb_luma_dc[p]+8);
646  AV_ZERO128(sl->mb_luma_dc[p]+16);
647  AV_ZERO128(sl->mb_luma_dc[p]+24);
648  if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
649  return -1; //FIXME continue if partitioned and other return -1 too
650  }
651 
652  av_assert2((cbp&15) == 0 || (cbp&15) == 15);
653 
654  if(cbp&15){
655  for(i8x8=0; i8x8<4; i8x8++){
656  for(i4x4=0; i4x4<4; i4x4++){
657  const int index= i4x4 + 4*i8x8 + p*16;
658  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
659  index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
660  return -1;
661  }
662  }
663  }
664  return 0xf;
665  }else{
666  fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
667  return 0;
668  }
669  }else{
670  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
671  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
672  int new_cbp = 0;
673  for(i8x8=0; i8x8<4; i8x8++){
674  if(cbp & (1<<i8x8)){
675  if(IS_8x8DCT(mb_type)){
676  int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
677  uint8_t *nnz;
678  for(i4x4=0; i4x4<4; i4x4++){
679  const int index= i4x4 + 4*i8x8 + p*16;
680  if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
681  h->dequant8_coeff[cqm][qscale], 16) < 0 )
682  return -1;
683  }
684  nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
685  nnz[0] += nnz[1] + nnz[8] + nnz[9];
686  new_cbp |= !!nnz[0] << i8x8;
687  }else{
688  for(i4x4=0; i4x4<4; i4x4++){
689  const int index= i4x4 + 4*i8x8 + p*16;
690  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
691  scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
692  return -1;
693  }
694  new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
695  }
696  }
697  }else{
698  uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
699  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
700  }
701  }
702  return new_cbp;
703  }
704 }
705 
707 {
708  int mb_xy;
709  int partition_count;
710  unsigned int mb_type, cbp;
711  int dct8x8_allowed= h->pps.transform_8x8_mode;
712  int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
713  const int pixel_shift = h->pixel_shift;
714 
715  mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
716 
717  ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, sl->mb_x, sl->mb_y);
718  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
719  down the code */
720  if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
721  if (sl->mb_skip_run == -1)
722  sl->mb_skip_run = get_ue_golomb_long(&sl->gb);
723 
724  if (sl->mb_skip_run--) {
725  if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
726  if (sl->mb_skip_run == 0)
727  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
728  }
729  decode_mb_skip(h, sl);
730  return 0;
731  }
732  }
733  if (FRAME_MBAFF(h)) {
734  if ((sl->mb_y & 1) == 0)
735  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
736  }
737 
738  sl->prev_mb_skipped = 0;
739 
740  mb_type= get_ue_golomb(&sl->gb);
741  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
742  if(mb_type < 23){
743  partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
744  mb_type = ff_h264_b_mb_type_info[mb_type].type;
745  }else{
746  mb_type -= 23;
747  goto decode_intra_mb;
748  }
749  } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
750  if(mb_type < 5){
751  partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
752  mb_type = ff_h264_p_mb_type_info[mb_type].type;
753  }else{
754  mb_type -= 5;
755  goto decode_intra_mb;
756  }
757  }else{
759  if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
760  mb_type--;
761 decode_intra_mb:
762  if(mb_type > 25){
763  av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(sl->slice_type), sl->mb_x, sl->mb_y);
764  return -1;
765  }
766  partition_count=0;
767  cbp = ff_h264_i_mb_type_info[mb_type].cbp;
769  mb_type = ff_h264_i_mb_type_info[mb_type].type;
770  }
771 
772  if (MB_FIELD(sl))
773  mb_type |= MB_TYPE_INTERLACED;
774 
775  h->slice_table[mb_xy] = sl->slice_num;
776 
777  if(IS_INTRA_PCM(mb_type)){
778  const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
779  h->sps.bit_depth_luma;
780 
781  // We assume these blocks are very rare so we do not optimize it.
782  sl->intra_pcm_ptr = align_get_bits(&sl->gb);
783  if (get_bits_left(&sl->gb) < mb_size) {
784  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
785  return AVERROR_INVALIDDATA;
786  }
787  skip_bits_long(&sl->gb, mb_size);
788 
789  // In deblocking, the quantizer is 0
790  h->cur_pic.qscale_table[mb_xy] = 0;
791  // All coeffs are present
792  memset(h->non_zero_count[mb_xy], 16, 48);
793 
794  h->cur_pic.mb_type[mb_xy] = mb_type;
795  return 0;
796  }
797 
798  fill_decode_neighbors(h, sl, mb_type);
799  fill_decode_caches(h, sl, mb_type);
800 
801  //mb_pred
802  if(IS_INTRA(mb_type)){
803  int pred_mode;
804 // init_top_left_availability(h);
805  if(IS_INTRA4x4(mb_type)){
806  int i;
807  int di = 1;
808  if(dct8x8_allowed && get_bits1(&sl->gb)){
809  mb_type |= MB_TYPE_8x8DCT;
810  di = 4;
811  }
812 
813 // fill_intra4x4_pred_table(h);
814  for(i=0; i<16; i+=di){
815  int mode = pred_intra_mode(h, sl, i);
816 
817  if(!get_bits1(&sl->gb)){
818  const int rem_mode= get_bits(&sl->gb, 3);
819  mode = rem_mode + (rem_mode >= mode);
820  }
821 
822  if(di==4)
823  fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
824  else
826  }
830  return -1;
831  }else{
834  if (sl->intra16x16_pred_mode < 0)
835  return -1;
836  }
837  if(decode_chroma){
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] = ff_h264_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] = ff_h264_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))
1076  cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1077  else
1078  cbp = ff_h264_golomb_to_inter_cbp[cbp];
1079  }else{
1080  if(cbp > 15){
1081  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1082  return -1;
1083  }
1084  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1085  else cbp= golomb_to_inter_cbp_gray[cbp];
1086  }
1087  } else {
1088  if (!decode_chroma && cbp>15) {
1089  av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1090  return AVERROR_INVALIDDATA;
1091  }
1092  }
1093 
1094  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1095  mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1096  }
1097  sl->cbp=
1098  h->cbp_table[mb_xy]= cbp;
1099  h->cur_pic.mb_type[mb_xy] = mb_type;
1100 
1101  if(cbp || IS_INTRA16x16(mb_type)){
1102  int i4x4, i8x8, chroma_idx;
1103  int dquant;
1104  int ret;
1105  GetBitContext *gb = &sl->gb;
1106  const uint8_t *scan, *scan8x8;
1107  const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1108 
1109  if(IS_INTERLACED(mb_type)){
1110  scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1111  scan = sl->qscale ? h->field_scan : h->field_scan_q0;
1112  }else{
1113  scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1114  scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1115  }
1116 
1117  dquant= get_se_golomb(&sl->gb);
1118 
1119  sl->qscale += dquant;
1120 
1121  if (((unsigned)sl->qscale) > max_qp){
1122  if (sl->qscale < 0) sl->qscale += max_qp + 1;
1123  else sl->qscale -= max_qp+1;
1124  if (((unsigned)sl->qscale) > max_qp){
1125  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1126  return -1;
1127  }
1128  }
1129 
1130  sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
1131  sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
1132 
1133  if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1134  return -1;
1135  }
1136  h->cbp_table[mb_xy] |= ret << 12;
1137  if (CHROMA444(h)) {
1138  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1139  return -1;
1140  }
1141  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1142  return -1;
1143  }
1144  } else {
1145  const int num_c8x8 = h->sps.chroma_format_idc;
1146 
1147  if(cbp&0x30){
1148  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1149  if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1150  CHROMA_DC_BLOCK_INDEX + chroma_idx,
1152  NULL, 4 * num_c8x8) < 0) {
1153  return -1;
1154  }
1155  }
1156 
1157  if(cbp&0x20){
1158  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1159  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1160  int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1161  for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1162  for (i4x4 = 0; i4x4 < 4; i4x4++) {
1163  const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1164  if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1165  return -1;
1166  mb += 16 << pixel_shift;
1167  }
1168  }
1169  }
1170  }else{
1171  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1172  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1173  }
1174  }
1175  }else{
1176  fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1177  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1178  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1179  }
1180  h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1182 
1183  return 0;
1184 }
int chroma_format_idc
Definition: h264.h:181
uint8_t pred_mode
Definition: h264data.h:35
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:271
#define ff_tlog(ctx,...)
Definition: internal.h:65
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:634
#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:491
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264.h:483
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
#define CHROMA444(h)
Definition: h264.h:102
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:217
uint16_t * cbp_table
Definition: h264.h:595
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:391
int av_log2(unsigned v)
Definition: intmath.c:26
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
#define IS_SUB_8X8(a)
Definition: mpegutils.h:92
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264.h:604
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
#define VLC_TYPE
Definition: get_bits.h:61
H264Context.
Definition: h264.h:514
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:1107
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:1047
static VLC chroma422_dc_coeff_token_vlc
Definition: h264_cavlc.c:247
#define IS_REF0(a)
Definition: h264.h:108
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: h264.h:457
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:443
Switching Intra.
Definition: avutil.h:270
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:706
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:109
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:488
#define MB_FIELD(sl)
Definition: h264.h:75
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264.h:582
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:63
mode
Definition: f_perms.c:27
int slice_type
Definition: h264.h:375
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:970
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:98
static av_always_inline int pred_intra_mode(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264.h:1019
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
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:91
static const uint8_t total_zeros_len[16][16]
Definition: h264_cavlc.c:151
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:102
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color, int update)
Definition: ffplay.c:805
int chroma_qp[2]
Definition: h264.h:380
#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
static int ref[MAX_W *MAX_W]
static VLC total_zeros_vlc[15]
Definition: h264_cavlc.c:251
const PMbInfo ff_h264_p_mb_type_info[5]
Definition: h264data.c:95
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:374
#define U(x)
Definition: vp56_arith.h:37
int frame_num
Definition: h264.h:649
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:607
#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 an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
Definition: h264.h:1134
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:1035
#define CHROMA_DC_BLOCK_INDEX
Definition: h264.h:971
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: h264.h:397
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:576
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: h264.h:414
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:990
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define CLOSE_READER(name, gb)
Definition: get_bits.h:144
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264.h:376
Definition: get_bits.h:63
int mb_skip_run
Definition: h264.h:428
static const uint8_t scan8[16 *3+3]
Definition: h264.h:974
#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:492
static const int chroma_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:245
#define IS_INTRA_PCM(a)
Definition: mpegutils.h:84
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:169
#define IS_16X8(a)
Definition: mpegutils.h:89
int chroma_pred_mode
Definition: h264.h:394
#define IS_SUB_4X8(a)
Definition: mpegutils.h:94
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264.h:585
uint8_t field_scan8x8_cavlc[64]
Definition: h264.h:607
#define IS_DIRECT(a)
Definition: mpegutils.h:86
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:260
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:1244
static uint8_t tmp[8]
Definition: des-test.c:38
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:327
SPS sps
current sps
Definition: h264.h:575
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:295
#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:574
int direct_8x8_inference_flag
Definition: h264.h:196
int n
Definition: avisynth_c.h:547
#define MB_MBAFF(h)
Definition: h264.h:74
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:482
#define PART_NOT_AVAILABLE
Definition: h264.h:561
#define FF_ARRAY_ELEMS(a)
#define IS_INTRA16x16(a)
Definition: mpegutils.h:78
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:608
int intra16x16_pred_mode
Definition: h264.h:395
int mb_stride
Definition: h264.h:619
#define IS_INTERLACED(a)
Definition: mpegutils.h:85
AVCodecContext * avctx
Definition: h264.h:516
#define IS_SUB_8X4(a)
Definition: mpegutils.h:93
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:133
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:465
void * buf
Definition: avisynth_c.h:553
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
int8_t * qscale_table
Definition: h264.h:321
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:312
const uint8_t ff_h264_golomb_to_intra4x4_cbp[48]
Definition: h264data.c:42
#define IS_16X16(a)
Definition: mpegutils.h:88
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:305
#define CHROMA422(h)
Definition: h264.h:101
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264.h:478
int index
Definition: gxfenc.c:89
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264.h:583
#define IS_8X16(a)
Definition: mpegutils.h:90
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:533
#define GET_CACHE(name, gb)
Definition: get_bits.h:210
#define MB_TYPE_16x16
Definition: avcodec.h:1240
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:432
#define IS_INTER(a)
Definition: mpegutils.h:81
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 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.h:257
uint8_t zigzag_scan[16]
Definition: h264.h:602
unsigned int list_count
Definition: h264.h:458
uint8_t level
Definition: svq3.c:193
#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:36
common internal api header.
const PMbInfo ff_h264_b_mb_type_info[23]
Definition: h264data.c:110
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:150
const PMbInfo ff_h264_p_sub_mb_type_info[4]
Definition: h264data.c:103
H.264 / AVC / MPEG4 part10 motion vector predicion.
Bi-dir predicted.
Definition: avutil.h:268
static void fill_decode_neighbors(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:356
#define MB_TYPE_16x8
Definition: avcodec.h:1241
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:706
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:230
static av_always_inline int get_chroma_qp(const H264Context *h, int t, int qscale)
Get the chroma qp.
Definition: h264.h:1011
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:77
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:610
int8_t ref_cache[2][5 *8]
Definition: h264.h:484
#define FRAME_MBAFF(h)
Definition: h264.h:76
const uint16_t ff_h264_mb_sizes[4]
Definition: h264.c:58
static const int run_vlc_tables_size
Definition: h264_cavlc.c:265
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:525
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:457
uint8_t field_scan8x8_cavlc_q0[64]
Definition: h264.h:613
const uint8_t * intra_pcm_ptr
Definition: h264.h:464
uint16_t type
Definition: h264data.h:34
unsigned int left_samples_available
Definition: h264.h:416
#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
static VLC_TYPE run_vlc_tables[6][8][2]
Definition: h264_cavlc.c:264
uint8_t field_scan_q0[16]
Definition: h264.h:611
#define LIST_NOT_USED
Definition: h264.h:560
int mb_field_decoding_flag
Definition: h264.h:431
uint8_t(* non_zero_count)[48]
Definition: h264.h:558
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:636
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:244
GetBitContext gb
Definition: h264.h:371
uint8_t field_scan[16]
Definition: h264.h:605
Predicted.
Definition: avutil.h:267
#define MB_TYPE_8x8DCT
Definition: h264.h:107
#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:112