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  zeros_left -= run_before; \
587  scantable -= 1 + run_before; \
588  ((type*)block)[*scantable]= level[i]; \
589  } \
590  for(;i<total_coeff;i++) { \
591  scantable--; \
592  ((type*)block)[*scantable]= level[i]; \
593  } \
594  }else{ \
595  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
596  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
597  if(zeros_left < 7) \
598  run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
599  else \
600  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
601  zeros_left -= run_before; \
602  scantable -= 1 + run_before; \
603  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
604  } \
605  for(;i<total_coeff;i++) { \
606  scantable--; \
607  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
608  } \
609  }
610 
611  if (zeros_left < 0) {
613  "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
614  return AVERROR_INVALIDDATA;
615  }
616 
617  if (h->pixel_shift) {
619  } else {
620  STORE_BLOCK(int16_t)
621  }
622 
623  return 0;
624 }
625 
626 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){
627  int i4x4, i8x8;
628  int qscale = p == 0 ? h->qscale : h->chroma_qp[p-1];
629  if(IS_INTRA16x16(mb_type)){
630  AV_ZERO128(h->mb_luma_dc[p]+0);
631  AV_ZERO128(h->mb_luma_dc[p]+8);
632  AV_ZERO128(h->mb_luma_dc[p]+16);
633  AV_ZERO128(h->mb_luma_dc[p]+24);
634  if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX+p, scan, NULL, 16) < 0){
635  return -1; //FIXME continue if partitioned and other return -1 too
636  }
637 
638  assert((cbp&15) == 0 || (cbp&15) == 15);
639 
640  if(cbp&15){
641  for(i8x8=0; i8x8<4; i8x8++){
642  for(i4x4=0; i4x4<4; i4x4++){
643  const int index= i4x4 + 4*i8x8 + p*16;
644  if( decode_residual(h, h->intra_gb_ptr, h->mb + (16*index << pixel_shift),
645  index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
646  return -1;
647  }
648  }
649  }
650  return 0xf;
651  }else{
652  fill_rectangle(&h->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
653  return 0;
654  }
655  }else{
656  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
657  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
658  int new_cbp = 0;
659  for(i8x8=0; i8x8<4; i8x8++){
660  if(cbp & (1<<i8x8)){
661  if(IS_8x8DCT(mb_type)){
662  int16_t *buf = &h->mb[64*i8x8+256*p << pixel_shift];
663  uint8_t *nnz;
664  for(i4x4=0; i4x4<4; i4x4++){
665  const int index= i4x4 + 4*i8x8 + p*16;
666  if( decode_residual(h, gb, buf, index, scan8x8+16*i4x4,
667  h->dequant8_coeff[cqm][qscale], 16) < 0 )
668  return -1;
669  }
670  nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
671  nnz[0] += nnz[1] + nnz[8] + nnz[9];
672  new_cbp |= !!nnz[0] << i8x8;
673  }else{
674  for(i4x4=0; i4x4<4; i4x4++){
675  const int index= i4x4 + 4*i8x8 + p*16;
676  if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index,
677  scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
678  return -1;
679  }
680  new_cbp |= h->non_zero_count_cache[ scan8[index] ] << i8x8;
681  }
682  }
683  }else{
684  uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
685  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
686  }
687  }
688  return new_cbp;
689  }
690 }
691 
693  int mb_xy;
694  int partition_count;
695  unsigned int mb_type, cbp;
696  int dct8x8_allowed= h->pps.transform_8x8_mode;
697  int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
698  const int pixel_shift = h->pixel_shift;
699 
700  mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
701 
702  tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
703  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
704  down the code */
706  if(h->mb_skip_run==-1)
707  h->mb_skip_run= get_ue_golomb(&h->gb);
708 
709  if (h->mb_skip_run--) {
710  if(FRAME_MBAFF(h) && (h->mb_y&1) == 0){
711  if(h->mb_skip_run==0)
713  }
714  decode_mb_skip(h);
715  return 0;
716  }
717  }
718  if (FRAME_MBAFF(h)) {
719  if( (h->mb_y&1) == 0 )
721  }
722 
723  h->prev_mb_skipped= 0;
724 
725  mb_type= get_ue_golomb(&h->gb);
727  if(mb_type < 23){
728  partition_count= b_mb_type_info[mb_type].partition_count;
729  mb_type= b_mb_type_info[mb_type].type;
730  }else{
731  mb_type -= 23;
732  goto decode_intra_mb;
733  }
734  }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
735  if(mb_type < 5){
736  partition_count= p_mb_type_info[mb_type].partition_count;
737  mb_type= p_mb_type_info[mb_type].type;
738  }else{
739  mb_type -= 5;
740  goto decode_intra_mb;
741  }
742  }else{
743  assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
744  if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
745  mb_type--;
746 decode_intra_mb:
747  if(mb_type > 25){
748  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);
749  return -1;
750  }
751  partition_count=0;
752  cbp= i_mb_type_info[mb_type].cbp;
754  mb_type= i_mb_type_info[mb_type].type;
755  }
756 
757  if(MB_FIELD(h))
758  mb_type |= MB_TYPE_INTERLACED;
759 
760  h->slice_table[ mb_xy ]= h->slice_num;
761 
762  if(IS_INTRA_PCM(mb_type)){
763  const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
764  h->sps.bit_depth_luma;
765 
766  // We assume these blocks are very rare so we do not optimize it.
767  h->intra_pcm_ptr = align_get_bits(&h->gb);
768  if (get_bits_left(&h->gb) < mb_size) {
769  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
770  return AVERROR_INVALIDDATA;
771  }
772  skip_bits_long(&h->gb, mb_size);
773 
774  // In deblocking, the quantizer is 0
775  h->cur_pic.qscale_table[mb_xy] = 0;
776  // All coeffs are present
777  memset(h->non_zero_count[mb_xy], 16, 48);
778 
779  h->cur_pic.mb_type[mb_xy] = mb_type;
780  return 0;
781  }
782 
783  fill_decode_neighbors(h, mb_type);
784  fill_decode_caches(h, mb_type);
785 
786  //mb_pred
787  if(IS_INTRA(mb_type)){
788  int pred_mode;
789 // init_top_left_availability(h);
790  if(IS_INTRA4x4(mb_type)){
791  int i;
792  int di = 1;
793  if(dct8x8_allowed && get_bits1(&h->gb)){
794  mb_type |= MB_TYPE_8x8DCT;
795  di = 4;
796  }
797 
798 // fill_intra4x4_pred_table(h);
799  for(i=0; i<16; i+=di){
800  int mode= pred_intra_mode(h, i);
801 
802  if(!get_bits1(&h->gb)){
803  const int rem_mode= get_bits(&h->gb, 3);
804  mode = rem_mode + (rem_mode >= mode);
805  }
806 
807  if(di==4)
808  fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
809  else
810  h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
811  }
814  return -1;
815  }else{
817  if(h->intra16x16_pred_mode < 0)
818  return -1;
819  }
820  if(decode_chroma){
821  pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&h->gb), 1);
822  if(pred_mode < 0)
823  return -1;
824  h->chroma_pred_mode= pred_mode;
825  } else {
827  }
828  }else if(partition_count==4){
829  int i, j, sub_partition_count[4], list, ref[2][4];
830 
832  for(i=0; i<4; i++){
833  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
834  if(h->sub_mb_type[i] >=13){
835  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);
836  return -1;
837  }
838  sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
840  }
841  if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
842  ff_h264_pred_direct_motion(h, &mb_type);
843  h->ref_cache[0][scan8[4]] =
844  h->ref_cache[1][scan8[4]] =
845  h->ref_cache[0][scan8[12]] =
846  h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
847  }
848  }else{
849  assert(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
850  for(i=0; i<4; i++){
851  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
852  if(h->sub_mb_type[i] >=4){
853  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);
854  return -1;
855  }
856  sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
858  }
859  }
860 
861  for(list=0; list<h->list_count; list++){
862  int ref_count = IS_REF0(mb_type) ? 1 : h->ref_count[list] << MB_MBAFF(h);
863  for(i=0; i<4; i++){
864  if(IS_DIRECT(h->sub_mb_type[i])) continue;
865  if(IS_DIR(h->sub_mb_type[i], 0, list)){
866  unsigned int tmp;
867  if(ref_count == 1){
868  tmp= 0;
869  }else if(ref_count == 2){
870  tmp= get_bits1(&h->gb)^1;
871  }else{
872  tmp= get_ue_golomb_31(&h->gb);
873  if(tmp>=ref_count){
874  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
875  return -1;
876  }
877  }
878  ref[list][i]= tmp;
879  }else{
880  //FIXME
881  ref[list][i] = -1;
882  }
883  }
884  }
885 
886  if(dct8x8_allowed)
887  dct8x8_allowed = get_dct8x8_allowed(h);
888 
889  for(list=0; list<h->list_count; list++){
890  for(i=0; i<4; i++){
891  if(IS_DIRECT(h->sub_mb_type[i])) {
892  h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
893  continue;
894  }
895  h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
896  h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
897 
898  if(IS_DIR(h->sub_mb_type[i], 0, list)){
899  const int sub_mb_type= h->sub_mb_type[i];
900  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
901  for(j=0; j<sub_partition_count[i]; j++){
902  int mx, my;
903  const int index= 4*i + block_width*j;
904  int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
905  pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
906  mx += get_se_golomb(&h->gb);
907  my += get_se_golomb(&h->gb);
908  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
909 
910  if(IS_SUB_8X8(sub_mb_type)){
911  mv_cache[ 1 ][0]=
912  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
913  mv_cache[ 1 ][1]=
914  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
915  }else if(IS_SUB_8X4(sub_mb_type)){
916  mv_cache[ 1 ][0]= mx;
917  mv_cache[ 1 ][1]= my;
918  }else if(IS_SUB_4X8(sub_mb_type)){
919  mv_cache[ 8 ][0]= mx;
920  mv_cache[ 8 ][1]= my;
921  }
922  mv_cache[ 0 ][0]= mx;
923  mv_cache[ 0 ][1]= my;
924  }
925  }else{
926  uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
927  p[0] = p[1]=
928  p[8] = p[9]= 0;
929  }
930  }
931  }
932  }else if(IS_DIRECT(mb_type)){
933  ff_h264_pred_direct_motion(h, &mb_type);
934  dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
935  }else{
936  int list, mx, my, i;
937  //FIXME we should set ref_idx_l? to 0 if we use that later ...
938  if(IS_16X16(mb_type)){
939  for(list=0; list<h->list_count; list++){
940  unsigned int val;
941  if(IS_DIR(mb_type, 0, list)){
942  int rc = h->ref_count[list] << MB_MBAFF(h);
943  if (rc == 1) {
944  val= 0;
945  } else if (rc == 2) {
946  val= get_bits1(&h->gb)^1;
947  }else{
948  val= get_ue_golomb_31(&h->gb);
949  if (val >= rc) {
950  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
951  return -1;
952  }
953  }
954  fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
955  }
956  }
957  for(list=0; list<h->list_count; list++){
958  if(IS_DIR(mb_type, 0, list)){
959  pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
960  mx += get_se_golomb(&h->gb);
961  my += get_se_golomb(&h->gb);
962  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
963 
964  fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
965  }
966  }
967  }
968  else if(IS_16X8(mb_type)){
969  for(list=0; list<h->list_count; list++){
970  for(i=0; i<2; i++){
971  unsigned int val;
972  if(IS_DIR(mb_type, i, list)){
973  int rc = h->ref_count[list] << MB_MBAFF(h);
974  if (rc == 1) {
975  val= 0;
976  } else if (rc == 2) {
977  val= get_bits1(&h->gb)^1;
978  }else{
979  val= get_ue_golomb_31(&h->gb);
980  if (val >= rc) {
981  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
982  return -1;
983  }
984  }
985  }else
986  val= LIST_NOT_USED&0xFF;
987  fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
988  }
989  }
990  for(list=0; list<h->list_count; list++){
991  for(i=0; i<2; i++){
992  unsigned int val;
993  if(IS_DIR(mb_type, i, list)){
994  pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
995  mx += get_se_golomb(&h->gb);
996  my += get_se_golomb(&h->gb);
997  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
998 
999  val= pack16to32(mx,my);
1000  }else
1001  val=0;
1002  fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1003  }
1004  }
1005  }else{
1006  assert(IS_8X16(mb_type));
1007  for(list=0; list<h->list_count; list++){
1008  for(i=0; i<2; i++){
1009  unsigned int val;
1010  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1011  int rc = h->ref_count[list] << MB_MBAFF(h);
1012  if (rc == 1) {
1013  val= 0;
1014  } else if (rc == 2) {
1015  val= get_bits1(&h->gb)^1;
1016  }else{
1017  val= get_ue_golomb_31(&h->gb);
1018  if (val >= rc) {
1019  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1020  return -1;
1021  }
1022  }
1023  }else
1024  val= LIST_NOT_USED&0xFF;
1025  fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1026  }
1027  }
1028  for(list=0; list<h->list_count; list++){
1029  for(i=0; i<2; i++){
1030  unsigned int val;
1031  if(IS_DIR(mb_type, i, list)){
1032  pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1033  mx += get_se_golomb(&h->gb);
1034  my += get_se_golomb(&h->gb);
1035  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1036 
1037  val= pack16to32(mx,my);
1038  }else
1039  val=0;
1040  fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1041  }
1042  }
1043  }
1044  }
1045 
1046  if(IS_INTER(mb_type))
1047  write_back_motion(h, mb_type);
1048 
1049  if(!IS_INTRA16x16(mb_type)){
1050  cbp= get_ue_golomb(&h->gb);
1051 
1052  if(decode_chroma){
1053  if(cbp > 47){
1054  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
1055  return -1;
1056  }
1057  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
1058  else cbp= golomb_to_inter_cbp [cbp];
1059  }else{
1060  if(cbp > 15){
1061  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
1062  return -1;
1063  }
1064  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1065  else cbp= golomb_to_inter_cbp_gray[cbp];
1066  }
1067  }
1068 
1069  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1070  mb_type |= MB_TYPE_8x8DCT*get_bits1(&h->gb);
1071  }
1072  h->cbp=
1073  h->cbp_table[mb_xy]= cbp;
1074  h->cur_pic.mb_type[mb_xy] = mb_type;
1075 
1076  if(cbp || IS_INTRA16x16(mb_type)){
1077  int i4x4, i8x8, chroma_idx;
1078  int dquant;
1079  int ret;
1080  GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
1081  const uint8_t *scan, *scan8x8;
1082  const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1083 
1084  if(IS_INTERLACED(mb_type)){
1085  scan8x8= h->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1086  scan= h->qscale ? h->field_scan : h->field_scan_q0;
1087  }else{
1088  scan8x8= h->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1089  scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1090  }
1091 
1092  dquant= get_se_golomb(&h->gb);
1093 
1094  h->qscale += dquant;
1095 
1096  if(((unsigned)h->qscale) > max_qp){
1097  if(h->qscale<0) h->qscale+= max_qp+1;
1098  else h->qscale-= max_qp+1;
1099  if(((unsigned)h->qscale) > max_qp){
1100  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, h->mb_x, h->mb_y);
1101  return -1;
1102  }
1103  }
1104 
1105  h->chroma_qp[0]= get_chroma_qp(h, 0, h->qscale);
1106  h->chroma_qp[1]= get_chroma_qp(h, 1, h->qscale);
1107 
1108  if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
1109  return -1;
1110  }
1111  h->cbp_table[mb_xy] |= ret << 12;
1112  if (CHROMA444(h)) {
1113  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
1114  return -1;
1115  }
1116  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
1117  return -1;
1118  }
1119  } else if (CHROMA422(h)) {
1120  if(cbp&0x30){
1121  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1122  if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1124  NULL, 8) < 0) {
1125  return -1;
1126  }
1127  }
1128 
1129  if(cbp&0x20){
1130  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1131  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1132  int16_t *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1133  for (i8x8 = 0; i8x8 < 2; i8x8++) {
1134  for (i4x4 = 0; i4x4 < 4; i4x4++) {
1135  const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1136  if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
1137  return -1;
1138  mb += 16 << pixel_shift;
1139  }
1140  }
1141  }
1142  }else{
1143  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1144  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1145  }
1146  } else /* yuv420 */ {
1147  if(cbp&0x30){
1148  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1149  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){
1150  return -1;
1151  }
1152  }
1153 
1154  if(cbp&0x20){
1155  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1156  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1157  for(i4x4=0; i4x4<4; i4x4++){
1158  const int index= 16 + 16*chroma_idx + i4x4;
1159  if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
1160  return -1;
1161  }
1162  }
1163  }
1164  }else{
1165  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1166  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1167  }
1168  }
1169  }else{
1170  fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
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  h->cur_pic.qscale_table[mb_xy] = h->qscale;
1176 
1177  return 0;
1178 }
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:626
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:692
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