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 "mpegvideo.h"
34 #include "h264.h"
35 #include "h264data.h" // FIXME FIXME FIXME
36 #include "h264_mvpred.h"
37 #include "golomb.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(H264Context *h, int n){
288  const int index8= scan8[n];
289  const int left= h->non_zero_count_cache[index8 - 1];
290  const int top = h->non_zero_count_cache[index8 - 8];
291  int i= left + top;
292 
293  if(i<64) i= (i+1)>>1;
294 
295  tprintf(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
296 
297  return i&31;
298 }
299 
300 static av_cold void init_cavlc_level_tab(void){
301  int suffix_length;
302  unsigned int i;
303 
304  for(suffix_length=0; suffix_length<7; suffix_length++){
305  for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
306  int prefix= LEVEL_TAB_BITS - av_log2(2*i);
307 
308  if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
309  int level_code = (prefix << suffix_length) +
310  (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
311  int mask = -(level_code&1);
312  level_code = (((2 + level_code) >> 1) ^ mask) - mask;
313  cavlc_level_tab[suffix_length][i][0]= level_code;
314  cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
315  }else if(prefix + 1 <= LEVEL_TAB_BITS){
316  cavlc_level_tab[suffix_length][i][0]= prefix+100;
317  cavlc_level_tab[suffix_length][i][1]= prefix + 1;
318  }else{
319  cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
320  cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
321  }
322  }
323  }
324 }
325 
327  static int done = 0;
328 
329  if (!done) {
330  int i;
331  int offset;
332  done = 1;
333 
334  chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
335  chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
336  init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
337  &chroma_dc_coeff_token_len [0], 1, 1,
338  &chroma_dc_coeff_token_bits[0], 1, 1,
340 
341  chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
342  chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
343  init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
344  &chroma422_dc_coeff_token_len [0], 1, 1,
347 
348  offset = 0;
349  for(i=0; i<4; i++){
350  coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
351  coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
352  init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
353  &coeff_token_len [i][0], 1, 1,
354  &coeff_token_bits[i][0], 1, 1,
356  offset += coeff_token_vlc_tables_size[i];
357  }
358  /*
359  * This is a one time safety check to make sure that
360  * the packed static coeff_token_vlc table sizes
361  * were initialized correctly.
362  */
364 
365  for(i=0; i<3; i++){
366  chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
367  chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
368  init_vlc(&chroma_dc_total_zeros_vlc[i],
370  &chroma_dc_total_zeros_len [i][0], 1, 1,
371  &chroma_dc_total_zeros_bits[i][0], 1, 1,
373  }
374 
375  for(i=0; i<7; i++){
376  chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
377  chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
378  init_vlc(&chroma422_dc_total_zeros_vlc[i],
380  &chroma422_dc_total_zeros_len [i][0], 1, 1,
381  &chroma422_dc_total_zeros_bits[i][0], 1, 1,
383  }
384 
385  for(i=0; i<15; i++){
386  total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
387  total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
388  init_vlc(&total_zeros_vlc[i],
390  &total_zeros_len [i][0], 1, 1,
391  &total_zeros_bits[i][0], 1, 1,
393  }
394 
395  for(i=0; i<6; i++){
396  run_vlc[i].table = run_vlc_tables[i];
398  init_vlc(&run_vlc[i],
399  RUN_VLC_BITS, 7,
400  &run_len [i][0], 1, 1,
401  &run_bits[i][0], 1, 1,
403  }
404  run7_vlc.table = run7_vlc_table,
406  init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
407  &run_len [6][0], 1, 1,
408  &run_bits[6][0], 1, 1,
410 
412  }
413 }
414 
415 /**
416  *
417  */
418 static inline int get_level_prefix(GetBitContext *gb){
419  unsigned int buf;
420  int log;
421 
422  OPEN_READER(re, gb);
423  UPDATE_CACHE(re, gb);
424  buf=GET_CACHE(re, gb);
425 
426  log= 32 - av_log2(buf);
427 #ifdef TRACE
428  print_bin(buf>>(32-log), log);
429  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__);
430 #endif
431 
432  LAST_SKIP_BITS(re, gb, log);
433  CLOSE_READER(re, gb);
434 
435  return log-1;
436 }
437 
438 /**
439  * Decode a residual block.
440  * @param n block index
441  * @param scantable scantable
442  * @param max_coeff number of coefficients in the block
443  * @return <0 if an error occurred
444  */
445 static int decode_residual(H264Context *h, GetBitContext *gb, int16_t *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
446  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};
447  int level[16];
448  int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
449 
450  //FIXME put trailing_onex into the context
451 
452  if(max_coeff <= 8){
453  if (max_coeff == 4)
454  coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
455  else
456  coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
457  total_coeff= coeff_token>>2;
458  }else{
459  if(n >= LUMA_DC_BLOCK_INDEX){
460  total_coeff= pred_non_zero_count(h, (n - LUMA_DC_BLOCK_INDEX)*16);
461  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
462  total_coeff= coeff_token>>2;
463  }else{
464  total_coeff= pred_non_zero_count(h, n);
465  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
466  total_coeff= coeff_token>>2;
467  }
468  }
469  h->non_zero_count_cache[ scan8[n] ]= total_coeff;
470 
471  //FIXME set last_non_zero?
472 
473  if(total_coeff==0)
474  return 0;
475  if(total_coeff > (unsigned)max_coeff) {
476  av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", h->mb_x, h->mb_y, total_coeff);
477  return -1;
478  }
479 
480  trailing_ones= coeff_token&3;
481  tprintf(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
482  av_assert2(total_coeff<=16);
483 
484  i = show_bits(gb, 3);
485  skip_bits(gb, trailing_ones);
486  level[0] = 1-((i&4)>>1);
487  level[1] = 1-((i&2) );
488  level[2] = 1-((i&1)<<1);
489 
490  if(trailing_ones<total_coeff) {
491  int mask, prefix;
492  int suffix_length = total_coeff > 10 & trailing_ones < 3;
493  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
494  int level_code= cavlc_level_tab[suffix_length][bitsi][0];
495 
496  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
497  if(level_code >= 100){
498  prefix= level_code - 100;
499  if(prefix == LEVEL_TAB_BITS)
500  prefix += get_level_prefix(gb);
501 
502  //first coefficient has suffix_length equal to 0 or 1
503  if(prefix<14){ //FIXME try to build a large unified VLC table for all this
504  if(suffix_length)
505  level_code= (prefix<<1) + get_bits1(gb); //part
506  else
507  level_code= prefix; //part
508  }else if(prefix==14){
509  if(suffix_length)
510  level_code= (prefix<<1) + get_bits1(gb); //part
511  else
512  level_code= prefix + get_bits(gb, 4); //part
513  }else{
514  level_code= 30;
515  if(prefix>=16){
516  if(prefix > 25+3){
517  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
518  return -1;
519  }
520  level_code += (1<<(prefix-3))-4096;
521  }
522  level_code += get_bits(gb, prefix-3); //part
523  }
524 
525  if(trailing_ones < 3) level_code += 2;
526 
527  suffix_length = 2;
528  mask= -(level_code&1);
529  level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
530  }else{
531  level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
532 
533  suffix_length = 1 + (level_code + 3U > 6U);
534  level[trailing_ones]= level_code;
535  }
536 
537  //remaining coefficients have suffix_length > 0
538  for(i=trailing_ones+1;i<total_coeff;i++) {
539  static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
540  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
541  level_code= cavlc_level_tab[suffix_length][bitsi][0];
542 
543  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
544  if(level_code >= 100){
545  prefix= level_code - 100;
546  if(prefix == LEVEL_TAB_BITS){
547  prefix += get_level_prefix(gb);
548  }
549  if(prefix<15){
550  level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
551  }else{
552  level_code = 15<<suffix_length;
553  if (prefix>=16) {
554  if(prefix > 25+3){
555  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
556  return AVERROR_INVALIDDATA;
557  }
558  level_code += (1<<(prefix-3))-4096;
559  }
560  level_code += get_bits(gb, prefix-3);
561  }
562  mask= -(level_code&1);
563  level_code= (((2+level_code)>>1) ^ mask) - mask;
564  }
565  level[i]= level_code;
566  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
567  }
568  }
569 
570  if(total_coeff == max_coeff)
571  zeros_left=0;
572  else{
573  if (max_coeff <= 8) {
574  if (max_coeff == 4)
575  zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
577  else
578  zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
580  } else {
581  zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
582  }
583  }
584 
585 #define STORE_BLOCK(type) \
586  scantable += zeros_left + total_coeff - 1; \
587  if(n >= LUMA_DC_BLOCK_INDEX){ \
588  ((type*)block)[*scantable] = level[0]; \
589  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
590  if(zeros_left < 7) \
591  run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
592  else \
593  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
594  zeros_left -= run_before; \
595  scantable -= 1 + run_before; \
596  ((type*)block)[*scantable]= level[i]; \
597  } \
598  for(;i<total_coeff;i++) { \
599  scantable--; \
600  ((type*)block)[*scantable]= level[i]; \
601  } \
602  }else{ \
603  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
604  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
605  if(zeros_left < 7) \
606  run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
607  else \
608  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
609  zeros_left -= run_before; \
610  scantable -= 1 + run_before; \
611  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
612  } \
613  for(;i<total_coeff;i++) { \
614  scantable--; \
615  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
616  } \
617  }
618 
619  if (h->pixel_shift) {
621  } else {
622  STORE_BLOCK(int16_t)
623  }
624 
625  if(zeros_left<0){
626  av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
627  return -1;
628  }
629 
630  return 0;
631 }
632 
633 static av_always_inline int decode_luma_residual(H264Context *h, GetBitContext *gb, const uint8_t *scan, const uint8_t *scan8x8, int pixel_shift, int mb_type, int cbp, int p){
634  int i4x4, i8x8;
635  int qscale = p == 0 ? h->qscale : h->chroma_qp[p-1];
636  if(IS_INTRA16x16(mb_type)){
637  AV_ZERO128(h->mb_luma_dc[p]+0);
638  AV_ZERO128(h->mb_luma_dc[p]+8);
639  AV_ZERO128(h->mb_luma_dc[p]+16);
640  AV_ZERO128(h->mb_luma_dc[p]+24);
641  if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX+p, scan, NULL, 16) < 0){
642  return -1; //FIXME continue if partitioned and other return -1 too
643  }
644 
645  av_assert2((cbp&15) == 0 || (cbp&15) == 15);
646 
647  if(cbp&15){
648  for(i8x8=0; i8x8<4; i8x8++){
649  for(i4x4=0; i4x4<4; i4x4++){
650  const int index= i4x4 + 4*i8x8 + p*16;
651  if( decode_residual(h, h->intra_gb_ptr, h->mb + (16*index << pixel_shift),
652  index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
653  return -1;
654  }
655  }
656  }
657  return 0xf;
658  }else{
659  fill_rectangle(&h->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
660  return 0;
661  }
662  }else{
663  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
664  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
665  int new_cbp = 0;
666  for(i8x8=0; i8x8<4; i8x8++){
667  if(cbp & (1<<i8x8)){
668  if(IS_8x8DCT(mb_type)){
669  int16_t *buf = &h->mb[64*i8x8+256*p << pixel_shift];
670  uint8_t *nnz;
671  for(i4x4=0; i4x4<4; i4x4++){
672  const int index= i4x4 + 4*i8x8 + p*16;
673  if( decode_residual(h, gb, buf, index, scan8x8+16*i4x4,
674  h->dequant8_coeff[cqm][qscale], 16) < 0 )
675  return -1;
676  }
677  nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
678  nnz[0] += nnz[1] + nnz[8] + nnz[9];
679  new_cbp |= !!nnz[0] << i8x8;
680  }else{
681  for(i4x4=0; i4x4<4; i4x4++){
682  const int index= i4x4 + 4*i8x8 + p*16;
683  if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index,
684  scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
685  return -1;
686  }
687  new_cbp |= h->non_zero_count_cache[ scan8[index] ] << i8x8;
688  }
689  }
690  }else{
691  uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
692  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
693  }
694  }
695  return new_cbp;
696  }
697 }
698 
700  int mb_xy;
701  int partition_count;
702  unsigned int mb_type, cbp;
703  int dct8x8_allowed= h->pps.transform_8x8_mode;
704  int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
705  const int pixel_shift = h->pixel_shift;
706  unsigned local_ref_count[2];
707 
708  mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
709 
710  tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
711  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
712  down the code */
714  if(h->mb_skip_run==-1)
715  h->mb_skip_run= get_ue_golomb(&h->gb);
716 
717  if (h->mb_skip_run--) {
718  if(FRAME_MBAFF(h) && (h->mb_y&1) == 0){
719  if(h->mb_skip_run==0)
721  }
722  decode_mb_skip(h);
723  return 0;
724  }
725  }
726  if (FRAME_MBAFF(h)) {
727  if( (h->mb_y&1) == 0 )
729  }
730 
731  h->prev_mb_skipped= 0;
732 
733  mb_type= get_ue_golomb(&h->gb);
735  if(mb_type < 23){
736  partition_count= b_mb_type_info[mb_type].partition_count;
737  mb_type= b_mb_type_info[mb_type].type;
738  }else{
739  mb_type -= 23;
740  goto decode_intra_mb;
741  }
742  }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
743  if(mb_type < 5){
744  partition_count= p_mb_type_info[mb_type].partition_count;
745  mb_type= p_mb_type_info[mb_type].type;
746  }else{
747  mb_type -= 5;
748  goto decode_intra_mb;
749  }
750  }else{
752  if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
753  mb_type--;
754 decode_intra_mb:
755  if(mb_type > 25){
756  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(h->slice_type), h->mb_x, h->mb_y);
757  return -1;
758  }
759  partition_count=0;
760  cbp= i_mb_type_info[mb_type].cbp;
762  mb_type= i_mb_type_info[mb_type].type;
763  }
764 
765  if(MB_FIELD(h))
766  mb_type |= MB_TYPE_INTERLACED;
767 
768  h->slice_table[ mb_xy ]= h->slice_num;
769 
770  if(IS_INTRA_PCM(mb_type)){
771  const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
772  h->sps.bit_depth_luma;
773 
774  // We assume these blocks are very rare so we do not optimize it.
775  h->intra_pcm_ptr = align_get_bits(&h->gb);
776  skip_bits_long(&h->gb, mb_size);
777 
778  // In deblocking, the quantizer is 0
779  h->cur_pic.qscale_table[mb_xy] = 0;
780  // All coeffs are present
781  memset(h->non_zero_count[mb_xy], 16, 48);
782 
783  h->cur_pic.mb_type[mb_xy] = mb_type;
784  return 0;
785  }
786 
787  local_ref_count[0] = h->ref_count[0] << MB_MBAFF(h);
788  local_ref_count[1] = h->ref_count[1] << MB_MBAFF(h);
789 
790  fill_decode_neighbors(h, mb_type);
791  fill_decode_caches(h, mb_type);
792 
793  //mb_pred
794  if(IS_INTRA(mb_type)){
795  int pred_mode;
796 // init_top_left_availability(h);
797  if(IS_INTRA4x4(mb_type)){
798  int i;
799  int di = 1;
800  if(dct8x8_allowed && get_bits1(&h->gb)){
801  mb_type |= MB_TYPE_8x8DCT;
802  di = 4;
803  }
804 
805 // fill_intra4x4_pred_table(h);
806  for(i=0; i<16; i+=di){
807  int mode= pred_intra_mode(h, i);
808 
809  if(!get_bits1(&h->gb)){
810  const int rem_mode= get_bits(&h->gb, 3);
811  mode = rem_mode + (rem_mode >= mode);
812  }
813 
814  if(di==4)
815  fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
816  else
818  }
821  return -1;
822  }else{
824  if(h->intra16x16_pred_mode < 0)
825  return -1;
826  }
827  if(decode_chroma){
828  pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&h->gb), 1);
829  if(pred_mode < 0)
830  return -1;
831  h->chroma_pred_mode= pred_mode;
832  } else {
834  }
835  }else if(partition_count==4){
836  int i, j, sub_partition_count[4], list, ref[2][4];
837 
839  for(i=0; i<4; i++){
840  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
841  if(h->sub_mb_type[i] >=13){
842  av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], h->mb_x, h->mb_y);
843  return -1;
844  }
845  sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
846  h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
847  }
848  if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
849  ff_h264_pred_direct_motion(h, &mb_type);
850  h->ref_cache[0][scan8[4]] =
851  h->ref_cache[1][scan8[4]] =
852  h->ref_cache[0][scan8[12]] =
853  h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
854  }
855  }else{
856  av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
857  for(i=0; i<4; i++){
858  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
859  if(h->sub_mb_type[i] >=4){
860  av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], h->mb_x, h->mb_y);
861  return -1;
862  }
863  sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
864  h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
865  }
866  }
867 
868  for(list=0; list<h->list_count; list++){
869  int ref_count= IS_REF0(mb_type) ? 1 : local_ref_count[list];
870  for(i=0; i<4; i++){
871  if(IS_DIRECT(h->sub_mb_type[i])) continue;
872  if(IS_DIR(h->sub_mb_type[i], 0, list)){
873  unsigned int tmp;
874  if(ref_count == 1){
875  tmp= 0;
876  }else if(ref_count == 2){
877  tmp= get_bits1(&h->gb)^1;
878  }else{
879  tmp= get_ue_golomb_31(&h->gb);
880  if(tmp>=ref_count){
881  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
882  return -1;
883  }
884  }
885  ref[list][i]= tmp;
886  }else{
887  //FIXME
888  ref[list][i] = -1;
889  }
890  }
891  }
892 
893  if(dct8x8_allowed)
894  dct8x8_allowed = get_dct8x8_allowed(h);
895 
896  for(list=0; list<h->list_count; list++){
897  for(i=0; i<4; i++){
898  if(IS_DIRECT(h->sub_mb_type[i])) {
899  h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
900  continue;
901  }
902  h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
903  h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
904 
905  if(IS_DIR(h->sub_mb_type[i], 0, list)){
906  const int sub_mb_type= h->sub_mb_type[i];
907  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
908  for(j=0; j<sub_partition_count[i]; j++){
909  int mx, my;
910  const int index= 4*i + block_width*j;
911  int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
912  pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
913  mx += get_se_golomb(&h->gb);
914  my += get_se_golomb(&h->gb);
915  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
916 
917  if(IS_SUB_8X8(sub_mb_type)){
918  mv_cache[ 1 ][0]=
919  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
920  mv_cache[ 1 ][1]=
921  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
922  }else if(IS_SUB_8X4(sub_mb_type)){
923  mv_cache[ 1 ][0]= mx;
924  mv_cache[ 1 ][1]= my;
925  }else if(IS_SUB_4X8(sub_mb_type)){
926  mv_cache[ 8 ][0]= mx;
927  mv_cache[ 8 ][1]= my;
928  }
929  mv_cache[ 0 ][0]= mx;
930  mv_cache[ 0 ][1]= my;
931  }
932  }else{
933  uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
934  p[0] = p[1]=
935  p[8] = p[9]= 0;
936  }
937  }
938  }
939  }else if(IS_DIRECT(mb_type)){
940  ff_h264_pred_direct_motion(h, &mb_type);
941  dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
942  }else{
943  int list, mx, my, i;
944  //FIXME we should set ref_idx_l? to 0 if we use that later ...
945  if(IS_16X16(mb_type)){
946  for(list=0; list<h->list_count; list++){
947  unsigned int val;
948  if(IS_DIR(mb_type, 0, list)){
949  if(local_ref_count[list]==1){
950  val= 0;
951  }else if(local_ref_count[list]==2){
952  val= get_bits1(&h->gb)^1;
953  }else{
954  val= get_ue_golomb_31(&h->gb);
955  if(val >= local_ref_count[list]){
956  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
957  return -1;
958  }
959  }
960  fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
961  }
962  }
963  for(list=0; list<h->list_count; list++){
964  if(IS_DIR(mb_type, 0, list)){
965  pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
966  mx += get_se_golomb(&h->gb);
967  my += get_se_golomb(&h->gb);
968  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
969 
970  fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
971  }
972  }
973  }
974  else if(IS_16X8(mb_type)){
975  for(list=0; list<h->list_count; list++){
976  for(i=0; i<2; i++){
977  unsigned int val;
978  if(IS_DIR(mb_type, i, list)){
979  if(local_ref_count[list] == 1){
980  val= 0;
981  }else if(local_ref_count[list] == 2){
982  val= get_bits1(&h->gb)^1;
983  }else{
984  val= get_ue_golomb_31(&h->gb);
985  if(val >= local_ref_count[list]){
986  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
987  return -1;
988  }
989  }
990  }else
991  val= LIST_NOT_USED&0xFF;
992  fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
993  }
994  }
995  for(list=0; list<h->list_count; list++){
996  for(i=0; i<2; i++){
997  unsigned int val;
998  if(IS_DIR(mb_type, i, list)){
999  pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1000  mx += get_se_golomb(&h->gb);
1001  my += get_se_golomb(&h->gb);
1002  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1003 
1004  val= pack16to32(mx,my);
1005  }else
1006  val=0;
1007  fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1008  }
1009  }
1010  }else{
1011  av_assert2(IS_8X16(mb_type));
1012  for(list=0; list<h->list_count; list++){
1013  for(i=0; i<2; i++){
1014  unsigned int val;
1015  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1016  if(local_ref_count[list]==1){
1017  val= 0;
1018  }else if(local_ref_count[list]==2){
1019  val= get_bits1(&h->gb)^1;
1020  }else{
1021  val= get_ue_golomb_31(&h->gb);
1022  if(val >= local_ref_count[list]){
1023  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1024  return -1;
1025  }
1026  }
1027  }else
1028  val= LIST_NOT_USED&0xFF;
1029  fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1030  }
1031  }
1032  for(list=0; list<h->list_count; list++){
1033  for(i=0; i<2; i++){
1034  unsigned int val;
1035  if(IS_DIR(mb_type, i, list)){
1036  pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1037  mx += get_se_golomb(&h->gb);
1038  my += get_se_golomb(&h->gb);
1039  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1040 
1041  val= pack16to32(mx,my);
1042  }else
1043  val=0;
1044  fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1045  }
1046  }
1047  }
1048  }
1049 
1050  if(IS_INTER(mb_type))
1051  write_back_motion(h, mb_type);
1052 
1053  if(!IS_INTRA16x16(mb_type)){
1054  cbp= get_ue_golomb(&h->gb);
1055 
1056  if(decode_chroma){
1057  if(cbp > 47){
1058  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
1059  return -1;
1060  }
1061  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
1062  else cbp= golomb_to_inter_cbp [cbp];
1063  }else{
1064  if(cbp > 15){
1065  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
1066  return -1;
1067  }
1068  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1069  else cbp= golomb_to_inter_cbp_gray[cbp];
1070  }
1071  } else {
1072  if (!decode_chroma && cbp>15) {
1073  av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1074  return AVERROR_INVALIDDATA;
1075  }
1076  }
1077 
1078  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1079  mb_type |= MB_TYPE_8x8DCT*get_bits1(&h->gb);
1080  }
1081  h->cbp=
1082  h->cbp_table[mb_xy]= cbp;
1083  h->cur_pic.mb_type[mb_xy] = mb_type;
1084 
1085  if(cbp || IS_INTRA16x16(mb_type)){
1086  int i4x4, i8x8, chroma_idx;
1087  int dquant;
1088  int ret;
1089  GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
1090  const uint8_t *scan, *scan8x8;
1091  const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1092 
1093  if(IS_INTERLACED(mb_type)){
1094  scan8x8= h->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1095  scan= h->qscale ? h->field_scan : h->field_scan_q0;
1096  }else{
1097  scan8x8= h->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1098  scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1099  }
1100 
1101  dquant= get_se_golomb(&h->gb);
1102 
1103  h->qscale += dquant;
1104 
1105  if(((unsigned)h->qscale) > max_qp){
1106  if(h->qscale<0) h->qscale+= max_qp+1;
1107  else h->qscale-= max_qp+1;
1108  if(((unsigned)h->qscale) > max_qp){
1109  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, h->mb_x, h->mb_y);
1110  return -1;
1111  }
1112  }
1113 
1114  h->chroma_qp[0]= get_chroma_qp(h, 0, h->qscale);
1115  h->chroma_qp[1]= get_chroma_qp(h, 1, h->qscale);
1116 
1117  if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
1118  return -1;
1119  }
1120  h->cbp_table[mb_xy] |= ret << 12;
1121  if (CHROMA444(h)) {
1122  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
1123  return -1;
1124  }
1125  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
1126  return -1;
1127  }
1128  } else {
1129  const int num_c8x8 = h->sps.chroma_format_idc;
1130 
1131  if(cbp&0x30){
1132  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1133  if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1134  CHROMA_DC_BLOCK_INDEX+chroma_idx,
1136  NULL, 4*num_c8x8) < 0) {
1137  return -1;
1138  }
1139  }
1140 
1141  if(cbp&0x20){
1142  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1143  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1144  int16_t *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1145  for (i8x8=0; i8x8<num_c8x8; i8x8++) {
1146  for (i4x4=0; i4x4<4; i4x4++) {
1147  const int index= 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1148  if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
1149  return -1;
1150  mb += 16<<pixel_shift;
1151  }
1152  }
1153  }
1154  }else{
1155  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1156  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1157  }
1158  }
1159  }else{
1160  fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1161  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1162  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1163  }
1164  h->cur_pic.qscale_table[mb_xy] = h->qscale;
1166 
1167  return 0;
1168 }
int chroma_format_idc
Definition: h264.h:154
uint8_t pred_mode
Definition: h264data.h:155
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:271
static av_always_inline int get_dct8x8_allowed(H264Context *h)
Definition: h264.h:966
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define DC_128_PRED8x8
Definition: h264pred.h:76
GetBitContext gb
Definition: h264.h:268
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:278
GetBitContext * intra_gb_ptr
Definition: h264.h:419
FIXME Range Coding of cr are ref
Definition: snow.txt:367
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:175
#define CHROMA444(h)
Definition: h264.h:92
int cbp
Definition: h264.h:435
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
static const uint8_t chroma422_dc_scan[8]
Definition: h264data.h:88
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:198
uint16_t * cbp_table
Definition: h264.h:434
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:300
int mb_y
Definition: h264.h:461
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264.h:448
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
#define VLC_TYPE
Definition: get_bits.h:61
mpegvideo header.
#define FF_ARRAY_ELEMS(a)
H264Context.
Definition: h264.h:260
static const uint8_t chroma422_dc_coeff_token_len[4 *9]
Definition: h264_cavlc.c:65
static const int chroma422_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:261
#define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:279
#define IS_INTRA4x4(a)
Definition: mpegvideo.h:135
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2]
Definition: h264_cavlc.c:256
static VLC chroma422_dc_coeff_token_vlc
Definition: h264_cavlc.c:247
static av_always_inline void write_back_motion(H264Context *h, int mb_type)
Definition: h264.h:941
#define IS_REF0(a)
Definition: h264.h:98
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 void fill_decode_caches(H264Context *h, int mb_type)
Definition: h264_mvpred.h:438
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264.h:375
static const uint8_t chroma422_dc_total_zeros_len[7][8]
Definition: h264_cavlc.c:199
#define IS_INTRA_PCM(a)
Definition: mpegvideo.h:141
uint8_t partition_count
Definition: h264data.h:190
static av_always_inline uint32_t pack16to32(int a, int b)
Definition: h264.h:828
int mb_skip_run
Definition: h264.h:464
static const PMbInfo b_sub_mb_type_info[13]
Definition: h264data.h:234
static av_always_inline int pred_intra_mode(H264Context *h, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264.h:857
Switching Intra.
Definition: avutil.h:220
#define IS_DIR(a, part, list)
Definition: mpegvideo.h:155
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:219
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:99
static const uint8_t golomb_to_intra4x4_cbp_gray[16]
Definition: h264_cavlc.c:45
#define IS_INTER(a)
Definition: mpegvideo.h:139
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264.h:369
static const uint8_t coeff_token_bits[4][4 *17]
Definition: h264_cavlc.c:120
uint8_t
#define av_cold
Definition: attributes.h:78
#define mb
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
#define IS_8X16(a)
Definition: mpegvideo.h:147
mode
Definition: f_perms.c:27
static const int chroma_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:257
int mb_xy
Definition: h264.h:468
#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:275
#define LUMA_DC_BLOCK_INDEX
Definition: h264.h:808
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:408
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
int mb_x
Definition: h264.h:461
static const IMbInfo i_mb_type_info[26]
Definition: h264data.h:159
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:193
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.
static const uint8_t total_zeros_len[16][16]
Definition: h264_cavlc.c:151
static void av_unused decode_mb_skip(H264Context *h)
decodes a P_SKIP or B_SKIP macroblock
Definition: h264_mvpred.h:796
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color, int update)
Definition: ffplay.c:489
#define IS_INTERLACED(a)
Definition: mpegvideo.h:142
uint16_t type
Definition: h264data.h:189
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
#define U(x)
int frame_num
Definition: h264.h:507
#define RUN7_VLC_BITS
Definition: h264_cavlc.c:281
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:160
int ff_h264_check_intra_pred_mode(H264Context *h, 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:473
static int get_ue_golomb(GetBitContext *gb)
read unsigned exp golomb code.
Definition: golomb.h:53
static const uint16_t mask[17]
Definition: lzw.c:37
#define CHROMA_DC_BLOCK_INDEX
Definition: h264.h:809
static av_always_inline int get_chroma_qp(H264Context *h, int t, int qscale)
Get the chroma qp.
Definition: h264.h:849
GetBitContext * inter_gb_ptr
Definition: h264.h:420
static const struct endianess table[]
#define IS_SUB_8X4(a)
Definition: mpegvideo.h:150
#define MB_FIELD(h)
Definition: h264.h:65
int mb_field_decoding_flag
Definition: h264.h:380
static const uint8_t chroma_dc_total_zeros_bits[3][4]
Definition: h264_cavlc.c:193
PPS pps
current pps
Definition: h264.h:365
static av_always_inline void pred_8x16_motion(H264Context *const h, int n, int list, int ref, int *const mx, int *const my)
Get the directionally predicted 8x16 MV.
Definition: h264_mvpred.h:196
simple assert() macros that are a bit more flexible than ISO C assert().
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
#define IS_INTRA(a)
Definition: mpegvideo.h:138
static VLC chroma_dc_coeff_token_vlc
Definition: h264_cavlc.c:243
static const uint8_t offset[127][2]
Definition: vf_spp.c:70
#define CLOSE_READER(name, gb)
Definition: get_bits.h:140
external API header
Definition: get_bits.h:63
static const uint8_t scan8[16 *3+3]
Definition: h264.h:812
static av_always_inline void pred_motion(H264Context *const h, int n, int part_width, int list, int ref, int *const mx, int *const my)
Get the predicted MV.
Definition: h264_mvpred.h:93
int chroma_pred_mode
Definition: h264.h:300
#define COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:276
void ff_h264_pred_direct_motion(H264Context *const h, int *mb_type)
Definition: h264_direct.c:623
static const int chroma_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:245
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:169
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264.h:373
uint8_t field_scan8x8_cavlc[64]
Definition: h264.h:451
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:260
ret
Definition: avfilter.c:821
#define MB_TYPE_INTERLACED
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
static av_always_inline int decode_luma_residual(H264Context *h, GetBitContext *gb, const uint8_t *scan, const uint8_t *scan8x8, int pixel_shift, int mb_type, int cbp, int p)
Definition: h264_cavlc.c:633
SPS sps
current sps
Definition: h264.h:360
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:255
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:181
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:524
int ff_h264_decode_mb_cavlc(H264Context *h)
Decode a macroblock.
Definition: h264_cavlc.c:699
int direct_8x8_inference_flag
Definition: h264.h:169
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264.h:316
int slice_type
Definition: h264.h:374
FIXME Range Coding of cr are level
Definition: snow.txt:367
static const uint8_t golomb_to_intra4x4_cbp[48]
Definition: h264data.h:43
#define MB_MBAFF(h)
Definition: h264.h:64
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:443
static av_always_inline void write_back_non_zero_count(H264Context *h)
Definition: h264.h:883
#define PART_NOT_AVAILABLE
Definition: h264.h:339
unsigned int list_count
Definition: h264.h:409
#define IS_16X8(a)
Definition: mpegvideo.h:146
static int decode_residual(H264Context *h, 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:445
static const uint8_t chroma_dc_coeff_token_len[4 *5]
Definition: h264_cavlc.c:49
int table_allocated
Definition: get_bits.h:66
Picture cur_pic
Definition: h264.h:274
uint8_t zigzag_scan_q0[16]
Definition: h264.h:452
NULL
Definition: eval.c:55
int mb_stride
Definition: h264.h:466
AVCodecContext * avctx
Definition: h264.h:261
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
int ff_h264_check_intra4x4_pred_mode(H264Context *h)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264.c:426
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
#define OPEN_READER(name, gb)
Definition: get_bits.h:126
static void fill_decode_neighbors(H264Context *h, int mb_type)
Definition: h264_mvpred.h:349
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:426
void * buf
Definition: avisynth_c.h:594
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
int prev_mb_skipped
Definition: h264.h:296
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:273
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:265
#define CHROMA422(h)
Definition: h264.h:91
int index
Definition: gxfenc.c:89
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264.h:370
synthesis window for stochastic i
static const uint8_t chroma_dc_scan[4]
Definition: h264data.h:83
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:326
int pixel_shift
0 for 8-bit H264, 1 for high-bit-depth H264
Definition: h264.h:276
#define GET_CACHE(name, gb)
Definition: get_bits.h:191
#define MB_TYPE_16x16
static const int total_zeros_vlc_tables_size
Definition: h264_cavlc.c:253
static const uint8_t chroma422_dc_total_zeros_bits[7][8]
Definition: h264_cavlc.c:209
static const PMbInfo b_mb_type_info[23]
Definition: h264data.h:208
static const int coeff_token_vlc_tables_size[4]
Definition: h264_cavlc.c:241
static int pred_non_zero_count(H264Context *h, int n)
Get the predicted number of non-zero coefficients.
Definition: h264_cavlc.c:287
static const int run7_vlc_table_size
Definition: h264_cavlc.c:269
static const PMbInfo p_mb_type_info[5]
Definition: h264data.h:193
static const PMbInfo p_sub_mb_type_info[4]
Definition: h264data.h:201
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264.h:228
uint8_t zigzag_scan[16]
Definition: h264.h:446
#define IS_INTRA16x16(a)
Definition: mpegvideo.h:136
#define AV_ZERO128(d)
Definition: intreadwrite.h:614
int8_t * qscale_table
Definition: mpegvideo.h:102
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2]
Definition: h264_cavlc.c:248
int qscale
Definition: h264.h:286
#define tprintf(p,...)
Definition: get_bits.h:628
uint8_t cbp
Definition: h264data.h:156
common internal api header.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:162
const uint8_t * intra_pcm_ptr
Definition: h264.h:422
H.264 / AVC / MPEG4 part10 motion vector predicion.
Bi-dir predicted.
Definition: avutil.h:218
int chroma_qp[2]
Definition: h264.h:277
static const uint8_t golomb_to_inter_cbp[48]
Definition: h264data.h:49
#define MB_TYPE_16x8
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:203
static av_always_inline void write_back_intra_pred_mode(H264Context *h)
Definition: h264.h:872
static av_always_inline void pred_16x8_motion(H264Context *const h, int n, int list, int ref, int *const mx, int *const my)
Get the directionally predicted 16x8 MV.
Definition: h264_mvpred.h:156
int intra16x16_pred_mode
Definition: h264.h:301
#define IS_SUB_4X8(a)
Definition: mpegvideo.h:151
#define CHROMA_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:274
static VLC run7_vlc
Definition: h264_cavlc.c:267
float re
Definition: fft-test.c:64
uint8_t zigzag_scan8x8_cavlc_q0[64]
Definition: h264.h:454
#define FRAME_MBAFF(h)
Definition: h264.h:66
#define IS_SUB_8X8(a)
Definition: mpegvideo.h:149
const uint16_t ff_h264_mb_sizes[4]
Definition: h264.c:54
static const int run_vlc_tables_size
Definition: h264_cavlc.c:265
#define IS_DIRECT(a)
Definition: mpegvideo.h:143
#define av_log2
Definition: intmath.h:89
static VLC run_vlc[6]
Definition: h264_cavlc.c:263
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
static const uint8_t chroma_dc_total_zeros_len[3][4]
Definition: h264_cavlc.c:187
static int get_level_prefix(GetBitContext *gb)
Definition: h264_cavlc.c:418
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:418
#define IS_16X16(a)
Definition: mpegvideo.h:145
uint8_t field_scan8x8_cavlc_q0[64]
Definition: h264.h:457
uint16_t type
Definition: h264data.h:154
uint32_t * mb_type
Definition: mpegvideo.h:108
#define av_always_inline
Definition: attributes.h:41
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:455
#define LIST_NOT_USED
Definition: h264.h:338
uint8_t(* non_zero_count)[48]
Definition: h264.h:331
exp golomb vlc stuff
int slice_num
Definition: h264.h:372
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:244
uint8_t field_scan[16]
Definition: h264.h:449
Predicted.
Definition: avutil.h:217
#define MB_TYPE_8x8DCT
Definition: h264.h:97
#define STORE_BLOCK(type)
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264.h:381