Libav
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(h) 0
29 
30 #include "internal.h"
31 #include "avcodec.h"
32 #include "h264.h"
33 #include "h264data.h" // FIXME FIXME FIXME
34 #include "h264_mvpred.h"
35 #include "golomb.h"
36 #include "mpegutils.h"
37 
38 #include <assert.h>
39 
41  0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
42 };
43 
45 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
46 };
47 
49  2, 0, 0, 0,
50  6, 1, 0, 0,
51  6, 6, 3, 0,
52  6, 7, 7, 6,
53  6, 8, 8, 7,
54 };
55 
57  1, 0, 0, 0,
58  7, 1, 0, 0,
59  4, 6, 1, 0,
60  3, 3, 2, 5,
61  2, 3, 2, 0,
62 };
63 
65  1, 0, 0, 0,
66  7, 2, 0, 0,
67  7, 7, 3, 0,
68  9, 7, 7, 5,
69  9, 9, 7, 6,
70  10, 10, 9, 7,
71  11, 11, 10, 7,
72  12, 12, 11, 10,
73  13, 12, 12, 11,
74 };
75 
77  1, 0, 0, 0,
78  15, 1, 0, 0,
79  14, 13, 1, 0,
80  7, 12, 11, 1,
81  6, 5, 10, 1,
82  7, 6, 4, 9,
83  7, 6, 5, 8,
84  7, 6, 5, 4,
85  7, 5, 4, 4,
86 };
87 
88 static const uint8_t coeff_token_len[4][4*17]={
89 {
90  1, 0, 0, 0,
91  6, 2, 0, 0, 8, 6, 3, 0, 9, 8, 7, 5, 10, 9, 8, 6,
92  11,10, 9, 7, 13,11,10, 8, 13,13,11, 9, 13,13,13,10,
93  14,14,13,11, 14,14,14,13, 15,15,14,14, 15,15,15,14,
94  16,15,15,15, 16,16,16,15, 16,16,16,16, 16,16,16,16,
95 },
96 {
97  2, 0, 0, 0,
98  6, 2, 0, 0, 6, 5, 3, 0, 7, 6, 6, 4, 8, 6, 6, 4,
99  8, 7, 7, 5, 9, 8, 8, 6, 11, 9, 9, 6, 11,11,11, 7,
100  12,11,11, 9, 12,12,12,11, 12,12,12,11, 13,13,13,12,
101  13,13,13,13, 13,14,13,13, 14,14,14,13, 14,14,14,14,
102 },
103 {
104  4, 0, 0, 0,
105  6, 4, 0, 0, 6, 5, 4, 0, 6, 5, 5, 4, 7, 5, 5, 4,
106  7, 5, 5, 4, 7, 6, 6, 4, 7, 6, 6, 4, 8, 7, 7, 5,
107  8, 8, 7, 6, 9, 8, 8, 7, 9, 9, 8, 8, 9, 9, 9, 8,
108  10, 9, 9, 9, 10,10,10,10, 10,10,10,10, 10,10,10,10,
109 },
110 {
111  6, 0, 0, 0,
112  6, 6, 0, 0, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6,
113  6, 6, 6, 6, 6, 6, 6, 6, 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 }
117 };
118 
119 static const uint8_t coeff_token_bits[4][4*17]={
120 {
121  1, 0, 0, 0,
122  5, 1, 0, 0, 7, 4, 1, 0, 7, 6, 5, 3, 7, 6, 5, 3,
123  7, 6, 5, 4, 15, 6, 5, 4, 11,14, 5, 4, 8,10,13, 4,
124  15,14, 9, 4, 11,10,13,12, 15,14, 9,12, 11,10,13, 8,
125  15, 1, 9,12, 11,14,13, 8, 7,10, 9,12, 4, 6, 5, 8,
126 },
127 {
128  3, 0, 0, 0,
129  11, 2, 0, 0, 7, 7, 3, 0, 7,10, 9, 5, 7, 6, 5, 4,
130  4, 6, 5, 6, 7, 6, 5, 8, 15, 6, 5, 4, 11,14,13, 4,
131  15,10, 9, 4, 11,14,13,12, 8,10, 9, 8, 15,14,13,12,
132  11,10, 9,12, 7,11, 6, 8, 9, 8,10, 1, 7, 6, 5, 4,
133 },
134 {
135  15, 0, 0, 0,
136  15,14, 0, 0, 11,15,13, 0, 8,12,14,12, 15,10,11,11,
137  11, 8, 9,10, 9,14,13, 9, 8,10, 9, 8, 15,14,13,13,
138  11,14,10,12, 15,10,13,12, 11,14, 9,12, 8,10,13, 8,
139  13, 7, 9,12, 9,12,11,10, 5, 8, 7, 6, 1, 4, 3, 2,
140 },
141 {
142  3, 0, 0, 0,
143  0, 1, 0, 0, 4, 5, 6, 0, 8, 9,10,11, 12,13,14,15,
144  16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31,
145  32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47,
146  48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63,
147 }
148 };
149 
150 static const uint8_t total_zeros_len[16][16]= {
151  {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
152  {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
153  {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
154  {5,3,4,4,3,3,3,4,3,4,5,5,5},
155  {4,4,4,3,3,3,3,3,4,5,4,5},
156  {6,5,3,3,3,3,3,3,4,3,6},
157  {6,5,3,3,3,2,3,4,3,6},
158  {6,4,5,3,2,2,3,3,6},
159  {6,6,4,2,2,3,2,5},
160  {5,5,3,2,2,2,4},
161  {4,4,3,3,1,3},
162  {4,4,2,1,3},
163  {3,3,1,2},
164  {2,2,1},
165  {1,1},
166 };
167 
168 static const uint8_t total_zeros_bits[16][16]= {
169  {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
170  {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
171  {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
172  {3,7,5,4,6,5,4,3,3,2,2,1,0},
173  {5,4,3,7,6,5,4,3,2,1,1,0},
174  {1,1,7,6,5,4,3,2,1,1,0},
175  {1,1,5,4,3,3,2,1,1,0},
176  {1,1,1,3,3,2,2,1,0},
177  {1,0,1,3,2,1,1,1},
178  {1,0,1,3,2,1,1},
179  {0,1,1,2,1,3},
180  {0,1,1,1,1},
181  {0,1,1,1},
182  {0,1,1},
183  {0,1},
184 };
185 
186 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
187  { 1, 2, 3, 3,},
188  { 1, 2, 2, 0,},
189  { 1, 1, 0, 0,},
190 };
191 
192 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
193  { 1, 1, 1, 0,},
194  { 1, 1, 0, 0,},
195  { 1, 0, 0, 0,},
196 };
197 
199  { 1, 3, 3, 4, 4, 4, 5, 5 },
200  { 3, 2, 3, 3, 3, 3, 3 },
201  { 3, 3, 2, 2, 3, 3 },
202  { 3, 2, 2, 2, 3 },
203  { 2, 2, 2, 2 },
204  { 2, 2, 1 },
205  { 1, 1 },
206 };
207 
209  { 1, 2, 3, 2, 3, 1, 1, 0 },
210  { 0, 1, 1, 4, 5, 6, 7 },
211  { 0, 1, 1, 2, 6, 7 },
212  { 6, 0, 1, 2, 7 },
213  { 0, 1, 2, 3 },
214  { 0, 1, 1 },
215  { 0, 1 },
216 };
217 
218 static const uint8_t run_len[7][16]={
219  {1,1},
220  {1,2,2},
221  {2,2,2,2},
222  {2,2,2,3,3},
223  {2,2,3,3,3,3},
224  {2,3,3,3,3,3,3},
225  {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
226 };
227 
228 static const uint8_t run_bits[7][16]={
229  {1,0},
230  {1,1,0},
231  {3,2,1,0},
232  {3,2,1,1,0},
233  {3,2,3,2,1,0},
234  {3,0,1,3,2,5,4},
235  {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
236 };
237 
239 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
240 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
241 
245 
249 
250 static VLC total_zeros_vlc[15];
251 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
252 static const int total_zeros_vlc_tables_size = 512;
253 
257 
261 
262 static VLC run_vlc[6];
263 static VLC_TYPE run_vlc_tables[6][8][2];
264 static const int run_vlc_tables_size = 8;
265 
266 static VLC run7_vlc;
267 static VLC_TYPE run7_vlc_table[96][2];
268 static const int run7_vlc_table_size = 96;
269 
270 #define LEVEL_TAB_BITS 8
271 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
272 
273 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
274 #define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
275 #define COEFF_TOKEN_VLC_BITS 8
276 #define TOTAL_ZEROS_VLC_BITS 9
277 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
278 #define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
279 #define RUN_VLC_BITS 3
280 #define RUN7_VLC_BITS 6
281 
286 static inline int pred_non_zero_count(H264Context *h, int n){
287  const int index8= scan8[n];
288  const int left= h->non_zero_count_cache[index8 - 1];
289  const int top = h->non_zero_count_cache[index8 - 8];
290  int i= left + top;
291 
292  if(i<64) i= (i+1)>>1;
293 
294  tprintf(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
295 
296  return i&31;
297 }
298 
299 static av_cold void init_cavlc_level_tab(void){
300  int suffix_length;
301  unsigned int i;
302 
303  for(suffix_length=0; suffix_length<7; suffix_length++){
304  for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
305  int prefix= LEVEL_TAB_BITS - av_log2(2*i);
306 
307  if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
308  int level_code = (prefix << suffix_length) +
309  (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
310  int mask = -(level_code&1);
311  level_code = (((2 + level_code) >> 1) ^ mask) - mask;
312  cavlc_level_tab[suffix_length][i][0]= level_code;
313  cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
314  }else if(prefix + 1 <= LEVEL_TAB_BITS){
315  cavlc_level_tab[suffix_length][i][0]= prefix+100;
316  cavlc_level_tab[suffix_length][i][1]= prefix + 1;
317  }else{
318  cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
319  cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
320  }
321  }
322  }
323 }
324 
326  static int done = 0;
327 
328  if (!done) {
329  int i;
330  int offset;
331  done = 1;
332 
333  chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
334  chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
335  init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
336  &chroma_dc_coeff_token_len [0], 1, 1,
337  &chroma_dc_coeff_token_bits[0], 1, 1,
339 
340  chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
341  chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
342  init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
343  &chroma422_dc_coeff_token_len [0], 1, 1,
346 
347  offset = 0;
348  for(i=0; i<4; i++){
349  coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
350  coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
351  init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
352  &coeff_token_len [i][0], 1, 1,
353  &coeff_token_bits[i][0], 1, 1,
355  offset += coeff_token_vlc_tables_size[i];
356  }
357  /*
358  * This is a one time safety check to make sure that
359  * the packed static coeff_token_vlc table sizes
360  * were initialized correctly.
361  */
362  assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
363 
364  for(i=0; i<3; i++){
365  chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
366  chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
367  init_vlc(&chroma_dc_total_zeros_vlc[i],
369  &chroma_dc_total_zeros_len [i][0], 1, 1,
370  &chroma_dc_total_zeros_bits[i][0], 1, 1,
372  }
373 
374  for(i=0; i<7; i++){
375  chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
376  chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
377  init_vlc(&chroma422_dc_total_zeros_vlc[i],
379  &chroma422_dc_total_zeros_len [i][0], 1, 1,
380  &chroma422_dc_total_zeros_bits[i][0], 1, 1,
382  }
383 
384  for(i=0; i<15; i++){
385  total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
386  total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
387  init_vlc(&total_zeros_vlc[i],
389  &total_zeros_len [i][0], 1, 1,
390  &total_zeros_bits[i][0], 1, 1,
392  }
393 
394  for(i=0; i<6; i++){
395  run_vlc[i].table = run_vlc_tables[i];
397  init_vlc(&run_vlc[i],
398  RUN_VLC_BITS, 7,
399  &run_len [i][0], 1, 1,
400  &run_bits[i][0], 1, 1,
402  }
403  run7_vlc.table = run7_vlc_table,
405  init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
406  &run_len [6][0], 1, 1,
407  &run_bits[6][0], 1, 1,
409 
411  }
412 }
413 
417 static inline int get_level_prefix(GetBitContext *gb){
418  unsigned int buf;
419  int log;
420 
421  OPEN_READER(re, gb);
422  UPDATE_CACHE(re, gb);
423  buf=GET_CACHE(re, gb);
424 
425  log= 32 - av_log2(buf);
426 #ifdef TRACE
427  print_bin(buf>>(32-log), log);
428  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__);
429 #endif
430 
431  LAST_SKIP_BITS(re, gb, log);
432  CLOSE_READER(re, gb);
433 
434  return log-1;
435 }
436 
444 static int decode_residual(H264Context *h, GetBitContext *gb, int16_t *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
445  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};
446  int level[16];
447  int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
448 
449  //FIXME put trailing_onex into the context
450 
451  if(max_coeff <= 8){
452  if (max_coeff == 4)
453  coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
454  else
455  coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
456  total_coeff= coeff_token>>2;
457  }else{
458  if(n >= LUMA_DC_BLOCK_INDEX){
459  total_coeff= pred_non_zero_count(h, (n - LUMA_DC_BLOCK_INDEX)*16);
460  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
461  total_coeff= coeff_token>>2;
462  }else{
463  total_coeff= pred_non_zero_count(h, n);
464  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
465  total_coeff= coeff_token>>2;
466  }
467  }
468  h->non_zero_count_cache[ scan8[n] ]= total_coeff;
469 
470  //FIXME set last_non_zero?
471 
472  if(total_coeff==0)
473  return 0;
474  if(total_coeff > (unsigned)max_coeff) {
475  av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", h->mb_x, h->mb_y, total_coeff);
476  return -1;
477  }
478 
479  trailing_ones= coeff_token&3;
480  tprintf(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
481  assert(total_coeff<=16);
482 
483  i = show_bits(gb, 3);
484  skip_bits(gb, trailing_ones);
485  level[0] = 1-((i&4)>>1);
486  level[1] = 1-((i&2) );
487  level[2] = 1-((i&1)<<1);
488 
489  if(trailing_ones<total_coeff) {
490  int mask, prefix;
491  int suffix_length = total_coeff > 10 & trailing_ones < 3;
492  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
493  int level_code= cavlc_level_tab[suffix_length][bitsi][0];
494 
495  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
496  if(level_code >= 100){
497  prefix= level_code - 100;
498  if(prefix == LEVEL_TAB_BITS)
499  prefix += get_level_prefix(gb);
500 
501  //first coefficient has suffix_length equal to 0 or 1
502  if(prefix<14){ //FIXME try to build a large unified VLC table for all this
503  if(suffix_length)
504  level_code= (prefix<<1) + get_bits1(gb); //part
505  else
506  level_code= prefix; //part
507  }else if(prefix==14){
508  if(suffix_length)
509  level_code= (prefix<<1) + get_bits1(gb); //part
510  else
511  level_code= prefix + get_bits(gb, 4); //part
512  }else{
513  level_code= 30 + get_bits(gb, prefix-3); //part
514  if(prefix>=16){
515  if(prefix > 25+3){
516  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
517  return -1;
518  }
519  level_code += (1<<(prefix-3))-4096;
520  }
521  }
522 
523  if(trailing_ones < 3) level_code += 2;
524 
525  suffix_length = 2;
526  mask= -(level_code&1);
527  level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
528  }else{
529  level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
530 
531  suffix_length = 1 + (level_code + 3U > 6U);
532  level[trailing_ones]= level_code;
533  }
534 
535  //remaining coefficients have suffix_length > 0
536  for(i=trailing_ones+1;i<total_coeff;i++) {
537  static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
538  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
539  level_code= cavlc_level_tab[suffix_length][bitsi][0];
540 
541  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
542  if(level_code >= 100){
543  prefix= level_code - 100;
544  if(prefix == LEVEL_TAB_BITS){
545  prefix += get_level_prefix(gb);
546  }
547  if(prefix<15){
548  level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
549  }else{
550  level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
551  if(prefix>=16)
552  level_code += (1<<(prefix-3))-4096;
553  }
554  mask= -(level_code&1);
555  level_code= (((2+level_code)>>1) ^ mask) - mask;
556  }
557  level[i]= level_code;
558  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
559  }
560  }
561 
562  if(total_coeff == max_coeff)
563  zeros_left=0;
564  else{
565  if (max_coeff <= 8) {
566  if (max_coeff == 4)
567  zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff - 1].table,
569  else
570  zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
572  } else {
573  zeros_left= get_vlc2(gb, total_zeros_vlc[total_coeff - 1].table, TOTAL_ZEROS_VLC_BITS, 1);
574  }
575  }
576 
577 #define STORE_BLOCK(type) \
578  scantable += zeros_left + total_coeff - 1; \
579  if(n >= LUMA_DC_BLOCK_INDEX){ \
580  ((type*)block)[*scantable] = level[0]; \
581  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
582  if(zeros_left < 7) \
583  run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
584  else {\
585  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
586  run_before = FFMIN(zeros_left, run_before);\
587  }\
588  zeros_left -= run_before; \
589  scantable -= 1 + run_before; \
590  ((type*)block)[*scantable]= level[i]; \
591  } \
592  for(;i<total_coeff;i++) { \
593  scantable--; \
594  ((type*)block)[*scantable]= level[i]; \
595  } \
596  }else{ \
597  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
598  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
599  if(zeros_left < 7) \
600  run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
601  else {\
602  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
603  run_before = FFMIN(zeros_left, run_before);\
604  }\
605  zeros_left -= run_before; \
606  scantable -= 1 + run_before; \
607  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
608  } \
609  for(;i<total_coeff;i++) { \
610  scantable--; \
611  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
612  } \
613  }
614 
615  if (zeros_left < 0) {
617  "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
618  return AVERROR_INVALIDDATA;
619  }
620 
621  if (h->pixel_shift) {
623  } else {
624  STORE_BLOCK(int16_t)
625  }
626 
627  return 0;
628 }
629 
630 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){
631  int i4x4, i8x8;
632  int qscale = p == 0 ? h->qscale : h->chroma_qp[p-1];
633  if(IS_INTRA16x16(mb_type)){
634  AV_ZERO128(h->mb_luma_dc[p]+0);
635  AV_ZERO128(h->mb_luma_dc[p]+8);
636  AV_ZERO128(h->mb_luma_dc[p]+16);
637  AV_ZERO128(h->mb_luma_dc[p]+24);
638  if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX+p, scan, NULL, 16) < 0){
639  return -1; //FIXME continue if partitioned and other return -1 too
640  }
641 
642  assert((cbp&15) == 0 || (cbp&15) == 15);
643 
644  if(cbp&15){
645  for(i8x8=0; i8x8<4; i8x8++){
646  for(i4x4=0; i4x4<4; i4x4++){
647  const int index= i4x4 + 4*i8x8 + p*16;
648  if( decode_residual(h, h->intra_gb_ptr, h->mb + (16*index << pixel_shift),
649  index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
650  return -1;
651  }
652  }
653  }
654  return 0xf;
655  }else{
656  fill_rectangle(&h->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
657  return 0;
658  }
659  }else{
660  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
661  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
662  int new_cbp = 0;
663  for(i8x8=0; i8x8<4; i8x8++){
664  if(cbp & (1<<i8x8)){
665  if(IS_8x8DCT(mb_type)){
666  int16_t *buf = &h->mb[64*i8x8+256*p << pixel_shift];
667  uint8_t *nnz;
668  for(i4x4=0; i4x4<4; i4x4++){
669  const int index= i4x4 + 4*i8x8 + p*16;
670  if( decode_residual(h, gb, buf, index, scan8x8+16*i4x4,
671  h->dequant8_coeff[cqm][qscale], 16) < 0 )
672  return -1;
673  }
674  nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
675  nnz[0] += nnz[1] + nnz[8] + nnz[9];
676  new_cbp |= !!nnz[0] << i8x8;
677  }else{
678  for(i4x4=0; i4x4<4; i4x4++){
679  const int index= i4x4 + 4*i8x8 + p*16;
680  if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index,
681  scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
682  return -1;
683  }
684  new_cbp |= h->non_zero_count_cache[ scan8[index] ] << i8x8;
685  }
686  }
687  }else{
688  uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
689  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
690  }
691  }
692  return new_cbp;
693  }
694 }
695 
697  int mb_xy;
698  int partition_count;
699  unsigned int mb_type, cbp;
700  int dct8x8_allowed= h->pps.transform_8x8_mode;
701  int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
702  const int pixel_shift = h->pixel_shift;
703 
704  mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
705 
706  tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
707  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
708  down the code */
710  if(h->mb_skip_run==-1)
711  h->mb_skip_run= get_ue_golomb(&h->gb);
712 
713  if (h->mb_skip_run--) {
714  if(FRAME_MBAFF(h) && (h->mb_y&1) == 0){
715  if(h->mb_skip_run==0)
717  }
718  decode_mb_skip(h);
719  return 0;
720  }
721  }
722  if (FRAME_MBAFF(h)) {
723  if( (h->mb_y&1) == 0 )
725  }
726 
727  h->prev_mb_skipped= 0;
728 
729  mb_type= get_ue_golomb(&h->gb);
731  if(mb_type < 23){
732  partition_count= b_mb_type_info[mb_type].partition_count;
733  mb_type= b_mb_type_info[mb_type].type;
734  }else{
735  mb_type -= 23;
736  goto decode_intra_mb;
737  }
738  }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
739  if(mb_type < 5){
740  partition_count= p_mb_type_info[mb_type].partition_count;
741  mb_type= p_mb_type_info[mb_type].type;
742  }else{
743  mb_type -= 5;
744  goto decode_intra_mb;
745  }
746  }else{
747  assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
748  if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
749  mb_type--;
750 decode_intra_mb:
751  if(mb_type > 25){
752  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);
753  return -1;
754  }
755  partition_count=0;
756  cbp= i_mb_type_info[mb_type].cbp;
758  mb_type= i_mb_type_info[mb_type].type;
759  }
760 
761  if(MB_FIELD(h))
762  mb_type |= MB_TYPE_INTERLACED;
763 
764  h->slice_table[ mb_xy ]= h->slice_num;
765 
766  if(IS_INTRA_PCM(mb_type)){
767  const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
768  h->sps.bit_depth_luma;
769 
770  // We assume these blocks are very rare so we do not optimize it.
771  h->intra_pcm_ptr = align_get_bits(&h->gb);
772  if (get_bits_left(&h->gb) < mb_size) {
773  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
774  return AVERROR_INVALIDDATA;
775  }
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  fill_decode_neighbors(h, mb_type);
788  fill_decode_caches(h, mb_type);
789 
790  //mb_pred
791  if(IS_INTRA(mb_type)){
792  int pred_mode;
793 // init_top_left_availability(h);
794  if(IS_INTRA4x4(mb_type)){
795  int i;
796  int di = 1;
797  if(dct8x8_allowed && get_bits1(&h->gb)){
798  mb_type |= MB_TYPE_8x8DCT;
799  di = 4;
800  }
801 
802 // fill_intra4x4_pred_table(h);
803  for(i=0; i<16; i+=di){
804  int mode= pred_intra_mode(h, i);
805 
806  if(!get_bits1(&h->gb)){
807  const int rem_mode= get_bits(&h->gb, 3);
808  mode = rem_mode + (rem_mode >= mode);
809  }
810 
811  if(di==4)
812  fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
813  else
814  h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
815  }
818  return -1;
819  }else{
821  if(h->intra16x16_pred_mode < 0)
822  return -1;
823  }
824  if(decode_chroma){
825  pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&h->gb), 1);
826  if(pred_mode < 0)
827  return -1;
828  h->chroma_pred_mode= pred_mode;
829  } else {
831  }
832  }else if(partition_count==4){
833  int i, j, sub_partition_count[4], list, ref[2][4];
834 
836  for(i=0; i<4; i++){
837  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
838  if(h->sub_mb_type[i] >=13){
839  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);
840  return -1;
841  }
842  sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
844  }
845  if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
846  ff_h264_pred_direct_motion(h, &mb_type);
847  h->ref_cache[0][scan8[4]] =
848  h->ref_cache[1][scan8[4]] =
849  h->ref_cache[0][scan8[12]] =
850  h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
851  }
852  }else{
853  assert(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
854  for(i=0; i<4; i++){
855  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
856  if(h->sub_mb_type[i] >=4){
857  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);
858  return -1;
859  }
860  sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
862  }
863  }
864 
865  for(list=0; list<h->list_count; list++){
866  int ref_count = IS_REF0(mb_type) ? 1 : h->ref_count[list] << MB_MBAFF(h);
867  for(i=0; i<4; i++){
868  if(IS_DIRECT(h->sub_mb_type[i])) continue;
869  if(IS_DIR(h->sub_mb_type[i], 0, list)){
870  unsigned int tmp;
871  if(ref_count == 1){
872  tmp= 0;
873  }else if(ref_count == 2){
874  tmp= get_bits1(&h->gb)^1;
875  }else{
876  tmp= get_ue_golomb_31(&h->gb);
877  if(tmp>=ref_count){
878  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
879  return -1;
880  }
881  }
882  ref[list][i]= tmp;
883  }else{
884  //FIXME
885  ref[list][i] = -1;
886  }
887  }
888  }
889 
890  if(dct8x8_allowed)
891  dct8x8_allowed = get_dct8x8_allowed(h);
892 
893  for(list=0; list<h->list_count; list++){
894  for(i=0; i<4; i++){
895  if(IS_DIRECT(h->sub_mb_type[i])) {
896  h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
897  continue;
898  }
899  h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
900  h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
901 
902  if(IS_DIR(h->sub_mb_type[i], 0, list)){
903  const int sub_mb_type= h->sub_mb_type[i];
904  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
905  for(j=0; j<sub_partition_count[i]; j++){
906  int mx, my;
907  const int index= 4*i + block_width*j;
908  int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
909  pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
910  mx += get_se_golomb(&h->gb);
911  my += get_se_golomb(&h->gb);
912  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
913 
914  if(IS_SUB_8X8(sub_mb_type)){
915  mv_cache[ 1 ][0]=
916  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
917  mv_cache[ 1 ][1]=
918  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
919  }else if(IS_SUB_8X4(sub_mb_type)){
920  mv_cache[ 1 ][0]= mx;
921  mv_cache[ 1 ][1]= my;
922  }else if(IS_SUB_4X8(sub_mb_type)){
923  mv_cache[ 8 ][0]= mx;
924  mv_cache[ 8 ][1]= my;
925  }
926  mv_cache[ 0 ][0]= mx;
927  mv_cache[ 0 ][1]= my;
928  }
929  }else{
930  uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
931  p[0] = p[1]=
932  p[8] = p[9]= 0;
933  }
934  }
935  }
936  }else if(IS_DIRECT(mb_type)){
937  ff_h264_pred_direct_motion(h, &mb_type);
938  dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
939  }else{
940  int list, mx, my, i;
941  //FIXME we should set ref_idx_l? to 0 if we use that later ...
942  if(IS_16X16(mb_type)){
943  for(list=0; list<h->list_count; list++){
944  unsigned int val;
945  if(IS_DIR(mb_type, 0, list)){
946  int rc = h->ref_count[list] << MB_MBAFF(h);
947  if (rc == 1) {
948  val= 0;
949  } else if (rc == 2) {
950  val= get_bits1(&h->gb)^1;
951  }else{
952  val= get_ue_golomb_31(&h->gb);
953  if (val >= rc) {
954  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
955  return -1;
956  }
957  }
958  fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
959  }
960  }
961  for(list=0; list<h->list_count; list++){
962  if(IS_DIR(mb_type, 0, list)){
963  pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
964  mx += get_se_golomb(&h->gb);
965  my += get_se_golomb(&h->gb);
966  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
967 
968  fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
969  }
970  }
971  }
972  else if(IS_16X8(mb_type)){
973  for(list=0; list<h->list_count; list++){
974  for(i=0; i<2; i++){
975  unsigned int val;
976  if(IS_DIR(mb_type, i, list)){
977  int rc = h->ref_count[list] << MB_MBAFF(h);
978  if (rc == 1) {
979  val= 0;
980  } else if (rc == 2) {
981  val= get_bits1(&h->gb)^1;
982  }else{
983  val= get_ue_golomb_31(&h->gb);
984  if (val >= rc) {
985  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
986  return -1;
987  }
988  }
989  }else
990  val= LIST_NOT_USED&0xFF;
991  fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
992  }
993  }
994  for(list=0; list<h->list_count; list++){
995  for(i=0; i<2; i++){
996  unsigned int val;
997  if(IS_DIR(mb_type, i, list)){
998  pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
999  mx += get_se_golomb(&h->gb);
1000  my += get_se_golomb(&h->gb);
1001  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1002 
1003  val= pack16to32(mx,my);
1004  }else
1005  val=0;
1006  fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1007  }
1008  }
1009  }else{
1010  assert(IS_8X16(mb_type));
1011  for(list=0; list<h->list_count; list++){
1012  for(i=0; i<2; i++){
1013  unsigned int val;
1014  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1015  int rc = h->ref_count[list] << MB_MBAFF(h);
1016  if (rc == 1) {
1017  val= 0;
1018  } else if (rc == 2) {
1019  val= get_bits1(&h->gb)^1;
1020  }else{
1021  val= get_ue_golomb_31(&h->gb);
1022  if (val >= rc) {
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  }
1072 
1073  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1074  mb_type |= MB_TYPE_8x8DCT*get_bits1(&h->gb);
1075  }
1076  h->cbp=
1077  h->cbp_table[mb_xy]= cbp;
1078  h->cur_pic.mb_type[mb_xy] = mb_type;
1079 
1080  if(cbp || IS_INTRA16x16(mb_type)){
1081  int i4x4, i8x8, chroma_idx;
1082  int dquant;
1083  int ret;
1084  GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
1085  const uint8_t *scan, *scan8x8;
1086  const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1087 
1088  if(IS_INTERLACED(mb_type)){
1089  scan8x8= h->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1090  scan= h->qscale ? h->field_scan : h->field_scan_q0;
1091  }else{
1092  scan8x8= h->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1093  scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1094  }
1095 
1096  dquant= get_se_golomb(&h->gb);
1097 
1098  h->qscale += dquant;
1099 
1100  if(((unsigned)h->qscale) > max_qp){
1101  if(h->qscale<0) h->qscale+= max_qp+1;
1102  else h->qscale-= max_qp+1;
1103  if(((unsigned)h->qscale) > max_qp){
1104  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, h->mb_x, h->mb_y);
1105  return -1;
1106  }
1107  }
1108 
1109  h->chroma_qp[0]= get_chroma_qp(h, 0, h->qscale);
1110  h->chroma_qp[1]= get_chroma_qp(h, 1, h->qscale);
1111 
1112  if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
1113  return -1;
1114  }
1115  h->cbp_table[mb_xy] |= ret << 12;
1116  if (CHROMA444(h)) {
1117  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
1118  return -1;
1119  }
1120  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
1121  return -1;
1122  }
1123  } else if (CHROMA422(h)) {
1124  if(cbp&0x30){
1125  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1126  if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1128  NULL, 8) < 0) {
1129  return -1;
1130  }
1131  }
1132 
1133  if(cbp&0x20){
1134  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1135  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1136  int16_t *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1137  for (i8x8 = 0; i8x8 < 2; i8x8++) {
1138  for (i4x4 = 0; i4x4 < 4; i4x4++) {
1139  const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1140  if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
1141  return -1;
1142  mb += 16 << pixel_shift;
1143  }
1144  }
1145  }
1146  }else{
1147  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1148  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1149  }
1150  } else /* yuv420 */ {
1151  if(cbp&0x30){
1152  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1153  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){
1154  return -1;
1155  }
1156  }
1157 
1158  if(cbp&0x20){
1159  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1160  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1161  for(i4x4=0; i4x4<4; i4x4++){
1162  const int index= 16 + 16*chroma_idx + i4x4;
1163  if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
1164  return -1;
1165  }
1166  }
1167  }
1168  }else{
1169  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1170  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1171  }
1172  }
1173  }else{
1174  fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1175  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1176  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1177  }
1178  h->cur_pic.qscale_table[mb_xy] = h->qscale;
1180 
1181  return 0;
1182 }
int chroma_format_idc
Definition: h264.h:160
uint8_t pred_mode
Definition: h264data.h:75
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:270
static av_always_inline int get_dct8x8_allowed(H264Context *h)
Definition: h264.h:1022
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
#define DC_128_PRED8x8
Definition: h264pred.h:76
GetBitContext gb
Definition: h264.h:311
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
GetBitContext * intra_gb_ptr
Definition: h264.h:456
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:179
#define CHROMA444(h)
Definition: h264.h:96
int cbp
Definition: h264.h:472
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:66
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:199
uint16_t * cbp_table
Definition: h264.h:471
static const int chroma422_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:248
Definition: vf_drawbox.c:37
static av_cold void init_cavlc_level_tab(void)
Definition: h264_cavlc.c:299
int mb_y
Definition: h264.h:498
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:276
#define IS_SUB_8X8(a)
Definition: mpegutils.h:86
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264.h:485
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:267
#define VLC_TYPE
Definition: get_bits.h:62
#define FF_ARRAY_ELEMS(a)
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264.h:378
H264Context.
Definition: h264.h:303
static const uint8_t chroma422_dc_coeff_token_len[4 *9]
Definition: h264_cavlc.c:64
static const int chroma422_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:260
#define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:278
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2]
Definition: h264_cavlc.c:255
static VLC chroma422_dc_coeff_token_vlc
Definition: h264_cavlc.c:246
static av_always_inline void write_back_motion(H264Context *h, int mb_type)
Definition: h264.h:997
#define IS_REF0(a)
Definition: h264.h:102
static const uint8_t coeff_token_len[4][4 *17]
Definition: h264_cavlc.c:88
static const uint8_t chroma422_dc_coeff_token_bits[4 *9]
Definition: h264_cavlc.c:76
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:412
static const uint8_t chroma422_dc_total_zeros_len[7][8]
Definition: h264_cavlc.c:198
uint8_t partition_count
Definition: h264data.h:110
static av_always_inline uint32_t pack16to32(int a, int b)
Definition: h264.h:884
int mb_skip_run
Definition: h264.h:501
static const PMbInfo b_sub_mb_type_info[13]
Definition: h264data.h:154
static av_always_inline int pred_intra_mode(H264Context *h, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264.h:913
Switching Intra.
Definition: avutil.h:257
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:218
static const uint8_t chroma_dc_coeff_token_bits[4 *5]
Definition: h264_cavlc.c:56
static VLC chroma422_dc_total_zeros_vlc[7]
Definition: h264_cavlc.c:258
#define IS_8x8DCT(a)
Definition: h264.h:103
static const uint8_t golomb_to_intra4x4_cbp_gray[16]
Definition: h264_cavlc.c:44
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264.h:406
static const uint8_t coeff_token_bits[4][4 *17]
Definition: h264_cavlc.c:119
uint8_t
#define av_cold
Definition: attributes.h:66
static const int chroma_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:256
int mb_xy
Definition: h264.h:505
#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:274
#define LUMA_DC_BLOCK_INDEX
Definition: h264.h:864
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:445
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:228
#define IS_DIR(a, part, list)
Definition: mpegutils.h:92
int mb_x
Definition: h264.h:498
static const IMbInfo i_mb_type_info[26]
Definition: h264data.h:79
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:194
static int8_t cavlc_level_tab[7][1<< LEVEL_TAB_BITS][2]
Definition: h264_cavlc.c:271
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:150
static void av_unused decode_mb_skip(H264Context *h)
decodes a P_SKIP or B_SKIP macroblock
Definition: h264_mvpred.h:797
uint16_t type
Definition: h264data.h:109
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2]
Definition: h264_cavlc.c:239
static VLC total_zeros_vlc[15]
Definition: h264_cavlc.c:250
const uint8_t * zigzag_scan8x8_cavlc_q0
Definition: h264.h:491
H.264 / AVC / MPEG4 part10 codec.
static VLC chroma_dc_total_zeros_vlc[3]
Definition: h264_cavlc.c:254
int frame_num
Definition: h264.h:544
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:555
#define RUN7_VLC_BITS
Definition: h264_cavlc.c:280
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:161
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:175
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
int16_t mb_luma_dc[3][16 *2]
Definition: h264.h:461
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:489
static const uint16_t mask[17]
Definition: lzw.c:38
#define CHROMA_DC_BLOCK_INDEX
Definition: h264.h:865
static av_always_inline int get_chroma_qp(H264Context *h, int t, int qscale)
Get the chroma qp.
Definition: h264.h:905
GetBitContext * inter_gb_ptr
Definition: h264.h:457
#define MB_FIELD(h)
Definition: h264.h:70
int mb_field_decoding_flag
Definition: h264.h:417
static const uint8_t chroma_dc_total_zeros_bits[3][4]
Definition: h264_cavlc.c:192
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
PPS pps
current pps
Definition: h264.h:402
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:169
static VLC chroma_dc_coeff_token_vlc
Definition: h264_cavlc.c:242
#define CLOSE_READER(name, gb)
Definition: get_bits.h:141
Definition: get_bits.h:64
static const uint8_t scan8[16 *3+3]
Definition: h264.h:868
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:342
#define COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:275
void ff_h264_pred_direct_motion(H264Context *const h, int *mb_type)
Definition: h264_direct.c:692
static const int chroma_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:244
#define IS_INTRA_PCM(a)
Definition: mpegutils.h:78
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:168
#define IS_16X8(a)
Definition: mpegutils.h:83
#define IS_SUB_4X8(a)
Definition: mpegutils.h:88
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264.h:410
uint8_t field_scan8x8_cavlc[64]
Definition: h264.h:488
#define IS_DIRECT(a)
Definition: mpegutils.h:80
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:259
#define MB_TYPE_INTERLACED
Definition: avcodec.h:782
static VLC coeff_token_vlc[4]
Definition: h264_cavlc.c:238
static VLC_TYPE total_zeros_vlc_tables[15][512][2]
Definition: h264_cavlc.c:251
uint32_t * mb_type
Definition: h264.h:274
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:630
SPS sps
current sps
Definition: h264.h:401
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:254
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color)
Definition: avplay.c:396
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:182
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:522
int ff_h264_decode_mb_cavlc(H264Context *h)
Decode a macroblock.
Definition: h264_cavlc.c:696
int direct_8x8_inference_flag
Definition: h264.h:175
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264.h:358
int slice_type
Definition: h264.h:411
static const uint8_t golomb_to_intra4x4_cbp[48]
Definition: h264data.h:42
#define MB_MBAFF(h)
Definition: h264.h:69
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:441
static av_always_inline void write_back_non_zero_count(H264Context *h)
Definition: h264.h:939
#define PART_NOT_AVAILABLE
Definition: h264.h:381
unsigned int list_count
Definition: h264.h:446
#define IS_INTRA16x16(a)
Definition: mpegutils.h:72
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:444
static const uint8_t chroma_dc_coeff_token_len[4 *5]
Definition: h264_cavlc.c:48
int table_allocated
Definition: get_bits.h:67
NULL
Definition: eval.c:55
int mb_stride
Definition: h264.h:503
#define IS_INTERLACED(a)
Definition: mpegutils.h:79
AVCodecContext * avctx
Definition: h264.h:304
#define IS_SUB_8X4(a)
Definition: mpegutils.h:87
Libavcodec 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:128
int16_t mb[16 *48 *2]
as a dct coeffecient is int32_t in high depth, we need to reserve twice the space.
Definition: h264.h:460
#define OPEN_READER(name, gb)
Definition: get_bits.h:127
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:424
#define RUN_VLC_BITS
Definition: h264_cavlc.c:279
int prev_mb_skipped
Definition: h264.h:338
int8_t * qscale_table
Definition: h264.h:268
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
#define IS_16X16(a)
Definition: mpegutils.h:82
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
const uint8_t * field_scan8x8_cavlc_q0
Definition: h264.h:494
#define CHROMA422(h)
Definition: h264.h:95
int index
Definition: gxfenc.c:72
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264.h:407
static const uint8_t chroma_dc_scan[4]
Definition: h264data.h:61
#define IS_8X16(a)
Definition: mpegutils.h:84
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:325
int pixel_shift
0 for 8-bit H264, 1 for high-bit-depth H264
Definition: h264.h:318
#define GET_CACHE(name, gb)
Definition: get_bits.h:192
#define MB_TYPE_16x16
Definition: avcodec.h:778
static const int total_zeros_vlc_tables_size
Definition: h264_cavlc.c:252
#define IS_INTER(a)
Definition: mpegutils.h:75
static const uint8_t chroma422_dc_total_zeros_bits[7][8]
Definition: h264_cavlc.c:208
static const PMbInfo b_mb_type_info[23]
Definition: h264data.h:128
static const int coeff_token_vlc_tables_size[4]
Definition: h264_cavlc.c:240
static int pred_non_zero_count(H264Context *h, int n)
Get the predicted number of non-zero coefficients.
Definition: h264_cavlc.c:286
static const int run7_vlc_table_size
Definition: h264_cavlc.c:268
static const PMbInfo p_mb_type_info[5]
Definition: h264data.h:113
static const PMbInfo p_sub_mb_type_info[4]
Definition: h264data.h:121
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264.h:234
uint8_t zigzag_scan[16]
Definition: h264.h:483
uint8_t level
Definition: svq3.c:147
#define AV_ZERO128(d)
Definition: intreadwrite.h:542
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2]
Definition: h264_cavlc.c:247
int qscale
Definition: h264.h:328
#define tprintf(p,...)
Definition: get_bits.h:626
uint8_t cbp
Definition: h264data.h:76
common internal api header.
const uint8_t * intra_pcm_ptr
Definition: h264.h:459
H.264 / AVC / MPEG4 part10 motion vector predicion.
Bi-dir predicted.
Definition: avutil.h:255
int chroma_qp[2]
Definition: h264.h:319
static const uint8_t golomb_to_inter_cbp[48]
Definition: h264data.h:48
#define MB_TYPE_16x8
Definition: avcodec.h:779
uint16_t sub_mb_type[4]
Definition: h264.h:422
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:209
static av_always_inline void write_back_intra_pred_mode(H264Context *h)
Definition: h264.h:928
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:343
#define IS_INTRA(x, y)
#define CHROMA_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:273
#define IS_INTRA4x4(a)
Definition: mpegutils.h:71
static VLC run7_vlc
Definition: h264_cavlc.c:266
float re
Definition: fft-test.c:69
#define FRAME_MBAFF(h)
Definition: h264.h:71
const uint16_t ff_h264_mb_sizes[4]
Definition: h264.c:52
static const int run_vlc_tables_size
Definition: h264_cavlc.c:264
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264.h:371
#define av_log2
Definition: intmath.h:85
static VLC run_vlc[6]
Definition: h264_cavlc.c:262
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
H264Picture cur_pic
Definition: h264.h:316
static const uint8_t chroma_dc_total_zeros_len[3][4]
Definition: h264_cavlc.c:186
static int get_level_prefix(GetBitContext *gb)
Definition: h264_cavlc.c:417
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:416
const uint8_t * field_scan_q0
Definition: h264.h:492
uint16_t type
Definition: h264data.h:74
#define av_always_inline
Definition: attributes.h:40
static const uint8_t golomb_to_inter_cbp_gray[16]
Definition: h264_cavlc.c:40
static VLC_TYPE run_vlc_tables[6][8][2]
Definition: h264_cavlc.c:263
#define LIST_NOT_USED
Definition: h264.h:380
uint8_t(* non_zero_count)[48]
Definition: h264.h:373
exp golomb vlc stuff
int slice_num
Definition: h264.h:409
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:243
uint8_t field_scan[16]
Definition: h264.h:486
Predicted.
Definition: avutil.h:254
#define MB_TYPE_8x8DCT
Definition: h264.h:101
#define STORE_BLOCK(type)
int8_t ref_cache[2][5 *8]
Definition: h264.h:379
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264.h:418
static int16_t block[64]
Definition: dct-test.c:88