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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #define CABAC 0
29 
30 #include "internal.h"
31 #include "avcodec.h"
32 #include "mpegvideo.h"
33 #include "h264.h"
34 #include "h264data.h" // FIXME FIXME FIXME
35 #include "h264_mvpred.h"
36 #include "golomb.h"
37 
38 //#undef NDEBUG
39 #include <assert.h>
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 
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  */
363  assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
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 
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 
445 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *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  assert(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 + get_bits(gb, prefix-3); //part
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  }
523 
524  if(trailing_ones < 3) level_code += 2;
525 
526  suffix_length = 2;
527  mask= -(level_code&1);
528  level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
529  }else{
530  level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
531 
532  suffix_length = 1 + (level_code + 3U > 6U);
533  level[trailing_ones]= level_code;
534  }
535 
536  //remaining coefficients have suffix_length > 0
537  for(i=trailing_ones+1;i<total_coeff;i++) {
538  static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
539  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
540  level_code= cavlc_level_tab[suffix_length][bitsi][0];
541 
542  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
543  if(level_code >= 100){
544  prefix= level_code - 100;
545  if(prefix == LEVEL_TAB_BITS){
546  prefix += get_level_prefix(gb);
547  }
548  if(prefix<15){
549  level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
550  }else{
551  level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
552  if(prefix>=16)
553  level_code += (1<<(prefix-3))-4096;
554  }
555  mask= -(level_code&1);
556  level_code= (((2+level_code)>>1) ^ mask) - mask;
557  }
558  level[i]= level_code;
559  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
560  }
561  }
562 
563  if(total_coeff == max_coeff)
564  zeros_left=0;
565  else{
566  if (max_coeff <= 8) {
567  if (max_coeff == 4)
568  zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff - 1].table,
570  else
571  zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
573  } else {
574  zeros_left= get_vlc2(gb, total_zeros_vlc[total_coeff - 1].table, TOTAL_ZEROS_VLC_BITS, 1);
575  }
576  }
577 
578 #define STORE_BLOCK(type) \
579  scantable += zeros_left + total_coeff - 1; \
580  if(n >= LUMA_DC_BLOCK_INDEX){ \
581  ((type*)block)[*scantable] = level[0]; \
582  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
583  if(zeros_left < 7) \
584  run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
585  else \
586  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
587  zeros_left -= run_before; \
588  scantable -= 1 + run_before; \
589  ((type*)block)[*scantable]= level[i]; \
590  } \
591  for(;i<total_coeff;i++) { \
592  scantable--; \
593  ((type*)block)[*scantable]= level[i]; \
594  } \
595  }else{ \
596  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
597  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
598  if(zeros_left < 7) \
599  run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
600  else \
601  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
602  zeros_left -= run_before; \
603  scantable -= 1 + run_before; \
604  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
605  } \
606  for(;i<total_coeff;i++) { \
607  scantable--; \
608  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
609  } \
610  }
611 
612  if (zeros_left < 0) {
614  "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
615  return AVERROR_INVALIDDATA;
616  }
617 
618  if (h->pixel_shift) {
620  } else {
621  STORE_BLOCK(int16_t)
622  }
623 
624  return 0;
625 }
626 
627 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){
628  int i4x4, i8x8;
629  int qscale = p == 0 ? h->qscale : h->chroma_qp[p-1];
630  if(IS_INTRA16x16(mb_type)){
631  AV_ZERO128(h->mb_luma_dc[p]+0);
632  AV_ZERO128(h->mb_luma_dc[p]+8);
633  AV_ZERO128(h->mb_luma_dc[p]+16);
634  AV_ZERO128(h->mb_luma_dc[p]+24);
635  if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX+p, scan, NULL, 16) < 0){
636  return -1; //FIXME continue if partitioned and other return -1 too
637  }
638 
639  assert((cbp&15) == 0 || (cbp&15) == 15);
640 
641  if(cbp&15){
642  for(i8x8=0; i8x8<4; i8x8++){
643  for(i4x4=0; i4x4<4; i4x4++){
644  const int index= i4x4 + 4*i8x8 + p*16;
645  if( decode_residual(h, h->intra_gb_ptr, h->mb + (16*index << pixel_shift),
646  index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
647  return -1;
648  }
649  }
650  }
651  return 0xf;
652  }else{
653  fill_rectangle(&h->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
654  return 0;
655  }
656  }else{
657  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
658  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
659  int new_cbp = 0;
660  for(i8x8=0; i8x8<4; i8x8++){
661  if(cbp & (1<<i8x8)){
662  if(IS_8x8DCT(mb_type)){
663  DCTELEM *buf = &h->mb[64*i8x8+256*p << pixel_shift];
664  uint8_t *nnz;
665  for(i4x4=0; i4x4<4; i4x4++){
666  const int index= i4x4 + 4*i8x8 + p*16;
667  if( decode_residual(h, gb, buf, index, scan8x8+16*i4x4,
668  h->dequant8_coeff[cqm][qscale], 16) < 0 )
669  return -1;
670  }
671  nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
672  nnz[0] += nnz[1] + nnz[8] + nnz[9];
673  new_cbp |= !!nnz[0] << i8x8;
674  }else{
675  for(i4x4=0; i4x4<4; i4x4++){
676  const int index= i4x4 + 4*i8x8 + p*16;
677  if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index,
678  scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
679  return -1;
680  }
681  new_cbp |= h->non_zero_count_cache[ scan8[index] ] << i8x8;
682  }
683  }
684  }else{
685  uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
686  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
687  }
688  }
689  return new_cbp;
690  }
691 }
692 
694  int mb_xy;
695  int partition_count;
696  unsigned int mb_type, cbp;
697  int dct8x8_allowed= h->pps.transform_8x8_mode;
698  int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
699  const int pixel_shift = h->pixel_shift;
700 
701  mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
702 
703  tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
704  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
705  down the code */
707  if(h->mb_skip_run==-1)
708  h->mb_skip_run= get_ue_golomb(&h->gb);
709 
710  if (h->mb_skip_run--) {
711  if(FRAME_MBAFF && (h->mb_y&1) == 0){
712  if(h->mb_skip_run==0)
714  }
715  decode_mb_skip(h);
716  return 0;
717  }
718  }
719  if(FRAME_MBAFF){
720  if( (h->mb_y&1) == 0 )
722  }
723 
724  h->prev_mb_skipped= 0;
725 
726  mb_type= get_ue_golomb(&h->gb);
728  if(mb_type < 23){
729  partition_count= b_mb_type_info[mb_type].partition_count;
730  mb_type= b_mb_type_info[mb_type].type;
731  }else{
732  mb_type -= 23;
733  goto decode_intra_mb;
734  }
735  }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
736  if(mb_type < 5){
737  partition_count= p_mb_type_info[mb_type].partition_count;
738  mb_type= p_mb_type_info[mb_type].type;
739  }else{
740  mb_type -= 5;
741  goto decode_intra_mb;
742  }
743  }else{
744  assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
745  if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
746  mb_type--;
747 decode_intra_mb:
748  if(mb_type > 25){
749  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);
750  return -1;
751  }
752  partition_count=0;
753  cbp= i_mb_type_info[mb_type].cbp;
755  mb_type= i_mb_type_info[mb_type].type;
756  }
757 
758  if(MB_FIELD)
759  mb_type |= MB_TYPE_INTERLACED;
760 
761  h->slice_table[ mb_xy ]= h->slice_num;
762 
763  if(IS_INTRA_PCM(mb_type)){
764  unsigned int x;
765  const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
766  h->sps.bit_depth_luma >> 3;
767 
768  // We assume these blocks are very rare so we do not optimize it.
769  align_get_bits(&h->gb);
770  if (get_bits_left(&h->gb) < mb_size) {
771  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
772  return AVERROR_INVALIDDATA;
773  }
774 
775  // The pixels are stored in the same order as levels in h->mb array.
776  for(x=0; x < mb_size; x++){
777  ((uint8_t*)h->mb)[x]= get_bits(&h->gb, 8);
778  }
779 
780  // In deblocking, the quantizer is 0
781  h->cur_pic.f.qscale_table[mb_xy] = 0;
782  // All coeffs are present
783  memset(h->non_zero_count[mb_xy], 16, 48);
784 
785  h->cur_pic.f.mb_type[mb_xy] = mb_type;
786  return 0;
787  }
788 
789  fill_decode_neighbors(h, mb_type);
790  fill_decode_caches(h, mb_type);
791 
792  //mb_pred
793  if(IS_INTRA(mb_type)){
794  int pred_mode;
795 // init_top_left_availability(h);
796  if(IS_INTRA4x4(mb_type)){
797  int i;
798  int di = 1;
799  if(dct8x8_allowed && get_bits1(&h->gb)){
800  mb_type |= MB_TYPE_8x8DCT;
801  di = 4;
802  }
803 
804 // fill_intra4x4_pred_table(h);
805  for(i=0; i<16; i+=di){
806  int mode= pred_intra_mode(h, i);
807 
808  if(!get_bits1(&h->gb)){
809  const int rem_mode= get_bits(&h->gb, 3);
810  mode = rem_mode + (rem_mode >= mode);
811  }
812 
813  if(di==4)
814  fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
815  else
816  h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
817  }
820  return -1;
821  }else{
823  if(h->intra16x16_pred_mode < 0)
824  return -1;
825  }
826  if(decode_chroma){
827  pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&h->gb), 1);
828  if(pred_mode < 0)
829  return -1;
830  h->chroma_pred_mode= pred_mode;
831  } else {
833  }
834  }else if(partition_count==4){
835  int i, j, sub_partition_count[4], list, ref[2][4];
836 
838  for(i=0; i<4; i++){
839  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
840  if(h->sub_mb_type[i] >=13){
841  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);
842  return -1;
843  }
844  sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
846  }
847  if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
848  ff_h264_pred_direct_motion(h, &mb_type);
849  h->ref_cache[0][scan8[4]] =
850  h->ref_cache[1][scan8[4]] =
851  h->ref_cache[0][scan8[12]] =
852  h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
853  }
854  }else{
855  assert(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
856  for(i=0; i<4; i++){
857  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
858  if(h->sub_mb_type[i] >=4){
859  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);
860  return -1;
861  }
862  sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
864  }
865  }
866 
867  for(list=0; list<h->list_count; list++){
868  int ref_count = IS_REF0(mb_type) ? 1 : h->ref_count[list] << MB_MBAFF;
869  for(i=0; i<4; i++){
870  if(IS_DIRECT(h->sub_mb_type[i])) continue;
871  if(IS_DIR(h->sub_mb_type[i], 0, list)){
872  unsigned int tmp;
873  if(ref_count == 1){
874  tmp= 0;
875  }else if(ref_count == 2){
876  tmp= get_bits1(&h->gb)^1;
877  }else{
878  tmp= get_ue_golomb_31(&h->gb);
879  if(tmp>=ref_count){
880  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
881  return -1;
882  }
883  }
884  ref[list][i]= tmp;
885  }else{
886  //FIXME
887  ref[list][i] = -1;
888  }
889  }
890  }
891 
892  if(dct8x8_allowed)
893  dct8x8_allowed = get_dct8x8_allowed(h);
894 
895  for(list=0; list<h->list_count; list++){
896  for(i=0; i<4; i++){
897  if(IS_DIRECT(h->sub_mb_type[i])) {
898  h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
899  continue;
900  }
901  h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
902  h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
903 
904  if(IS_DIR(h->sub_mb_type[i], 0, list)){
905  const int sub_mb_type= h->sub_mb_type[i];
906  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
907  for(j=0; j<sub_partition_count[i]; j++){
908  int mx, my;
909  const int index= 4*i + block_width*j;
910  int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
911  pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
912  mx += get_se_golomb(&h->gb);
913  my += get_se_golomb(&h->gb);
914  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
915 
916  if(IS_SUB_8X8(sub_mb_type)){
917  mv_cache[ 1 ][0]=
918  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
919  mv_cache[ 1 ][1]=
920  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
921  }else if(IS_SUB_8X4(sub_mb_type)){
922  mv_cache[ 1 ][0]= mx;
923  mv_cache[ 1 ][1]= my;
924  }else if(IS_SUB_4X8(sub_mb_type)){
925  mv_cache[ 8 ][0]= mx;
926  mv_cache[ 8 ][1]= my;
927  }
928  mv_cache[ 0 ][0]= mx;
929  mv_cache[ 0 ][1]= my;
930  }
931  }else{
932  uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
933  p[0] = p[1]=
934  p[8] = p[9]= 0;
935  }
936  }
937  }
938  }else if(IS_DIRECT(mb_type)){
939  ff_h264_pred_direct_motion(h, &mb_type);
940  dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
941  }else{
942  int list, mx, my, i;
943  //FIXME we should set ref_idx_l? to 0 if we use that later ...
944  if(IS_16X16(mb_type)){
945  for(list=0; list<h->list_count; list++){
946  unsigned int val;
947  if(IS_DIR(mb_type, 0, list)){
948  int rc = h->ref_count[list] << MB_MBAFF;
949  if (rc == 1) {
950  val= 0;
951  } else if (rc == 2) {
952  val= get_bits1(&h->gb)^1;
953  }else{
954  val= get_ue_golomb_31(&h->gb);
955  if (val >= rc) {
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  int rc = h->ref_count[list] << MB_MBAFF;
980  if (rc == 1) {
981  val= 0;
982  } else if (rc == 2) {
983  val= get_bits1(&h->gb)^1;
984  }else{
985  val= get_ue_golomb_31(&h->gb);
986  if (val >= rc) {
987  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
988  return -1;
989  }
990  }
991  }else
992  val= LIST_NOT_USED&0xFF;
993  fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
994  }
995  }
996  for(list=0; list<h->list_count; list++){
997  for(i=0; i<2; i++){
998  unsigned int val;
999  if(IS_DIR(mb_type, i, list)){
1000  pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1001  mx += get_se_golomb(&h->gb);
1002  my += get_se_golomb(&h->gb);
1003  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1004 
1005  val= pack16to32(mx,my);
1006  }else
1007  val=0;
1008  fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1009  }
1010  }
1011  }else{
1012  assert(IS_8X16(mb_type));
1013  for(list=0; list<h->list_count; list++){
1014  for(i=0; i<2; i++){
1015  unsigned int val;
1016  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1017  int rc = h->ref_count[list] << MB_MBAFF;
1018  if (rc == 1) {
1019  val= 0;
1020  } else if (rc == 2) {
1021  val= get_bits1(&h->gb)^1;
1022  }else{
1023  val= get_ue_golomb_31(&h->gb);
1024  if (val >= rc) {
1025  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1026  return -1;
1027  }
1028  }
1029  }else
1030  val= LIST_NOT_USED&0xFF;
1031  fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1032  }
1033  }
1034  for(list=0; list<h->list_count; list++){
1035  for(i=0; i<2; i++){
1036  unsigned int val;
1037  if(IS_DIR(mb_type, i, list)){
1038  pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1039  mx += get_se_golomb(&h->gb);
1040  my += get_se_golomb(&h->gb);
1041  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1042 
1043  val= pack16to32(mx,my);
1044  }else
1045  val=0;
1046  fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1047  }
1048  }
1049  }
1050  }
1051 
1052  if(IS_INTER(mb_type))
1053  write_back_motion(h, mb_type);
1054 
1055  if(!IS_INTRA16x16(mb_type)){
1056  cbp= get_ue_golomb(&h->gb);
1057 
1058  if(decode_chroma){
1059  if(cbp > 47){
1060  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
1061  return -1;
1062  }
1063  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
1064  else cbp= golomb_to_inter_cbp [cbp];
1065  }else{
1066  if(cbp > 15){
1067  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
1068  return -1;
1069  }
1070  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1071  else cbp= golomb_to_inter_cbp_gray[cbp];
1072  }
1073  }
1074 
1075  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1076  mb_type |= MB_TYPE_8x8DCT*get_bits1(&h->gb);
1077  }
1078  h->cbp=
1079  h->cbp_table[mb_xy]= cbp;
1080  h->cur_pic.f.mb_type[mb_xy] = mb_type;
1081 
1082  if(cbp || IS_INTRA16x16(mb_type)){
1083  int i4x4, i8x8, chroma_idx;
1084  int dquant;
1085  int ret;
1086  GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
1087  const uint8_t *scan, *scan8x8;
1088  const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1089 
1090  if(IS_INTERLACED(mb_type)){
1091  scan8x8= h->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1092  scan= h->qscale ? h->field_scan : h->field_scan_q0;
1093  }else{
1094  scan8x8= h->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1095  scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1096  }
1097 
1098  dquant= get_se_golomb(&h->gb);
1099 
1100  h->qscale += dquant;
1101 
1102  if(((unsigned)h->qscale) > max_qp){
1103  if(h->qscale<0) h->qscale+= max_qp+1;
1104  else h->qscale-= max_qp+1;
1105  if(((unsigned)h->qscale) > max_qp){
1106  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, h->mb_x, h->mb_y);
1107  return -1;
1108  }
1109  }
1110 
1111  h->chroma_qp[0]= get_chroma_qp(h, 0, h->qscale);
1112  h->chroma_qp[1]= get_chroma_qp(h, 1, h->qscale);
1113 
1114  if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
1115  return -1;
1116  }
1117  h->cbp_table[mb_xy] |= ret << 12;
1118  if(CHROMA444){
1119  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
1120  return -1;
1121  }
1122  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
1123  return -1;
1124  }
1125  } else if (CHROMA422) {
1126  if(cbp&0x30){
1127  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1128  if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1130  NULL, 8) < 0) {
1131  return -1;
1132  }
1133  }
1134 
1135  if(cbp&0x20){
1136  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1137  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1138  DCTELEM *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1139  for (i8x8 = 0; i8x8 < 2; i8x8++) {
1140  for (i4x4 = 0; i4x4 < 4; i4x4++) {
1141  const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1142  if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
1143  return -1;
1144  mb += 16 << pixel_shift;
1145  }
1146  }
1147  }
1148  }else{
1149  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1150  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1151  }
1152  } else /* yuv420 */ {
1153  if(cbp&0x30){
1154  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1155  if( decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift), CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma_dc_scan, NULL, 4) < 0){
1156  return -1;
1157  }
1158  }
1159 
1160  if(cbp&0x20){
1161  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1162  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1163  for(i4x4=0; i4x4<4; i4x4++){
1164  const int index= 16 + 16*chroma_idx + i4x4;
1165  if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
1166  return -1;
1167  }
1168  }
1169  }
1170  }else{
1171  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1172  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1173  }
1174  }
1175  }else{
1176  fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1177  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1178  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1179  }
1180  h->cur_pic.f.qscale_table[mb_xy] = h->qscale;
1182 
1183  return 0;
1184 }
int chroma_format_idc
Definition: h264.h:148
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:932
#define DC_128_PRED8x8
Definition: h264pred.h:76
GetBitContext gb
Definition: h264.h:259
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:278
GetBitContext * intra_gb_ptr
Definition: h264.h:413
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:171
int cbp
Definition: h264.h:428
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
static const uint8_t chroma422_dc_scan[8]
Definition: h264data.h:88
#define CHROMA422
Definition: h264.h:86
uint16_t * cbp_table
Definition: h264.h:427
static void align_get_bits(GetBitContext *s)
Definition: get_bits.h:412
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:454
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264.h:441
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
#define VLC_TYPE
Definition: get_bits.h:61
mpegvideo header.
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264.h:327
H264Context.
Definition: h264.h:252
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:106
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:907
#define IS_REF0(a)
Definition: h264.h:93
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:439
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264.h:369
static const uint8_t chroma422_dc_total_zeros_len[7][8]
Definition: h264_cavlc.c:199
#define IS_INTRA_PCM(a)
Definition: mpegvideo.h:112
uint8_t partition_count
Definition: h264data.h:190
static av_always_inline uint32_t pack16to32(int a, int b)
Definition: h264.h:794
int mb_skip_run
Definition: h264.h:457
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:823
Switching Intra.
Definition: avutil.h:249
#define IS_DIR(a, part, list)
Definition: mpegvideo.h:126
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
static VLC chroma422_dc_total_zeros_vlc[7]
Definition: h264_cavlc.c:259
#define IS_8x8DCT(a)
Definition: h264.h:94
static const uint8_t golomb_to_intra4x4_cbp_gray[16]
Definition: h264_cavlc.c:45
#define IS_INTER(a)
Definition: mpegvideo.h:110
DCTELEM mb_luma_dc[3][16 *2]
Definition: h264.h:417
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264.h:363
static const uint8_t coeff_token_bits[4][4 *17]
Definition: h264_cavlc.c:120
uint8_t
#define IS_8X16(a)
Definition: mpegvideo.h:118
DCTELEM mb[16 *48 *2]
as a dct coeffecient is int32_t in high depth, we need to reserve twice the space.
Definition: h264.h:416
static const int chroma_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:257
int mb_xy
Definition: h264.h:461
#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:275
#define LUMA_DC_BLOCK_INDEX
Definition: h264.h:774
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:402
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
int mb_x
Definition: h264.h:454
static const IMbInfo i_mb_type_info[26]
Definition: h264data.h:159
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
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:43
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:797
#define MB_MBAFF
Definition: h264.h:60
#define IS_INTERLACED(a)
Definition: mpegvideo.h:113
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
const uint8_t * zigzag_scan8x8_cavlc_q0
Definition: h264.h:447
H.264 / AVC / MPEG4 part10 codec.
static VLC chroma_dc_total_zeros_vlc[3]
Definition: h264_cavlc.c:255
int frame_num
Definition: h264.h:500
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:547
#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:311
static int get_ue_golomb(GetBitContext *gb)
read unsigned exp golomb code.
Definition: golomb.h:53
const uint8_t * zigzag_scan_q0
Definition: h264.h:445
static const uint16_t mask[17]
Definition: lzw.c:38
static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff)
Decode a residual block.
Definition: h264_cavlc.c:445
#define CHROMA_DC_BLOCK_INDEX
Definition: h264.h:775
static av_always_inline int get_chroma_qp(H264Context *h, int t, int qscale)
Get the chroma qp.
Definition: h264.h:815
GetBitContext * inter_gb_ptr
Definition: h264.h:414
#define IS_SUB_8X4(a)
Definition: mpegvideo.h:121
int mb_field_decoding_flag
Definition: h264.h:374
static const uint8_t chroma_dc_total_zeros_bits[3][4]
Definition: h264_cavlc.c:193
PPS pps
current pps
Definition: h264.h:359
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:197
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
#define IS_INTRA(a)
Definition: mpegvideo.h:109
static VLC chroma_dc_coeff_token_vlc
Definition: h264_cavlc.c:243
#define CLOSE_READER(name, gb)
Definition: get_bits.h:140
Definition: get_bits.h:63
static const uint8_t scan8[16 *3+3]
Definition: h264.h:778
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:94
int chroma_pred_mode
Definition: h264.h:291
#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
#define FRAME_MBAFF
Definition: h264.h:62
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:169
static DCTELEM block[64]
Definition: dct-test.c:169
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264.h:367
uint8_t field_scan8x8_cavlc[64]
Definition: h264.h:444
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:260
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:627
SPS sps
current sps
Definition: h264.h:354
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:251
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color)
Definition: avplay.c:401
#define MB_FIELD
Definition: h264.h:61
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:180
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:515
int ff_h264_decode_mb_cavlc(H264Context *h)
Decode a macroblock.
Definition: h264_cavlc.c:693
int direct_8x8_inference_flag
Definition: h264.h:163
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264.h:307
int slice_type
Definition: h264.h:368
static const uint8_t golomb_to_intra4x4_cbp[48]
Definition: h264data.h:43
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:433
static av_always_inline void write_back_non_zero_count(H264Context *h)
Definition: h264.h:849
#define PART_NOT_AVAILABLE
Definition: h264.h:330
unsigned int list_count
Definition: h264.h:403
#define IS_16X8(a)
Definition: mpegvideo.h:117
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:264
uint32_t * mb_type
macroblock type table mb_type_base + mb_width + 2
Definition: avcodec.h:1180
NULL
Definition: eval.c:52
int mb_stride
Definition: h264.h:459
AVCodecContext * avctx
Definition: h264.h:253
external API header
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:96
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:264
#define OPEN_READER(name, gb)
Definition: get_bits.h:124
static void fill_decode_neighbors(H264Context *h, int mb_type)
Definition: h264_mvpred.h:350
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:418
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
int prev_mb_skipped
Definition: h264.h:287
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
const uint8_t * field_scan8x8_cavlc_q0
Definition: h264.h:450
int index
Definition: gxfenc.c:72
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264.h:364
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:268
#define GET_CACHE(name, gb)
Definition: get_bits.h:190
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
short DCTELEM
Definition: dsputil.h:39
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:220
uint8_t zigzag_scan[16]
Definition: h264.h:439
int8_t * qscale_table
QP table.
Definition: avcodec.h:1139
uint8_t level
Definition: svq3.c:133
#define IS_INTRA16x16(a)
Definition: mpegvideo.h:107
Definition: vf_drawbox.c:36
#define AV_ZERO128(d)
Definition: intreadwrite.h:542
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2]
Definition: h264_cavlc.c:248
int qscale
Definition: h264.h:277
#define tprintf(p,...)
Definition: get_bits.h:613
uint8_t cbp
Definition: h264data.h:156
common internal api header.
H.264 / AVC / MPEG4 part10 motion vector predicion.
Bi-dir predicted.
Definition: avutil.h:247
int chroma_qp[2]
Definition: h264.h:269
static const uint8_t golomb_to_inter_cbp[48]
Definition: h264data.h:49
uint16_t sub_mb_type[4]
Definition: h264.h:379
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:195
static av_always_inline void write_back_intra_pred_mode(H264Context *h)
Definition: h264.h:838
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:157
int intra16x16_pred_mode
Definition: h264.h:292
#define IS_SUB_4X8(a)
Definition: mpegvideo.h:122
#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
#define IS_SUB_8X8(a)
Definition: mpegvideo.h:120
const uint16_t ff_h264_mb_sizes[4]
Definition: h264.c:48
static const int run_vlc_tables_size
Definition: h264_cavlc.c:265
#define IS_DIRECT(a)
Definition: mpegvideo.h:114
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264.h:320
#define av_log2
Definition: intmath.h:85
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
#define IS_16X16(a)
Definition: mpegvideo.h:116
struct AVFrame f
Definition: mpegvideo.h:96
const uint8_t * field_scan_q0
Definition: h264.h:448
uint16_t type
Definition: h264data.h:154
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
#define LIST_NOT_USED
Definition: h264.h:329
uint8_t(* non_zero_count)[48]
Definition: h264.h:322
exp golomb vlc stuff
int slice_num
Definition: h264.h:366
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:244
uint8_t field_scan[16]
Definition: h264.h:442
Predicted.
Definition: avutil.h:246
#define MB_TYPE_8x8DCT
Definition: h264.h:92
#define CHROMA444
Definition: h264.h:87
#define STORE_BLOCK(type)
int8_t ref_cache[2][5 *8]
Definition: h264.h:328
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264.h:375