FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules 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  unsigned mb_skip_run = get_ue_golomb_long(&sl->gb);
726  if (mb_skip_run > h->mb_num) {
727  av_log(h->avctx, AV_LOG_ERROR, "mb_skip_run %d is invalid\n", mb_skip_run);
728  return AVERROR_INVALIDDATA;
729  }
730  sl->mb_skip_run = mb_skip_run;
731  }
732 
733  if (sl->mb_skip_run--) {
734  if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
735  if (sl->mb_skip_run == 0)
736  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
737  }
738  decode_mb_skip(h, sl);
739  return 0;
740  }
741  }
742  if (FRAME_MBAFF(h)) {
743  if ((sl->mb_y & 1) == 0)
744  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
745  }
746 
747  sl->prev_mb_skipped = 0;
748 
749  mb_type= get_ue_golomb(&sl->gb);
750  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
751  if(mb_type < 23){
752  partition_count= b_mb_type_info[mb_type].partition_count;
753  mb_type= b_mb_type_info[mb_type].type;
754  }else{
755  mb_type -= 23;
756  goto decode_intra_mb;
757  }
758  } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
759  if(mb_type < 5){
760  partition_count= p_mb_type_info[mb_type].partition_count;
761  mb_type= p_mb_type_info[mb_type].type;
762  }else{
763  mb_type -= 5;
764  goto decode_intra_mb;
765  }
766  }else{
768  if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
769  mb_type--;
770 decode_intra_mb:
771  if(mb_type > 25){
772  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);
773  return -1;
774  }
775  partition_count=0;
776  cbp= i_mb_type_info[mb_type].cbp;
778  mb_type= i_mb_type_info[mb_type].type;
779  }
780 
781  if (MB_FIELD(sl))
782  mb_type |= MB_TYPE_INTERLACED;
783 
784  h->slice_table[mb_xy] = sl->slice_num;
785 
786  if(IS_INTRA_PCM(mb_type)){
787  const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
788  h->sps.bit_depth_luma;
789 
790  // We assume these blocks are very rare so we do not optimize it.
791  sl->intra_pcm_ptr = align_get_bits(&sl->gb);
792  if (get_bits_left(&sl->gb) < mb_size) {
793  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
794  return AVERROR_INVALIDDATA;
795  }
796  skip_bits_long(&sl->gb, mb_size);
797 
798  // In deblocking, the quantizer is 0
799  h->cur_pic.qscale_table[mb_xy] = 0;
800  // All coeffs are present
801  memset(h->non_zero_count[mb_xy], 16, 48);
802 
803  h->cur_pic.mb_type[mb_xy] = mb_type;
804  return 0;
805  }
806 
807  fill_decode_neighbors(h, sl, mb_type);
808  fill_decode_caches(h, sl, mb_type);
809 
810  //mb_pred
811  if(IS_INTRA(mb_type)){
812  int pred_mode;
813 // init_top_left_availability(h);
814  if(IS_INTRA4x4(mb_type)){
815  int i;
816  int di = 1;
817  if(dct8x8_allowed && get_bits1(&sl->gb)){
818  mb_type |= MB_TYPE_8x8DCT;
819  di = 4;
820  }
821 
822 // fill_intra4x4_pred_table(h);
823  for(i=0; i<16; i+=di){
824  int mode = pred_intra_mode(h, sl, i);
825 
826  if(!get_bits1(&sl->gb)){
827  const int rem_mode= get_bits(&sl->gb, 3);
828  mode = rem_mode + (rem_mode >= mode);
829  }
830 
831  if(di==4)
832  fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
833  else
835  }
837  if (ff_h264_check_intra4x4_pred_mode(h, sl) < 0)
838  return -1;
839  }else{
841  if (sl->intra16x16_pred_mode < 0)
842  return -1;
843  }
844  if(decode_chroma){
845  pred_mode= ff_h264_check_intra_pred_mode(h, sl, get_ue_golomb_31(&sl->gb), 1);
846  if(pred_mode < 0)
847  return -1;
848  sl->chroma_pred_mode = pred_mode;
849  } else {
851  }
852  }else if(partition_count==4){
853  int i, j, sub_partition_count[4], list, ref[2][4];
854 
855  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
856  for(i=0; i<4; i++){
857  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
858  if(sl->sub_mb_type[i] >=13){
859  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);
860  return -1;
861  }
862  sub_partition_count[i]= b_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
864  }
865  if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
866  ff_h264_pred_direct_motion(h, sl, &mb_type);
867  sl->ref_cache[0][scan8[4]] =
868  sl->ref_cache[1][scan8[4]] =
869  sl->ref_cache[0][scan8[12]] =
870  sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
871  }
872  }else{
873  av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
874  for(i=0; i<4; i++){
875  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
876  if(sl->sub_mb_type[i] >=4){
877  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);
878  return -1;
879  }
880  sub_partition_count[i]= p_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
882  }
883  }
884 
885  for (list = 0; list < sl->list_count; list++) {
886  int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
887  for(i=0; i<4; i++){
888  if(IS_DIRECT(sl->sub_mb_type[i])) continue;
889  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
890  unsigned int tmp;
891  if(ref_count == 1){
892  tmp= 0;
893  }else if(ref_count == 2){
894  tmp= get_bits1(&sl->gb)^1;
895  }else{
896  tmp= get_ue_golomb_31(&sl->gb);
897  if(tmp>=ref_count){
898  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
899  return -1;
900  }
901  }
902  ref[list][i]= tmp;
903  }else{
904  //FIXME
905  ref[list][i] = -1;
906  }
907  }
908  }
909 
910  if(dct8x8_allowed)
911  dct8x8_allowed = get_dct8x8_allowed(h, sl);
912 
913  for (list = 0; list < sl->list_count; list++) {
914  for(i=0; i<4; i++){
915  if(IS_DIRECT(sl->sub_mb_type[i])) {
916  sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
917  continue;
918  }
919  sl->ref_cache[list][ scan8[4*i] ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
920  sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
921 
922  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
923  const int sub_mb_type= sl->sub_mb_type[i];
924  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
925  for(j=0; j<sub_partition_count[i]; j++){
926  int mx, my;
927  const int index= 4*i + block_width*j;
928  int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
929  pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
930  mx += get_se_golomb(&sl->gb);
931  my += get_se_golomb(&sl->gb);
932  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
933 
934  if(IS_SUB_8X8(sub_mb_type)){
935  mv_cache[ 1 ][0]=
936  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
937  mv_cache[ 1 ][1]=
938  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
939  }else if(IS_SUB_8X4(sub_mb_type)){
940  mv_cache[ 1 ][0]= mx;
941  mv_cache[ 1 ][1]= my;
942  }else if(IS_SUB_4X8(sub_mb_type)){
943  mv_cache[ 8 ][0]= mx;
944  mv_cache[ 8 ][1]= my;
945  }
946  mv_cache[ 0 ][0]= mx;
947  mv_cache[ 0 ][1]= my;
948  }
949  }else{
950  uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
951  p[0] = p[1]=
952  p[8] = p[9]= 0;
953  }
954  }
955  }
956  }else if(IS_DIRECT(mb_type)){
957  ff_h264_pred_direct_motion(h, sl, &mb_type);
958  dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
959  }else{
960  int list, mx, my, i;
961  //FIXME we should set ref_idx_l? to 0 if we use that later ...
962  if(IS_16X16(mb_type)){
963  for (list = 0; list < sl->list_count; list++) {
964  unsigned int val;
965  if(IS_DIR(mb_type, 0, list)){
966  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
967  if (rc == 1) {
968  val= 0;
969  } else if (rc == 2) {
970  val= get_bits1(&sl->gb)^1;
971  }else{
972  val= get_ue_golomb_31(&sl->gb);
973  if (val >= rc) {
974  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
975  return -1;
976  }
977  }
978  fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
979  }
980  }
981  for (list = 0; list < sl->list_count; list++) {
982  if(IS_DIR(mb_type, 0, list)){
983  pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
984  mx += get_se_golomb(&sl->gb);
985  my += get_se_golomb(&sl->gb);
986  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
987 
988  fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
989  }
990  }
991  }
992  else if(IS_16X8(mb_type)){
993  for (list = 0; list < sl->list_count; list++) {
994  for(i=0; i<2; i++){
995  unsigned int val;
996  if(IS_DIR(mb_type, i, list)){
997  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
998  if (rc == 1) {
999  val= 0;
1000  } else if (rc == 2) {
1001  val= get_bits1(&sl->gb)^1;
1002  }else{
1003  val= get_ue_golomb_31(&sl->gb);
1004  if (val >= rc) {
1005  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1006  return -1;
1007  }
1008  }
1009  }else
1010  val= LIST_NOT_USED&0xFF;
1011  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1012  }
1013  }
1014  for (list = 0; list < sl->list_count; list++) {
1015  for(i=0; i<2; i++){
1016  unsigned int val;
1017  if(IS_DIR(mb_type, i, list)){
1018  pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1019  mx += get_se_golomb(&sl->gb);
1020  my += get_se_golomb(&sl->gb);
1021  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1022 
1023  val= pack16to32(mx,my);
1024  }else
1025  val=0;
1026  fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1027  }
1028  }
1029  }else{
1030  av_assert2(IS_8X16(mb_type));
1031  for (list = 0; list < sl->list_count; list++) {
1032  for(i=0; i<2; i++){
1033  unsigned int val;
1034  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1035  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1036  if (rc == 1) {
1037  val= 0;
1038  } else if (rc == 2) {
1039  val= get_bits1(&sl->gb)^1;
1040  }else{
1041  val= get_ue_golomb_31(&sl->gb);
1042  if (val >= rc) {
1043  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1044  return -1;
1045  }
1046  }
1047  }else
1048  val= LIST_NOT_USED&0xFF;
1049  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1050  }
1051  }
1052  for (list = 0; list < sl->list_count; list++) {
1053  for(i=0; i<2; i++){
1054  unsigned int val;
1055  if(IS_DIR(mb_type, i, list)){
1056  pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1057  mx += get_se_golomb(&sl->gb);
1058  my += get_se_golomb(&sl->gb);
1059  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1060 
1061  val= pack16to32(mx,my);
1062  }else
1063  val=0;
1064  fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1065  }
1066  }
1067  }
1068  }
1069 
1070  if(IS_INTER(mb_type))
1071  write_back_motion(h, sl, mb_type);
1072 
1073  if(!IS_INTRA16x16(mb_type)){
1074  cbp= get_ue_golomb(&sl->gb);
1075 
1076  if(decode_chroma){
1077  if(cbp > 47){
1078  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1079  return -1;
1080  }
1081  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
1082  else cbp= golomb_to_inter_cbp [cbp];
1083  }else{
1084  if(cbp > 15){
1085  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1086  return -1;
1087  }
1088  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1089  else cbp= golomb_to_inter_cbp_gray[cbp];
1090  }
1091  } else {
1092  if (!decode_chroma && cbp>15) {
1093  av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1094  return AVERROR_INVALIDDATA;
1095  }
1096  }
1097 
1098  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1099  mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1100  }
1101  sl->cbp=
1102  h->cbp_table[mb_xy]= cbp;
1103  h->cur_pic.mb_type[mb_xy] = mb_type;
1104 
1105  if(cbp || IS_INTRA16x16(mb_type)){
1106  int i4x4, i8x8, chroma_idx;
1107  int dquant;
1108  int ret;
1109  GetBitContext *gb = &sl->gb;
1110  const uint8_t *scan, *scan8x8;
1111  const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1112 
1113  dquant= get_se_golomb(&sl->gb);
1114 
1115  sl->qscale += (unsigned)dquant;
1116 
1117  if (((unsigned)sl->qscale) > max_qp){
1118  if (sl->qscale < 0) sl->qscale += max_qp + 1;
1119  else sl->qscale -= max_qp+1;
1120  if (((unsigned)sl->qscale) > max_qp){
1121  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1122  sl->qscale = max_qp;
1123  return -1;
1124  }
1125  }
1126 
1127  sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
1128  sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
1129 
1130  if(IS_INTERLACED(mb_type)){
1131  scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1132  scan = sl->qscale ? h->field_scan : h->field_scan_q0;
1133  }else{
1134  scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1135  scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1136  }
1137 
1138  if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1139  return -1;
1140  }
1141  h->cbp_table[mb_xy] |= ret << 12;
1142  if (CHROMA444(h)) {
1143  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1144  return -1;
1145  }
1146  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1147  return -1;
1148  }
1149  } else {
1150  const int num_c8x8 = h->sps.chroma_format_idc;
1151 
1152  if(cbp&0x30){
1153  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1154  if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1155  CHROMA_DC_BLOCK_INDEX+chroma_idx,
1157  NULL, 4*num_c8x8) < 0) {
1158  return -1;
1159  }
1160  }
1161 
1162  if(cbp&0x20){
1163  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1164  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1165  int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1166  for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1167  for (i4x4 = 0; i4x4 < 4; i4x4++) {
1168  const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1169  if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1170  return -1;
1171  mb += 16 << pixel_shift;
1172  }
1173  }
1174  }
1175  }else{
1176  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1177  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1178  }
1179  }
1180  }else{
1181  fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1182  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1183  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1184  }
1185  h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1187 
1188  return 0;
1189 }
int chroma_format_idc
Definition: h264.h:178
uint8_t pred_mode
Definition: h264data.h:75
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:271
#define ff_tlog(ctx,...)
Definition: internal.h:54
#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:494
int mb_num
Definition: h264.h:622
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264.h:486
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:261
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:218
uint16_t * cbp_table
Definition: h264.h:596
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:394
#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:606
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
#define VLC_TYPE
Definition: get_bits.h:62
H264Context.
Definition: h264.h:517
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:1141
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:1081
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:460
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: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: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:491
#define MB_FIELD(sl)
Definition: h264.h:72
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264.h:583
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:368
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:1004
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:1053
static const IMbInfo i_mb_type_info[26]
Definition: h264data.h:79
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:213
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
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color, int update)
Definition: ffplay.c:785
int chroma_qp[2]
Definition: h264.h:373
#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:367
#define U(x)
Definition: vp56_arith.h:37
int frame_num
Definition: h264.h:651
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:594
#define RUN7_VLC_BITS
Definition: h264_cavlc.c:281
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:174
#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:1168
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:1069
#define CHROMA_DC_BLOCK_INDEX
Definition: h264.h:1005
static const struct endianess table[]
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264.h:400
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:577
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:1024
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define CLOSE_READER(name, gb)
Definition: get_bits.h:145
Libavcodec external API header.
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264.h:369
Definition: get_bits.h:64
int mb_skip_run
Definition: h264.h:431
static const uint8_t scan8[16 *3+3]
Definition: h264.h:1008
#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:495
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:397
#define IS_SUB_4X8(a)
Definition: mpegutils.h:88
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264.h:586
uint8_t field_scan8x8_cavlc[64]
Definition: h264.h:609
#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
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:1148
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:320
SPS sps
current sps
Definition: h264.h:576
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:288
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:195
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:561
int direct_8x8_inference_flag
Definition: h264.h:193
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:479
#define PART_NOT_AVAILABLE
Definition: h264.h:562
#define FF_ARRAY_ELEMS(a)
#define av_log2
Definition: intmath.h:100
#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:67
uint8_t zigzag_scan_q0[16]
Definition: h264.h:610
int intra16x16_pred_mode
Definition: h264.h:398
int mb_stride
Definition: h264.h:621
#define IS_INTERLACED(a)
Definition: mpegutils.h:79
AVCodecContext * avctx
Definition: h264.h:519
#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:134
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:462
void * buf
Definition: avisynth_c.h:553
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
int8_t * qscale_table
Definition: h264.h:314
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:305
#define IS_16X16(a)
Definition: mpegutils.h:82
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:298
#define CHROMA422(h)
Definition: h264.h:98
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264.h:481
int index
Definition: gxfenc.c:89
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264.h:584
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:534
#define GET_CACHE(name, gb)
Definition: get_bits.h:211
#define MB_TYPE_16x16
Definition: avcodec.h:1144
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:435
#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:252
uint8_t zigzag_scan[16]
Definition: h264.h:604
unsigned int list_count
Definition: h264.h:461
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:268
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:1145
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:227
static av_always_inline int get_chroma_qp(const H264Context *h, int t, int qscale)
Get the chroma qp.
Definition: h264.h:1045
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:612
int8_t ref_cache[2][5 *8]
Definition: h264.h:487
#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
static VLC run_vlc[6]
Definition: h264_cavlc.c:263
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
H264Picture cur_pic
Definition: h264.h:528
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:454
uint8_t field_scan8x8_cavlc_q0[64]
Definition: h264.h:615
const uint8_t * intra_pcm_ptr
Definition: h264.h:467
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:613
#define LIST_NOT_USED
Definition: h264.h:561
int mb_field_decoding_flag
Definition: h264.h:434
uint8_t(* non_zero_count)[48]
Definition: h264.h:559
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:364
uint8_t field_scan[16]
Definition: h264.h:607
Predicted.
Definition: avutil.h:267
#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