FFmpeg
h264_cavlc.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * H.264 / AVC / MPEG-4 part10 cavlc bitstream decoding.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27 
28 #define CABAC(h) 0
29 #define UNCHECKED_BITSTREAM_READER 1
30 
31 #include "internal.h"
32 #include "avcodec.h"
33 #include "h264dec.h"
34 #include "h264_mvpred.h"
35 #include "h264data.h"
36 #include "golomb.h"
37 #include "mpegutils.h"
38 #include "libavutil/avassert.h"
39 
40 
42  0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
43 };
44 
46 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
47 };
48 
50  2, 0, 0, 0,
51  6, 1, 0, 0,
52  6, 6, 3, 0,
53  6, 7, 7, 6,
54  6, 8, 8, 7,
55 };
56 
58  1, 0, 0, 0,
59  7, 1, 0, 0,
60  4, 6, 1, 0,
61  3, 3, 2, 5,
62  2, 3, 2, 0,
63 };
64 
66  1, 0, 0, 0,
67  7, 2, 0, 0,
68  7, 7, 3, 0,
69  9, 7, 7, 5,
70  9, 9, 7, 6,
71  10, 10, 9, 7,
72  11, 11, 10, 7,
73  12, 12, 11, 10,
74  13, 12, 12, 11,
75 };
76 
78  1, 0, 0, 0,
79  15, 1, 0, 0,
80  14, 13, 1, 0,
81  7, 12, 11, 1,
82  6, 5, 10, 1,
83  7, 6, 4, 9,
84  7, 6, 5, 8,
85  7, 6, 5, 4,
86  7, 5, 4, 4,
87 };
88 
89 static const uint8_t coeff_token_len[4][4*17]={
90 {
91  1, 0, 0, 0,
92  6, 2, 0, 0, 8, 6, 3, 0, 9, 8, 7, 5, 10, 9, 8, 6,
93  11,10, 9, 7, 13,11,10, 8, 13,13,11, 9, 13,13,13,10,
94  14,14,13,11, 14,14,14,13, 15,15,14,14, 15,15,15,14,
95  16,15,15,15, 16,16,16,15, 16,16,16,16, 16,16,16,16,
96 },
97 {
98  2, 0, 0, 0,
99  6, 2, 0, 0, 6, 5, 3, 0, 7, 6, 6, 4, 8, 6, 6, 4,
100  8, 7, 7, 5, 9, 8, 8, 6, 11, 9, 9, 6, 11,11,11, 7,
101  12,11,11, 9, 12,12,12,11, 12,12,12,11, 13,13,13,12,
102  13,13,13,13, 13,14,13,13, 14,14,14,13, 14,14,14,14,
103 },
104 {
105  4, 0, 0, 0,
106  6, 4, 0, 0, 6, 5, 4, 0, 6, 5, 5, 4, 7, 5, 5, 4,
107  7, 5, 5, 4, 7, 6, 6, 4, 7, 6, 6, 4, 8, 7, 7, 5,
108  8, 8, 7, 6, 9, 8, 8, 7, 9, 9, 8, 8, 9, 9, 9, 8,
109  10, 9, 9, 9, 10,10,10,10, 10,10,10,10, 10,10,10,10,
110 },
111 {
112  6, 0, 0, 0,
113  6, 6, 0, 0, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6,
114  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
115  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
116  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
117 }
118 };
119 
120 static const uint8_t coeff_token_bits[4][4*17]={
121 {
122  1, 0, 0, 0,
123  5, 1, 0, 0, 7, 4, 1, 0, 7, 6, 5, 3, 7, 6, 5, 3,
124  7, 6, 5, 4, 15, 6, 5, 4, 11,14, 5, 4, 8,10,13, 4,
125  15,14, 9, 4, 11,10,13,12, 15,14, 9,12, 11,10,13, 8,
126  15, 1, 9,12, 11,14,13, 8, 7,10, 9,12, 4, 6, 5, 8,
127 },
128 {
129  3, 0, 0, 0,
130  11, 2, 0, 0, 7, 7, 3, 0, 7,10, 9, 5, 7, 6, 5, 4,
131  4, 6, 5, 6, 7, 6, 5, 8, 15, 6, 5, 4, 11,14,13, 4,
132  15,10, 9, 4, 11,14,13,12, 8,10, 9, 8, 15,14,13,12,
133  11,10, 9,12, 7,11, 6, 8, 9, 8,10, 1, 7, 6, 5, 4,
134 },
135 {
136  15, 0, 0, 0,
137  15,14, 0, 0, 11,15,13, 0, 8,12,14,12, 15,10,11,11,
138  11, 8, 9,10, 9,14,13, 9, 8,10, 9, 8, 15,14,13,13,
139  11,14,10,12, 15,10,13,12, 11,14, 9,12, 8,10,13, 8,
140  13, 7, 9,12, 9,12,11,10, 5, 8, 7, 6, 1, 4, 3, 2,
141 },
142 {
143  3, 0, 0, 0,
144  0, 1, 0, 0, 4, 5, 6, 0, 8, 9,10,11, 12,13,14,15,
145  16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31,
146  32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47,
147  48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63,
148 }
149 };
150 
151 static const uint8_t total_zeros_len[16][16]= {
152  {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
153  {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
154  {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
155  {5,3,4,4,3,3,3,4,3,4,5,5,5},
156  {4,4,4,3,3,3,3,3,4,5,4,5},
157  {6,5,3,3,3,3,3,3,4,3,6},
158  {6,5,3,3,3,2,3,4,3,6},
159  {6,4,5,3,2,2,3,3,6},
160  {6,6,4,2,2,3,2,5},
161  {5,5,3,2,2,2,4},
162  {4,4,3,3,1,3},
163  {4,4,2,1,3},
164  {3,3,1,2},
165  {2,2,1},
166  {1,1},
167 };
168 
169 static const uint8_t total_zeros_bits[16][16]= {
170  {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
171  {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
172  {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
173  {3,7,5,4,6,5,4,3,3,2,2,1,0},
174  {5,4,3,7,6,5,4,3,2,1,1,0},
175  {1,1,7,6,5,4,3,2,1,1,0},
176  {1,1,5,4,3,3,2,1,1,0},
177  {1,1,1,3,3,2,2,1,0},
178  {1,0,1,3,2,1,1,1},
179  {1,0,1,3,2,1,1},
180  {0,1,1,2,1,3},
181  {0,1,1,1,1},
182  {0,1,1,1},
183  {0,1,1},
184  {0,1},
185 };
186 
187 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
188  { 1, 2, 3, 3,},
189  { 1, 2, 2, 0,},
190  { 1, 1, 0, 0,},
191 };
192 
193 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
194  { 1, 1, 1, 0,},
195  { 1, 1, 0, 0,},
196  { 1, 0, 0, 0,},
197 };
198 
200  { 1, 3, 3, 4, 4, 4, 5, 5 },
201  { 3, 2, 3, 3, 3, 3, 3 },
202  { 3, 3, 2, 2, 3, 3 },
203  { 3, 2, 2, 2, 3 },
204  { 2, 2, 2, 2 },
205  { 2, 2, 1 },
206  { 1, 1 },
207 };
208 
210  { 1, 2, 3, 2, 3, 1, 1, 0 },
211  { 0, 1, 1, 4, 5, 6, 7 },
212  { 0, 1, 1, 2, 6, 7 },
213  { 6, 0, 1, 2, 7 },
214  { 0, 1, 2, 3 },
215  { 0, 1, 1 },
216  { 0, 1 },
217 };
218 
219 static const uint8_t run_len[7][16]={
220  {1,1},
221  {1,2,2},
222  {2,2,2,2},
223  {2,2,2,3,3},
224  {2,2,3,3,3,3},
225  {2,3,3,3,3,3,3},
226  {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
227 };
228 
229 static const uint8_t run_bits[7][16]={
230  {1,0},
231  {1,1,0},
232  {3,2,1,0},
233  {3,2,1,1,0},
234  {3,2,3,2,1,0},
235  {3,0,1,3,2,5,4},
236  {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
237 };
238 
240 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
241 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
242 
246 
250 
251 static VLC total_zeros_vlc[15+1];
252 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
253 static const int total_zeros_vlc_tables_size = 512;
254 
258 
262 
263 static VLC run_vlc[6+1];
264 static VLC_TYPE run_vlc_tables[6][8][2];
265 static const int run_vlc_tables_size = 8;
266 
267 static VLC run7_vlc;
268 static VLC_TYPE run7_vlc_table[96][2];
269 static const int run7_vlc_table_size = 96;
270 
271 #define LEVEL_TAB_BITS 8
272 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
273 
274 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
275 #define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
276 #define COEFF_TOKEN_VLC_BITS 8
277 #define TOTAL_ZEROS_VLC_BITS 9
278 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
279 #define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
280 #define RUN_VLC_BITS 3
281 #define RUN7_VLC_BITS 6
282 
283 /**
284  * Get the predicted number of non-zero coefficients.
285  * @param n block index
286  */
287 static inline int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
288 {
289  const int index8= scan8[n];
290  const int left = sl->non_zero_count_cache[index8 - 1];
291  const int top = sl->non_zero_count_cache[index8 - 8];
292  int i= left + top;
293 
294  if(i<64) i= (i+1)>>1;
295 
296  ff_tlog(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
297 
298  return i&31;
299 }
300 
301 static av_cold void init_cavlc_level_tab(void){
302  int suffix_length;
303  unsigned int i;
304 
305  for(suffix_length=0; suffix_length<7; suffix_length++){
306  for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
307  int prefix= LEVEL_TAB_BITS - av_log2(2*i);
308 
309  if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
310  int level_code = (prefix << suffix_length) +
311  (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
312  int mask = -(level_code&1);
313  level_code = (((2 + level_code) >> 1) ^ mask) - mask;
314  cavlc_level_tab[suffix_length][i][0]= level_code;
315  cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
316  }else if(prefix + 1 <= LEVEL_TAB_BITS){
317  cavlc_level_tab[suffix_length][i][0]= prefix+100;
318  cavlc_level_tab[suffix_length][i][1]= prefix + 1;
319  }else{
320  cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
321  cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
322  }
323  }
324  }
325 }
326 
328  static int done = 0;
329 
330  if (!done) {
331  int i;
332  int offset;
333  done = 1;
334 
335  chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
336  chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
337  init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
338  &chroma_dc_coeff_token_len [0], 1, 1,
339  &chroma_dc_coeff_token_bits[0], 1, 1,
341 
342  chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
343  chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
344  init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
345  &chroma422_dc_coeff_token_len [0], 1, 1,
348 
349  offset = 0;
350  for(i=0; i<4; i++){
351  coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
352  coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
353  init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
354  &coeff_token_len [i][0], 1, 1,
355  &coeff_token_bits[i][0], 1, 1,
357  offset += coeff_token_vlc_tables_size[i];
358  }
359  /*
360  * This is a one time safety check to make sure that
361  * the packed static coeff_token_vlc table sizes
362  * were initialized correctly.
363  */
365 
366  for(i=0; i<3; i++){
367  chroma_dc_total_zeros_vlc[i+1].table = chroma_dc_total_zeros_vlc_tables[i];
368  chroma_dc_total_zeros_vlc[i+1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
369  init_vlc(&chroma_dc_total_zeros_vlc[i+1],
371  &chroma_dc_total_zeros_len [i][0], 1, 1,
372  &chroma_dc_total_zeros_bits[i][0], 1, 1,
374  }
375 
376  for(i=0; i<7; i++){
377  chroma422_dc_total_zeros_vlc[i+1].table = chroma422_dc_total_zeros_vlc_tables[i];
378  chroma422_dc_total_zeros_vlc[i+1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
379  init_vlc(&chroma422_dc_total_zeros_vlc[i+1],
381  &chroma422_dc_total_zeros_len [i][0], 1, 1,
382  &chroma422_dc_total_zeros_bits[i][0], 1, 1,
384  }
385 
386  for(i=0; i<15; i++){
387  total_zeros_vlc[i+1].table = total_zeros_vlc_tables[i];
388  total_zeros_vlc[i+1].table_allocated = total_zeros_vlc_tables_size;
389  init_vlc(&total_zeros_vlc[i+1],
391  &total_zeros_len [i][0], 1, 1,
392  &total_zeros_bits[i][0], 1, 1,
394  }
395 
396  for(i=0; i<6; i++){
397  run_vlc[i+1].table = run_vlc_tables[i];
398  run_vlc[i+1].table_allocated = run_vlc_tables_size;
399  init_vlc(&run_vlc[i+1],
400  RUN_VLC_BITS, 7,
401  &run_len [i][0], 1, 1,
402  &run_bits[i][0], 1, 1,
404  }
405  run7_vlc.table = run7_vlc_table,
407  init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
408  &run_len [6][0], 1, 1,
409  &run_bits[6][0], 1, 1,
411 
413  }
414 }
415 
416 static inline int get_level_prefix(GetBitContext *gb){
417  unsigned int buf;
418  int log;
419 
420  OPEN_READER(re, gb);
421  UPDATE_CACHE(re, gb);
422  buf=GET_CACHE(re, gb);
423 
424  log= 32 - av_log2(buf);
425 
426  LAST_SKIP_BITS(re, gb, log);
427  CLOSE_READER(re, gb);
428 
429  return log-1;
430 }
431 
432 /**
433  * Decode a residual block.
434  * @param n block index
435  * @param scantable scantable
436  * @param max_coeff number of coefficients in the block
437  * @return <0 if an error occurred
438  */
440  GetBitContext *gb, int16_t *block, int n,
441  const uint8_t *scantable, const uint32_t *qmul,
442  int max_coeff)
443 {
444  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};
445  int level[16];
446  int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
447 
448  //FIXME put trailing_onex into the context
449 
450  if(max_coeff <= 8){
451  if (max_coeff == 4)
452  coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
453  else
454  coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
455  total_coeff= coeff_token>>2;
456  }else{
457  if(n >= LUMA_DC_BLOCK_INDEX){
458  total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
459  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
460  total_coeff= coeff_token>>2;
461  }else{
462  total_coeff= pred_non_zero_count(h, sl, n);
463  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
464  total_coeff= coeff_token>>2;
465  }
466  }
467  sl->non_zero_count_cache[scan8[n]] = total_coeff;
468 
469  //FIXME set last_non_zero?
470 
471  if(total_coeff==0)
472  return 0;
473  if(total_coeff > (unsigned)max_coeff) {
474  av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
475  return -1;
476  }
477 
478  trailing_ones= coeff_token&3;
479  ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
480  av_assert2(total_coeff<=16);
481 
482  i = show_bits(gb, 3);
483  skip_bits(gb, trailing_ones);
484  level[0] = 1-((i&4)>>1);
485  level[1] = 1-((i&2) );
486  level[2] = 1-((i&1)<<1);
487 
488  if(trailing_ones<total_coeff) {
489  int mask, prefix;
490  int suffix_length = total_coeff > 10 & trailing_ones < 3;
491  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
492  int level_code= cavlc_level_tab[suffix_length][bitsi][0];
493 
494  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
495  if(level_code >= 100){
496  prefix= level_code - 100;
497  if(prefix == LEVEL_TAB_BITS)
498  prefix += get_level_prefix(gb);
499 
500  //first coefficient has suffix_length equal to 0 or 1
501  if(prefix<14){ //FIXME try to build a large unified VLC table for all this
502  if(suffix_length)
503  level_code= (prefix<<1) + get_bits1(gb); //part
504  else
505  level_code= prefix; //part
506  }else if(prefix==14){
507  if(suffix_length)
508  level_code= (prefix<<1) + get_bits1(gb); //part
509  else
510  level_code= prefix + get_bits(gb, 4); //part
511  }else{
512  level_code= 30;
513  if(prefix>=16){
514  if(prefix > 25+3){
515  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
516  return -1;
517  }
518  level_code += (1<<(prefix-3))-4096;
519  }
520  level_code += get_bits(gb, prefix-3); //part
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;
551  if (prefix>=16) {
552  if(prefix > 25+3){
553  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
554  return AVERROR_INVALIDDATA;
555  }
556  level_code += (1<<(prefix-3))-4096;
557  }
558  level_code += get_bits(gb, prefix-3);
559  }
560  mask= -(level_code&1);
561  level_code= (((2+level_code)>>1) ^ mask) - mask;
562  }
563  level[i]= level_code;
564  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
565  }
566  }
567 
568  if(total_coeff == max_coeff)
569  zeros_left=0;
570  else{
571  if (max_coeff <= 8) {
572  if (max_coeff == 4)
573  zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
575  else
576  zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
578  } else {
579  zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
580  }
581  }
582 
583 #define STORE_BLOCK(type) \
584  scantable += zeros_left + total_coeff - 1; \
585  if(n >= LUMA_DC_BLOCK_INDEX){ \
586  ((type*)block)[*scantable] = level[0]; \
587  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
588  if(zeros_left < 7) \
589  run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
590  else \
591  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
592  zeros_left -= run_before; \
593  scantable -= 1 + run_before; \
594  ((type*)block)[*scantable]= level[i]; \
595  } \
596  for(;i<total_coeff;i++) { \
597  scantable--; \
598  ((type*)block)[*scantable]= level[i]; \
599  } \
600  }else{ \
601  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
602  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
603  if(zeros_left < 7) \
604  run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
605  else \
606  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
607  zeros_left -= run_before; \
608  scantable -= 1 + run_before; \
609  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
610  } \
611  for(;i<total_coeff;i++) { \
612  scantable--; \
613  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
614  } \
615  }
616 
617  if (h->pixel_shift) {
619  } else {
620  STORE_BLOCK(int16_t)
621  }
622 
623  if(zeros_left<0){
624  av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
625  return -1;
626  }
627 
628  return 0;
629 }
630 
631 static av_always_inline
633  GetBitContext *gb, const uint8_t *scan,
634  const uint8_t *scan8x8, int pixel_shift,
635  int mb_type, int cbp, int p)
636 {
637  int i4x4, i8x8;
638  int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
639  if(IS_INTRA16x16(mb_type)){
640  AV_ZERO128(sl->mb_luma_dc[p]+0);
641  AV_ZERO128(sl->mb_luma_dc[p]+8);
642  AV_ZERO128(sl->mb_luma_dc[p]+16);
643  AV_ZERO128(sl->mb_luma_dc[p]+24);
644  if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
645  return -1; //FIXME continue if partitioned and other return -1 too
646  }
647 
648  av_assert2((cbp&15) == 0 || (cbp&15) == 15);
649 
650  if(cbp&15){
651  for(i8x8=0; i8x8<4; i8x8++){
652  for(i4x4=0; i4x4<4; i4x4++){
653  const int index= i4x4 + 4*i8x8 + p*16;
654  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
655  index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
656  return -1;
657  }
658  }
659  }
660  return 0xf;
661  }else{
662  fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
663  return 0;
664  }
665  }else{
666  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
667  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
668  int new_cbp = 0;
669  for(i8x8=0; i8x8<4; i8x8++){
670  if(cbp & (1<<i8x8)){
671  if(IS_8x8DCT(mb_type)){
672  int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
673  uint8_t *nnz;
674  for(i4x4=0; i4x4<4; i4x4++){
675  const int index= i4x4 + 4*i8x8 + p*16;
676  if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
677  h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
678  return -1;
679  }
680  nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
681  nnz[0] += nnz[1] + nnz[8] + nnz[9];
682  new_cbp |= !!nnz[0] << i8x8;
683  }else{
684  for(i4x4=0; i4x4<4; i4x4++){
685  const int index= i4x4 + 4*i8x8 + p*16;
686  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
687  scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
688  return -1;
689  }
690  new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
691  }
692  }
693  }else{
694  uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
695  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
696  }
697  }
698  return new_cbp;
699  }
700 }
701 
703 {
704  int mb_xy;
705  int partition_count;
706  unsigned int mb_type, cbp;
707  int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
708  const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
709  const int pixel_shift = h->pixel_shift;
710 
711  mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
712 
713  ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->poc.frame_num, sl->mb_x, sl->mb_y);
714  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
715  down the code */
716  if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
717  if (sl->mb_skip_run == -1) {
718  unsigned mb_skip_run = get_ue_golomb_long(&sl->gb);
719  if (mb_skip_run > h->mb_num) {
720  av_log(h->avctx, AV_LOG_ERROR, "mb_skip_run %d is invalid\n", mb_skip_run);
721  return AVERROR_INVALIDDATA;
722  }
723  sl->mb_skip_run = mb_skip_run;
724  }
725 
726  if (sl->mb_skip_run--) {
727  if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
728  if (sl->mb_skip_run == 0)
729  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
730  }
731  decode_mb_skip(h, sl);
732  return 0;
733  }
734  }
735  if (FRAME_MBAFF(h)) {
736  if ((sl->mb_y & 1) == 0)
737  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
738  }
739 
740  sl->prev_mb_skipped = 0;
741 
742  mb_type= get_ue_golomb(&sl->gb);
743  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
744  if(mb_type < 23){
745  partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
746  mb_type = ff_h264_b_mb_type_info[mb_type].type;
747  }else{
748  mb_type -= 23;
749  goto decode_intra_mb;
750  }
751  } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
752  if(mb_type < 5){
753  partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
754  mb_type = ff_h264_p_mb_type_info[mb_type].type;
755  }else{
756  mb_type -= 5;
757  goto decode_intra_mb;
758  }
759  }else{
761  if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
762  mb_type--;
763 decode_intra_mb:
764  if(mb_type > 25){
765  av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(sl->slice_type), sl->mb_x, sl->mb_y);
766  return -1;
767  }
768  partition_count=0;
769  cbp = ff_h264_i_mb_type_info[mb_type].cbp;
771  mb_type = ff_h264_i_mb_type_info[mb_type].type;
772  }
773 
774  if (MB_FIELD(sl))
775  mb_type |= MB_TYPE_INTERLACED;
776 
777  h->slice_table[mb_xy] = sl->slice_num;
778 
779  if(IS_INTRA_PCM(mb_type)){
780  const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
781  h->ps.sps->bit_depth_luma;
782 
783  // We assume these blocks are very rare so we do not optimize it.
784  sl->intra_pcm_ptr = align_get_bits(&sl->gb);
785  if (get_bits_left(&sl->gb) < mb_size) {
786  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
787  return AVERROR_INVALIDDATA;
788  }
789  skip_bits_long(&sl->gb, mb_size);
790 
791  // In deblocking, the quantizer is 0
792  h->cur_pic.qscale_table[mb_xy] = 0;
793  // All coeffs are present
794  memset(h->non_zero_count[mb_xy], 16, 48);
795 
796  h->cur_pic.mb_type[mb_xy] = mb_type;
797  return 0;
798  }
799 
800  fill_decode_neighbors(h, sl, mb_type);
801  fill_decode_caches(h, sl, mb_type);
802 
803  //mb_pred
804  if(IS_INTRA(mb_type)){
805  int pred_mode;
806 // init_top_left_availability(h);
807  if(IS_INTRA4x4(mb_type)){
808  int i;
809  int di = 1;
810  if(dct8x8_allowed && get_bits1(&sl->gb)){
811  mb_type |= MB_TYPE_8x8DCT;
812  di = 4;
813  }
814 
815 // fill_intra4x4_pred_table(h);
816  for(i=0; i<16; i+=di){
817  int mode = pred_intra_mode(h, sl, i);
818 
819  if(!get_bits1(&sl->gb)){
820  const int rem_mode= get_bits(&sl->gb, 3);
821  mode = rem_mode + (rem_mode >= mode);
822  }
823 
824  if(di==4)
825  fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
826  else
828  }
832  return -1;
833  }else{
836  if (sl->intra16x16_pred_mode < 0)
837  return -1;
838  }
839  if(decode_chroma){
842  if(pred_mode < 0)
843  return -1;
844  sl->chroma_pred_mode = pred_mode;
845  } else {
847  }
848  }else if(partition_count==4){
849  int i, j, sub_partition_count[4], list, ref[2][4];
850 
851  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
852  for(i=0; i<4; i++){
853  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
854  if(sl->sub_mb_type[i] >=13){
855  av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
856  return -1;
857  }
858  sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
860  }
861  if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
862  ff_h264_pred_direct_motion(h, sl, &mb_type);
863  sl->ref_cache[0][scan8[4]] =
864  sl->ref_cache[1][scan8[4]] =
865  sl->ref_cache[0][scan8[12]] =
866  sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
867  }
868  }else{
869  av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
870  for(i=0; i<4; i++){
871  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
872  if(sl->sub_mb_type[i] >=4){
873  av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
874  return -1;
875  }
876  sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
878  }
879  }
880 
881  for (list = 0; list < sl->list_count; list++) {
882  int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
883  for(i=0; i<4; i++){
884  if(IS_DIRECT(sl->sub_mb_type[i])) continue;
885  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
886  unsigned int tmp;
887  if(ref_count == 1){
888  tmp= 0;
889  }else if(ref_count == 2){
890  tmp= get_bits1(&sl->gb)^1;
891  }else{
892  tmp= get_ue_golomb_31(&sl->gb);
893  if(tmp>=ref_count){
894  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
895  return -1;
896  }
897  }
898  ref[list][i]= tmp;
899  }else{
900  //FIXME
901  ref[list][i] = -1;
902  }
903  }
904  }
905 
906  if(dct8x8_allowed)
907  dct8x8_allowed = get_dct8x8_allowed(h, sl);
908 
909  for (list = 0; list < sl->list_count; list++) {
910  for(i=0; i<4; i++){
911  if(IS_DIRECT(sl->sub_mb_type[i])) {
912  sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
913  continue;
914  }
915  sl->ref_cache[list][ scan8[4*i] ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
916  sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
917 
918  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
919  const int sub_mb_type= sl->sub_mb_type[i];
920  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
921  for(j=0; j<sub_partition_count[i]; j++){
922  int mx, my;
923  const int index= 4*i + block_width*j;
924  int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
925  pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
926  mx += get_se_golomb(&sl->gb);
927  my += get_se_golomb(&sl->gb);
928  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
929 
930  if(IS_SUB_8X8(sub_mb_type)){
931  mv_cache[ 1 ][0]=
932  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
933  mv_cache[ 1 ][1]=
934  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
935  }else if(IS_SUB_8X4(sub_mb_type)){
936  mv_cache[ 1 ][0]= mx;
937  mv_cache[ 1 ][1]= my;
938  }else if(IS_SUB_4X8(sub_mb_type)){
939  mv_cache[ 8 ][0]= mx;
940  mv_cache[ 8 ][1]= my;
941  }
942  mv_cache[ 0 ][0]= mx;
943  mv_cache[ 0 ][1]= my;
944  }
945  }else{
946  uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
947  p[0] = p[1]=
948  p[8] = p[9]= 0;
949  }
950  }
951  }
952  }else if(IS_DIRECT(mb_type)){
953  ff_h264_pred_direct_motion(h, sl, &mb_type);
954  dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
955  }else{
956  int list, mx, my, i;
957  //FIXME we should set ref_idx_l? to 0 if we use that later ...
958  if(IS_16X16(mb_type)){
959  for (list = 0; list < sl->list_count; list++) {
960  unsigned int val;
961  if(IS_DIR(mb_type, 0, list)){
962  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
963  if (rc == 1) {
964  val= 0;
965  } else if (rc == 2) {
966  val= get_bits1(&sl->gb)^1;
967  }else{
968  val= get_ue_golomb_31(&sl->gb);
969  if (val >= rc) {
970  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
971  return -1;
972  }
973  }
974  fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
975  }
976  }
977  for (list = 0; list < sl->list_count; list++) {
978  if(IS_DIR(mb_type, 0, list)){
979  pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
980  mx += get_se_golomb(&sl->gb);
981  my += get_se_golomb(&sl->gb);
982  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
983 
984  fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
985  }
986  }
987  }
988  else if(IS_16X8(mb_type)){
989  for (list = 0; list < sl->list_count; list++) {
990  for(i=0; i<2; i++){
991  unsigned int val;
992  if(IS_DIR(mb_type, i, list)){
993  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
994  if (rc == 1) {
995  val= 0;
996  } else if (rc == 2) {
997  val= get_bits1(&sl->gb)^1;
998  }else{
999  val= get_ue_golomb_31(&sl->gb);
1000  if (val >= rc) {
1001  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1002  return -1;
1003  }
1004  }
1005  }else
1006  val= LIST_NOT_USED&0xFF;
1007  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1008  }
1009  }
1010  for (list = 0; list < sl->list_count; list++) {
1011  for(i=0; i<2; i++){
1012  unsigned int val;
1013  if(IS_DIR(mb_type, i, list)){
1014  pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1015  mx += get_se_golomb(&sl->gb);
1016  my += get_se_golomb(&sl->gb);
1017  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1018 
1019  val= pack16to32(mx,my);
1020  }else
1021  val=0;
1022  fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1023  }
1024  }
1025  }else{
1026  av_assert2(IS_8X16(mb_type));
1027  for (list = 0; list < sl->list_count; list++) {
1028  for(i=0; i<2; i++){
1029  unsigned int val;
1030  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1031  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1032  if (rc == 1) {
1033  val= 0;
1034  } else if (rc == 2) {
1035  val= get_bits1(&sl->gb)^1;
1036  }else{
1037  val= get_ue_golomb_31(&sl->gb);
1038  if (val >= rc) {
1039  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1040  return -1;
1041  }
1042  }
1043  }else
1044  val= LIST_NOT_USED&0xFF;
1045  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1046  }
1047  }
1048  for (list = 0; list < sl->list_count; list++) {
1049  for(i=0; i<2; i++){
1050  unsigned int val;
1051  if(IS_DIR(mb_type, i, list)){
1052  pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1053  mx += get_se_golomb(&sl->gb);
1054  my += get_se_golomb(&sl->gb);
1055  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1056 
1057  val= pack16to32(mx,my);
1058  }else
1059  val=0;
1060  fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1061  }
1062  }
1063  }
1064  }
1065 
1066  if(IS_INTER(mb_type))
1067  write_back_motion(h, sl, mb_type);
1068 
1069  if(!IS_INTRA16x16(mb_type)){
1070  cbp= get_ue_golomb(&sl->gb);
1071 
1072  if(decode_chroma){
1073  if(cbp > 47){
1074  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1075  return -1;
1076  }
1077  if (IS_INTRA4x4(mb_type))
1078  cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1079  else
1080  cbp = ff_h264_golomb_to_inter_cbp[cbp];
1081  }else{
1082  if(cbp > 15){
1083  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1084  return -1;
1085  }
1086  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1087  else cbp= golomb_to_inter_cbp_gray[cbp];
1088  }
1089  } else {
1090  if (!decode_chroma && cbp>15) {
1091  av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1092  return AVERROR_INVALIDDATA;
1093  }
1094  }
1095 
1096  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1097  mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1098  }
1099  sl->cbp=
1100  h->cbp_table[mb_xy]= cbp;
1101  h->cur_pic.mb_type[mb_xy] = mb_type;
1102 
1103  if(cbp || IS_INTRA16x16(mb_type)){
1104  int i4x4, i8x8, chroma_idx;
1105  int dquant;
1106  int ret;
1107  GetBitContext *gb = &sl->gb;
1108  const uint8_t *scan, *scan8x8;
1109  const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
1110 
1111  dquant= get_se_golomb(&sl->gb);
1112 
1113  sl->qscale += (unsigned)dquant;
1114 
1115  if (((unsigned)sl->qscale) > max_qp){
1116  if (sl->qscale < 0) sl->qscale += max_qp + 1;
1117  else sl->qscale -= max_qp+1;
1118  if (((unsigned)sl->qscale) > max_qp){
1119  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1120  sl->qscale = max_qp;
1121  return -1;
1122  }
1123  }
1124 
1125  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
1126  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
1127 
1128  if(IS_INTERLACED(mb_type)){
1129  scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1130  scan = sl->qscale ? h->field_scan : h->field_scan_q0;
1131  }else{
1132  scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1133  scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1134  }
1135 
1136  if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1137  return -1;
1138  }
1139  h->cbp_table[mb_xy] |= ret << 12;
1140  if (CHROMA444(h)) {
1141  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1142  return -1;
1143  }
1144  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1145  return -1;
1146  }
1147  } else {
1148  const int num_c8x8 = h->ps.sps->chroma_format_idc;
1149 
1150  if(cbp&0x30){
1151  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1152  if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1153  CHROMA_DC_BLOCK_INDEX + chroma_idx,
1155  NULL, 4 * num_c8x8) < 0) {
1156  return -1;
1157  }
1158  }
1159 
1160  if(cbp&0x20){
1161  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1162  const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1163  int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1164  for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1165  for (i4x4 = 0; i4x4 < 4; i4x4++) {
1166  const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1167  if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1168  return -1;
1169  mb += 16 << pixel_shift;
1170  }
1171  }
1172  }
1173  }else{
1174  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1175  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1176  }
1177  }
1178  }else{
1179  fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1180  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1181  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1182  }
1183  h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1185 
1186  return 0;
1187 }
int chroma_format_idc
Definition: h264_ps.h:48
uint8_t pred_mode
Definition: h264data.h:35
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:271
#define ff_tlog(ctx,...)
Definition: internal.h:75
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define DC_128_PRED8x8
Definition: h264pred.h:76
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:278
int16_t mb[16 *48 *2]
Definition: h264dec.h:307
H264POCContext poc
Definition: h264dec.h:460
int mb_num
Definition: h264dec.h:437
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:299
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
float re
Definition: fft.c:82
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
Definition: h264dec.h:681
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
uint16_t * cbp_table
Definition: h264dec.h:413
static VLC total_zeros_vlc[15+1]
Definition: h264_cavlc.c:251
static const int chroma422_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:249
static av_cold void init_cavlc_level_tab(void)
Definition: h264_cavlc.c:301
int prev_mb_skipped
Definition: h264dec.h:199
int av_log2(unsigned v)
Definition: intmath.c:26
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
#define MB_TYPE_16x8
Definition: mpegutils.h:55
#define IS_SUB_8X8(a)
Definition: mpegutils.h:90
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264dec.h:423
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
Definition: h264_direct.c:721
H264Context.
Definition: h264dec.h:337
static const uint8_t chroma422_dc_coeff_token_len[4 *9]
Definition: h264_cavlc.c:65
static const int chroma422_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:261
#define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:279
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2]
Definition: h264_cavlc.c:256
static VLC chroma422_dc_coeff_token_vlc
Definition: h264_cavlc.c:247
static const uint8_t coeff_token_len[4][4 *17]
Definition: h264_cavlc.c:89
static const uint8_t chroma422_dc_coeff_token_bits[4 *9]
Definition: h264_cavlc.c:77
static const uint8_t chroma422_dc_total_zeros_len[7][8]
Definition: h264_cavlc.c:199
uint8_t partition_count
Definition: h264data.h:43
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:267
static int decode_residual(const H264Context *h, H264SliceContext *sl, GetBitContext *gb, int16_t *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff)
Decode a residual block.
Definition: h264_cavlc.c:439
Switching Intra.
Definition: avutil.h:278
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:219
static const uint8_t chroma_dc_coeff_token_bits[4 *5]
Definition: h264_cavlc.c:57
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static const uint8_t golomb_to_intra4x4_cbp_gray[16]
Definition: h264_cavlc.c:45
uint16_t sub_mb_type[4]
as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
Definition: h264dec.h:304
const PPS * pps
Definition: h264_ps.h:145
static const uint8_t coeff_token_bits[4][4 *17]
Definition: h264_cavlc.c:120
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
#define mb
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
#define MB_MBAFF(h)
Definition: h264dec.h:71
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static const int chroma_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:257
#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:275
#define MB_FIELD(sl)
Definition: h264dec.h:72
#define MB_TYPE_16x16
Definition: mpegutils.h:54
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
const uint8_t ff_h264_chroma_dc_scan[4]
Definition: h264data.c:54
#define IS_DIR(a, part, list)
Definition: mpegutils.h:96
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264_ps.h:134
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264_ps.h:135
const IMbInfo ff_h264_i_mb_type_info[26]
Definition: h264data.c:66
static int8_t cavlc_level_tab[7][1<< LEVEL_TAB_BITS][2]
Definition: h264_cavlc.c:272
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:88
static const uint8_t total_zeros_len[16][16]
Definition: h264_cavlc.c:151
static av_always_inline int pred_intra_mode(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264dec.h:689
const uint8_t ff_h264_golomb_to_inter_cbp[48]
Definition: h264data.c:48
int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx, int top_samples_available, int left_samples_available)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
Definition: h264_parse.c:131
static VLC run_vlc[6+1]
Definition: h264_cavlc.c:263
int chroma_qp[2]
Definition: h264dec.h:188
#define av_log(a,...)
uint16_t type
Definition: h264data.h:42
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2]
Definition: h264_cavlc.c:240
static const uint16_t table[]
Definition: prosumer.c:206
const PMbInfo ff_h264_p_mb_type_info[5]
Definition: h264data.c:95
static av_always_inline void write_back_motion(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264dec.h:777
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define RUN7_VLC_BITS
Definition: h264_cavlc.c:281
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
static const uint16_t mask[17]
Definition: lzw.c:38
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
const uint8_t ff_h264_chroma422_dc_scan[8]
Definition: h264data.c:59
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264dec.h:205
static const uint8_t chroma_dc_total_zeros_bits[3][4]
Definition: h264_cavlc.c:193
static av_always_inline void pred_16x8_motion(const H264Context *const h, H264SliceContext *sl, int n, int list, int ref, int *const mx, int *const my)
Get the directionally predicted 16x8 MV.
Definition: h264_mvpred.h:160
simple assert() macros that are a bit more flexible than ISO C assert().
unsigned int top_samples_available
Definition: h264dec.h:222
static VLC chroma_dc_coeff_token_vlc
Definition: h264_cavlc.c:243
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:184
Definition: vlc.h:26
#define COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:276
int16_t mb_luma_dc[3][16 *2]
as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too lar...
Definition: h264dec.h:308
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:804
static const int chroma_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:245
#define IS_INTRA_PCM(a)
Definition: mpegutils.h:82
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:169
#define IS_16X8(a)
Definition: mpegutils.h:87
int chroma_pred_mode
Definition: h264dec.h:202
#define IS_SUB_4X8(a)
Definition: mpegutils.h:92
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264dec.h:403
uint8_t field_scan8x8_cavlc[64]
Definition: h264dec.h:426
#define IS_DIRECT(a)
Definition: mpegutils.h:84
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:260
#define IS_REF0(a)
Definition: h264dec.h:103
static av_always_inline void pred_8x16_motion(const H264Context *const h, H264SliceContext *sl, int n, int list, int ref, int *const mx, int *const my)
Get the directionally predicted 8x16 MV.
Definition: h264_mvpred.h:201
static VLC coeff_token_vlc[4]
Definition: h264_cavlc.c:239
static VLC_TYPE total_zeros_vlc_tables[15][512][2]
Definition: h264_cavlc.c:252
uint32_t * mb_type
Definition: h264dec.h:139
int32_t
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
#define CHROMA_DC_BLOCK_INDEX
Definition: h264dec.h:641
H.264 / AVC / MPEG-4 part10 codec.
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
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:797
int direct_8x8_inference_flag
Definition: h264_ps.h:64
int n
Definition: avisynth_c.h:760
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:827
#define LUMA_DC_BLOCK_INDEX
Definition: h264dec.h:640
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:58
#define FF_ARRAY_ELEMS(a)
#define IS_INTRA16x16(a)
Definition: mpegutils.h:76
static const uint8_t chroma_dc_coeff_token_len[4 *5]
Definition: h264_cavlc.c:49
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:105
int table_allocated
Definition: vlc.h:29
uint8_t zigzag_scan_q0[16]
Definition: h264dec.h:427
int intra16x16_pred_mode
Definition: h264dec.h:203
int mb_stride
Definition: h264dec.h:436
#define IS_INTERLACED(a)
Definition: mpegutils.h:83
AVCodecContext * avctx
Definition: h264dec.h:339
#define IS_SUB_8X4(a)
Definition: mpegutils.h:91
Libavcodec external API header.
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
void * buf
Definition: avisynth_c.h:766
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
int8_t * qscale_table
Definition: h264dec.h:133
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:644
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
const uint8_t ff_h264_golomb_to_intra4x4_cbp[48]
Definition: h264data.c:42
#define IS_16X16(a)
Definition: mpegutils.h:86
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:294
int index
Definition: gxfenc.c:89
#define FRAME_MBAFF(h)
Definition: h264dec.h:73
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:660
#define IS_8X16(a)
Definition: mpegutils.h:88
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:327
int pixel_shift
0 for 8-bit H.264, 1 for high-bit-depth H.264
Definition: h264dec.h:356
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
#define LIST_NOT_USED
Definition: h264dec.h:390
static const int total_zeros_vlc_tables_size
Definition: h264_cavlc.c:253
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:242
#define IS_INTER(a)
Definition: mpegutils.h:79
static const uint8_t chroma422_dc_total_zeros_bits[7][8]
Definition: h264_cavlc.c:209
static void fill_decode_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:445
const SPS * sps
Definition: h264_ps.h:146
static const int coeff_token_vlc_tables_size[4]
Definition: h264_cavlc.c:241
static const int run7_vlc_table_size
Definition: h264_cavlc.c:269
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264_ps.h:124
#define CHROMA444(h)
Definition: h264dec.h:99
uint8_t zigzag_scan[16]
Definition: h264dec.h:421
unsigned int list_count
Definition: h264dec.h:268
uint8_t level
Definition: svq3.c:207
#define AV_ZERO128(d)
Definition: intreadwrite.h:637
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2]
Definition: h264_cavlc.c:248
static av_always_inline void write_back_non_zero_count(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:717
#define IS_8x8DCT(a)
Definition: h264dec.h:104
uint8_t cbp
Definition: h264data.h:36
common internal api header.
const PMbInfo ff_h264_b_mb_type_info[23]
Definition: h264data.c:110
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available, int left_samples_available, 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_parse.c:179
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
const PMbInfo ff_h264_p_sub_mb_type_info[4]
Definition: h264data.c:103
H264ParamSets ps
Definition: h264dec.h:456
H.264 / AVC / MPEG-4 part10 motion vector prediction.
Bi-dir predicted.
Definition: avutil.h:276
static void fill_decode_neighbors(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:356
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:702
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264_ps.h:98
static int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted number of non-zero coefficients.
Definition: h264_cavlc.c:287
#define IS_INTRA(x, y)
#define CHROMA_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:274
#define IS_INTRA4x4(a)
Definition: mpegutils.h:75
static VLC run7_vlc
Definition: h264_cavlc.c:267
uint8_t zigzag_scan8x8_cavlc_q0[64]
Definition: h264dec.h:429
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:300
static const int run_vlc_tables_size
Definition: h264_cavlc.c:265
#define CHROMA422(h)
Definition: h264dec.h:98
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
H264Picture cur_pic
Definition: h264dec.h:347
#define PART_NOT_AVAILABLE
Definition: h264dec.h:391
static const uint8_t chroma_dc_total_zeros_len[3][4]
Definition: h264_cavlc.c:187
static void av_unused decode_mb_skip(const H264Context *h, H264SliceContext *sl)
decodes a P_SKIP or B_SKIP macroblock
Definition: h264_mvpred.h:803
static int get_level_prefix(GetBitContext *gb)
Definition: h264_cavlc.c:416
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
uint8_t field_scan8x8_cavlc_q0[64]
Definition: h264dec.h:432
const uint8_t * intra_pcm_ptr
Definition: h264dec.h:280
uint16_t type
Definition: h264data.h:34
unsigned int left_samples_available
Definition: h264dec.h:224
#define av_always_inline
Definition: attributes.h:39
static const uint8_t golomb_to_inter_cbp_gray[16]
Definition: h264_cavlc.c:41
const PMbInfo ff_h264_b_sub_mb_type_info[13]
Definition: h264data.c:136
#define VLC_TYPE
Definition: vlc.h:24
static VLC chroma_dc_total_zeros_vlc[3+1]
Definition: h264_cavlc.c:255
static VLC_TYPE run_vlc_tables[6][8][2]
Definition: h264_cavlc.c:264
uint8_t field_scan_q0[16]
Definition: h264dec.h:430
int mb_field_decoding_flag
Definition: h264dec.h:241
uint8_t(* non_zero_count)[48]
Definition: h264dec.h:388
exp golomb vlc stuff
static av_always_inline int decode_luma_residual(const H264Context *h, H264SliceContext *sl, GetBitContext *gb, const uint8_t *scan, const uint8_t *scan8x8, int pixel_shift, int mb_type, int cbp, int p)
Definition: h264_cavlc.c:632
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:244
#define MB_TYPE_8x8DCT
Definition: h264dec.h:102
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
static VLC chroma422_dc_total_zeros_vlc[7+1]
Definition: h264_cavlc.c:259
GetBitContext gb
Definition: h264dec.h:179
uint8_t field_scan[16]
Definition: h264dec.h:424
Predicted.
Definition: avutil.h:275
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:58
#define STORE_BLOCK(type)
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:705
static av_always_inline void pred_motion(const H264Context *const h, H264SliceContext *sl, int n, int part_width, int list, int ref, int *const mx, int *const my)
Get the predicted MV.
Definition: h264_mvpred.h:95
static uint8_t tmp[11]
Definition: aes_ctr.c:26