FFmpeg  4.4
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 {
329  int offset;
330 
334  &chroma_dc_coeff_token_len [0], 1, 1,
335  &chroma_dc_coeff_token_bits[0], 1, 1,
337 
341  &chroma422_dc_coeff_token_len [0], 1, 1,
344 
345  offset = 0;
346  for (int i = 0; i < 4; i++) {
350  &coeff_token_len [i][0], 1, 1,
351  &coeff_token_bits[i][0], 1, 1,
354  }
355  /*
356  * This is a one time safety check to make sure that
357  * the packed static coeff_token_vlc table sizes
358  * were initialized correctly.
359  */
361 
362  for (int i = 0; i < 3; i++) {
367  &chroma_dc_total_zeros_len [i][0], 1, 1,
368  &chroma_dc_total_zeros_bits[i][0], 1, 1,
370  }
371 
372  for (int i = 0; i < 7; i++) {
377  &chroma422_dc_total_zeros_len [i][0], 1, 1,
378  &chroma422_dc_total_zeros_bits[i][0], 1, 1,
380  }
381 
382  for (int i = 0; i < 15; i++) {
385  init_vlc(&total_zeros_vlc[i + 1],
387  &total_zeros_len [i][0], 1, 1,
388  &total_zeros_bits[i][0], 1, 1,
390  }
391 
392  for (int i = 0; i < 6; i++) {
393  run_vlc[i + 1].table = run_vlc_tables[i];
395  init_vlc(&run_vlc[i + 1],
396  RUN_VLC_BITS, 7,
397  &run_len [i][0], 1, 1,
398  &run_bits[i][0], 1, 1,
400  }
404  &run_len [6][0], 1, 1,
405  &run_bits[6][0], 1, 1,
407 
409 }
410 
411 static inline int get_level_prefix(GetBitContext *gb){
412  unsigned int buf;
413  int log;
414 
415  OPEN_READER(re, gb);
416  UPDATE_CACHE(re, gb);
417  buf=GET_CACHE(re, gb);
418 
419  log= 32 - av_log2(buf);
420 
421  LAST_SKIP_BITS(re, gb, log);
422  CLOSE_READER(re, gb);
423 
424  return log-1;
425 }
426 
427 /**
428  * Decode a residual block.
429  * @param n block index
430  * @param scantable scantable
431  * @param max_coeff number of coefficients in the block
432  * @return <0 if an error occurred
433  */
435  GetBitContext *gb, int16_t *block, int n,
436  const uint8_t *scantable, const uint32_t *qmul,
437  int max_coeff)
438 {
439  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};
440  int level[16];
441  int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
442 
443  //FIXME put trailing_onex into the context
444 
445  if(max_coeff <= 8){
446  if (max_coeff == 4)
448  else
450  total_coeff= coeff_token>>2;
451  }else{
452  if(n >= LUMA_DC_BLOCK_INDEX){
453  total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
454  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
455  total_coeff= coeff_token>>2;
456  }else{
457  total_coeff= pred_non_zero_count(h, sl, n);
458  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
459  total_coeff= coeff_token>>2;
460  }
461  }
462  sl->non_zero_count_cache[scan8[n]] = total_coeff;
463 
464  //FIXME set last_non_zero?
465 
466  if(total_coeff==0)
467  return 0;
468  if(total_coeff > (unsigned)max_coeff) {
469  av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
470  return -1;
471  }
472 
473  trailing_ones= coeff_token&3;
474  ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
475  av_assert2(total_coeff<=16);
476 
477  i = show_bits(gb, 3);
478  skip_bits(gb, trailing_ones);
479  level[0] = 1-((i&4)>>1);
480  level[1] = 1-((i&2) );
481  level[2] = 1-((i&1)<<1);
482 
483  if(trailing_ones<total_coeff) {
484  int mask, prefix;
485  int suffix_length = total_coeff > 10 & trailing_ones < 3;
486  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
487  int level_code= cavlc_level_tab[suffix_length][bitsi][0];
488 
489  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
490  if(level_code >= 100){
491  prefix= level_code - 100;
492  if(prefix == LEVEL_TAB_BITS)
493  prefix += get_level_prefix(gb);
494 
495  //first coefficient has suffix_length equal to 0 or 1
496  if(prefix<14){ //FIXME try to build a large unified VLC table for all this
497  if(suffix_length)
498  level_code= (prefix<<1) + get_bits1(gb); //part
499  else
500  level_code= prefix; //part
501  }else if(prefix==14){
502  if(suffix_length)
503  level_code= (prefix<<1) + get_bits1(gb); //part
504  else
505  level_code= prefix + get_bits(gb, 4); //part
506  }else{
507  level_code= 30;
508  if(prefix>=16){
509  if(prefix > 25+3){
510  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
511  return -1;
512  }
513  level_code += (1<<(prefix-3))-4096;
514  }
515  level_code += get_bits(gb, prefix-3); //part
516  }
517 
518  if(trailing_ones < 3) level_code += 2;
519 
520  suffix_length = 2;
521  mask= -(level_code&1);
522  level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
523  }else{
524  level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
525 
526  suffix_length = 1 + (level_code + 3U > 6U);
527  level[trailing_ones]= level_code;
528  }
529 
530  //remaining coefficients have suffix_length > 0
531  for(i=trailing_ones+1;i<total_coeff;i++) {
532  static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
533  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
534  level_code= cavlc_level_tab[suffix_length][bitsi][0];
535 
536  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
537  if(level_code >= 100){
538  prefix= level_code - 100;
539  if(prefix == LEVEL_TAB_BITS){
540  prefix += get_level_prefix(gb);
541  }
542  if(prefix<15){
543  level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
544  }else{
545  level_code = 15<<suffix_length;
546  if (prefix>=16) {
547  if(prefix > 25+3){
548  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
549  return AVERROR_INVALIDDATA;
550  }
551  level_code += (1<<(prefix-3))-4096;
552  }
553  level_code += get_bits(gb, prefix-3);
554  }
555  mask= -(level_code&1);
556  level_code= (((2+level_code)>>1) ^ mask) - mask;
557  }
558  level[i]= level_code;
559  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
560  }
561  }
562 
563  if(total_coeff == max_coeff)
564  zeros_left=0;
565  else{
566  if (max_coeff <= 8) {
567  if (max_coeff == 4)
568  zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
570  else
571  zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
573  } else {
574  zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
575  }
576  }
577 
578 #define STORE_BLOCK(type) \
579  scantable += zeros_left + total_coeff - 1; \
580  if(n >= LUMA_DC_BLOCK_INDEX){ \
581  ((type*)block)[*scantable] = level[0]; \
582  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
583  if(zeros_left < 7) \
584  run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
585  else \
586  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
587  zeros_left -= run_before; \
588  scantable -= 1 + run_before; \
589  ((type*)block)[*scantable]= level[i]; \
590  } \
591  for(;i<total_coeff;i++) { \
592  scantable--; \
593  ((type*)block)[*scantable]= level[i]; \
594  } \
595  }else{ \
596  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
597  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
598  if(zeros_left < 7) \
599  run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
600  else \
601  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
602  zeros_left -= run_before; \
603  scantable -= 1 + run_before; \
604  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
605  } \
606  for(;i<total_coeff;i++) { \
607  scantable--; \
608  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
609  } \
610  }
611 
612  if (h->pixel_shift) {
614  } else {
615  STORE_BLOCK(int16_t)
616  }
617 
618  if(zeros_left<0){
619  av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
620  return -1;
621  }
622 
623  return 0;
624 }
625 
626 static av_always_inline
628  GetBitContext *gb, const uint8_t *scan,
629  const uint8_t *scan8x8, int pixel_shift,
630  int mb_type, int cbp, int p)
631 {
632  int i4x4, i8x8;
633  int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
634  if(IS_INTRA16x16(mb_type)){
635  AV_ZERO128(sl->mb_luma_dc[p]+0);
636  AV_ZERO128(sl->mb_luma_dc[p]+8);
637  AV_ZERO128(sl->mb_luma_dc[p]+16);
638  AV_ZERO128(sl->mb_luma_dc[p]+24);
639  if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
640  return -1; //FIXME continue if partitioned and other return -1 too
641  }
642 
643  av_assert2((cbp&15) == 0 || (cbp&15) == 15);
644 
645  if(cbp&15){
646  for(i8x8=0; i8x8<4; i8x8++){
647  for(i4x4=0; i4x4<4; i4x4++){
648  const int index= i4x4 + 4*i8x8 + p*16;
649  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
650  index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
651  return -1;
652  }
653  }
654  }
655  return 0xf;
656  }else{
657  fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
658  return 0;
659  }
660  }else{
661  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
662  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
663  int new_cbp = 0;
664  for(i8x8=0; i8x8<4; i8x8++){
665  if(cbp & (1<<i8x8)){
666  if(IS_8x8DCT(mb_type)){
667  int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
668  uint8_t *nnz;
669  for(i4x4=0; i4x4<4; i4x4++){
670  const int index= i4x4 + 4*i8x8 + p*16;
671  if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
672  h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
673  return -1;
674  }
675  nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
676  nnz[0] += nnz[1] + nnz[8] + nnz[9];
677  new_cbp |= !!nnz[0] << i8x8;
678  }else{
679  for(i4x4=0; i4x4<4; i4x4++){
680  const int index= i4x4 + 4*i8x8 + p*16;
681  if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
682  scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
683  return -1;
684  }
685  new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
686  }
687  }
688  }else{
689  uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
690  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
691  }
692  }
693  return new_cbp;
694  }
695 }
696 
698 {
699  int mb_xy;
700  int partition_count;
701  unsigned int mb_type, cbp;
702  int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
703  const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
704  const int pixel_shift = h->pixel_shift;
705 
706  mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
707 
708  ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->poc.frame_num, sl->mb_x, sl->mb_y);
709  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
710  down the code */
711  if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
712  if (sl->mb_skip_run == -1) {
713  unsigned mb_skip_run = get_ue_golomb_long(&sl->gb);
714  if (mb_skip_run > h->mb_num) {
715  av_log(h->avctx, AV_LOG_ERROR, "mb_skip_run %d is invalid\n", mb_skip_run);
716  return AVERROR_INVALIDDATA;
717  }
718  sl->mb_skip_run = mb_skip_run;
719  }
720 
721  if (sl->mb_skip_run--) {
722  if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
723  if (sl->mb_skip_run == 0)
724  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
725  }
726  decode_mb_skip(h, sl);
727  return 0;
728  }
729  }
730  if (FRAME_MBAFF(h)) {
731  if ((sl->mb_y & 1) == 0)
732  sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
733  }
734 
735  sl->prev_mb_skipped = 0;
736 
737  mb_type= get_ue_golomb(&sl->gb);
738  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
739  if(mb_type < 23){
740  partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
741  mb_type = ff_h264_b_mb_type_info[mb_type].type;
742  }else{
743  mb_type -= 23;
744  goto decode_intra_mb;
745  }
746  } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
747  if(mb_type < 5){
748  partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
749  mb_type = ff_h264_p_mb_type_info[mb_type].type;
750  }else{
751  mb_type -= 5;
752  goto decode_intra_mb;
753  }
754  }else{
756  if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
757  mb_type--;
758 decode_intra_mb:
759  if(mb_type > 25){
760  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);
761  return -1;
762  }
763  partition_count=0;
764  cbp = ff_h264_i_mb_type_info[mb_type].cbp;
766  mb_type = ff_h264_i_mb_type_info[mb_type].type;
767  }
768 
769  if (MB_FIELD(sl))
770  mb_type |= MB_TYPE_INTERLACED;
771 
772  h->slice_table[mb_xy] = sl->slice_num;
773 
774  if(IS_INTRA_PCM(mb_type)){
775  const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
776  h->ps.sps->bit_depth_luma;
777 
778  // We assume these blocks are very rare so we do not optimize it.
779  sl->intra_pcm_ptr = align_get_bits(&sl->gb);
780  if (get_bits_left(&sl->gb) < mb_size) {
781  av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
782  return AVERROR_INVALIDDATA;
783  }
784  skip_bits_long(&sl->gb, mb_size);
785 
786  // In deblocking, the quantizer is 0
787  h->cur_pic.qscale_table[mb_xy] = 0;
788  // All coeffs are present
789  memset(h->non_zero_count[mb_xy], 16, 48);
790 
791  h->cur_pic.mb_type[mb_xy] = mb_type;
792  return 0;
793  }
794 
795  fill_decode_neighbors(h, sl, mb_type);
796  fill_decode_caches(h, sl, mb_type);
797 
798  //mb_pred
799  if(IS_INTRA(mb_type)){
800  int pred_mode;
801 // init_top_left_availability(h);
802  if(IS_INTRA4x4(mb_type)){
803  int i;
804  int di = 1;
805  if(dct8x8_allowed && get_bits1(&sl->gb)){
806  mb_type |= MB_TYPE_8x8DCT;
807  di = 4;
808  }
809 
810 // fill_intra4x4_pred_table(h);
811  for(i=0; i<16; i+=di){
812  int mode = pred_intra_mode(h, sl, i);
813 
814  if(!get_bits1(&sl->gb)){
815  const int rem_mode= get_bits(&sl->gb, 3);
816  mode = rem_mode + (rem_mode >= mode);
817  }
818 
819  if(di==4)
820  fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
821  else
823  }
827  return -1;
828  }else{
831  if (sl->intra16x16_pred_mode < 0)
832  return -1;
833  }
834  if(decode_chroma){
837  if(pred_mode < 0)
838  return -1;
839  sl->chroma_pred_mode = pred_mode;
840  } else {
842  }
843  }else if(partition_count==4){
844  int i, j, sub_partition_count[4], list, ref[2][4];
845 
846  if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
847  for(i=0; i<4; i++){
848  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
849  if(sl->sub_mb_type[i] >=13){
850  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);
851  return -1;
852  }
853  sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
855  }
856  if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
857  ff_h264_pred_direct_motion(h, sl, &mb_type);
858  sl->ref_cache[0][scan8[4]] =
859  sl->ref_cache[1][scan8[4]] =
860  sl->ref_cache[0][scan8[12]] =
861  sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
862  }
863  }else{
864  av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
865  for(i=0; i<4; i++){
866  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
867  if(sl->sub_mb_type[i] >=4){
868  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);
869  return -1;
870  }
871  sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
873  }
874  }
875 
876  for (list = 0; list < sl->list_count; list++) {
877  int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
878  for(i=0; i<4; i++){
879  if(IS_DIRECT(sl->sub_mb_type[i])) continue;
880  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
881  unsigned int tmp;
882  if(ref_count == 1){
883  tmp= 0;
884  }else if(ref_count == 2){
885  tmp= get_bits1(&sl->gb)^1;
886  }else{
887  tmp= get_ue_golomb_31(&sl->gb);
888  if(tmp>=ref_count){
889  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
890  return -1;
891  }
892  }
893  ref[list][i]= tmp;
894  }else{
895  //FIXME
896  ref[list][i] = -1;
897  }
898  }
899  }
900 
901  if(dct8x8_allowed)
902  dct8x8_allowed = get_dct8x8_allowed(h, sl);
903 
904  for (list = 0; list < sl->list_count; list++) {
905  for(i=0; i<4; i++){
906  if(IS_DIRECT(sl->sub_mb_type[i])) {
907  sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
908  continue;
909  }
910  sl->ref_cache[list][ scan8[4*i] ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
911  sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
912 
913  if(IS_DIR(sl->sub_mb_type[i], 0, list)){
914  const int sub_mb_type= sl->sub_mb_type[i];
915  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
916  for(j=0; j<sub_partition_count[i]; j++){
917  int mx, my;
918  const int index= 4*i + block_width*j;
919  int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
920  pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
921  mx += (unsigned)get_se_golomb(&sl->gb);
922  my += (unsigned)get_se_golomb(&sl->gb);
923  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
924 
925  if(IS_SUB_8X8(sub_mb_type)){
926  mv_cache[ 1 ][0]=
927  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
928  mv_cache[ 1 ][1]=
929  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
930  }else if(IS_SUB_8X4(sub_mb_type)){
931  mv_cache[ 1 ][0]= mx;
932  mv_cache[ 1 ][1]= my;
933  }else if(IS_SUB_4X8(sub_mb_type)){
934  mv_cache[ 8 ][0]= mx;
935  mv_cache[ 8 ][1]= my;
936  }
937  mv_cache[ 0 ][0]= mx;
938  mv_cache[ 0 ][1]= my;
939  }
940  }else{
941  uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
942  p[0] = p[1]=
943  p[8] = p[9]= 0;
944  }
945  }
946  }
947  }else if(IS_DIRECT(mb_type)){
948  ff_h264_pred_direct_motion(h, sl, &mb_type);
949  dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
950  }else{
951  int list, mx, my, i;
952  //FIXME we should set ref_idx_l? to 0 if we use that later ...
953  if(IS_16X16(mb_type)){
954  for (list = 0; list < sl->list_count; list++) {
955  unsigned int val;
956  if(IS_DIR(mb_type, 0, list)){
957  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
958  if (rc == 1) {
959  val= 0;
960  } else if (rc == 2) {
961  val= get_bits1(&sl->gb)^1;
962  }else{
963  val= get_ue_golomb_31(&sl->gb);
964  if (val >= rc) {
965  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
966  return -1;
967  }
968  }
969  fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
970  }
971  }
972  for (list = 0; list < sl->list_count; list++) {
973  if(IS_DIR(mb_type, 0, list)){
974  pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
975  mx += (unsigned)get_se_golomb(&sl->gb);
976  my += (unsigned)get_se_golomb(&sl->gb);
977  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
978 
979  fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
980  }
981  }
982  }
983  else if(IS_16X8(mb_type)){
984  for (list = 0; list < sl->list_count; list++) {
985  for(i=0; i<2; i++){
986  unsigned int val;
987  if(IS_DIR(mb_type, i, list)){
988  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
989  if (rc == 1) {
990  val= 0;
991  } else if (rc == 2) {
992  val= get_bits1(&sl->gb)^1;
993  }else{
994  val= get_ue_golomb_31(&sl->gb);
995  if (val >= rc) {
996  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
997  return -1;
998  }
999  }
1000  }else
1001  val= LIST_NOT_USED&0xFF;
1002  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1003  }
1004  }
1005  for (list = 0; list < sl->list_count; list++) {
1006  for(i=0; i<2; i++){
1007  unsigned int val;
1008  if(IS_DIR(mb_type, i, list)){
1009  pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1010  mx += (unsigned)get_se_golomb(&sl->gb);
1011  my += (unsigned)get_se_golomb(&sl->gb);
1012  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1013 
1014  val= pack16to32(mx,my);
1015  }else
1016  val=0;
1017  fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1018  }
1019  }
1020  }else{
1021  av_assert2(IS_8X16(mb_type));
1022  for (list = 0; list < sl->list_count; list++) {
1023  for(i=0; i<2; i++){
1024  unsigned int val;
1025  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1026  unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1027  if (rc == 1) {
1028  val= 0;
1029  } else if (rc == 2) {
1030  val= get_bits1(&sl->gb)^1;
1031  }else{
1032  val= get_ue_golomb_31(&sl->gb);
1033  if (val >= rc) {
1034  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1035  return -1;
1036  }
1037  }
1038  }else
1039  val= LIST_NOT_USED&0xFF;
1040  fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1041  }
1042  }
1043  for (list = 0; list < sl->list_count; list++) {
1044  for(i=0; i<2; i++){
1045  unsigned int val;
1046  if(IS_DIR(mb_type, i, list)){
1047  pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1048  mx += (unsigned)get_se_golomb(&sl->gb);
1049  my += (unsigned)get_se_golomb(&sl->gb);
1050  ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1051 
1052  val= pack16to32(mx,my);
1053  }else
1054  val=0;
1055  fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1056  }
1057  }
1058  }
1059  }
1060 
1061  if(IS_INTER(mb_type))
1062  write_back_motion(h, sl, mb_type);
1063 
1064  if(!IS_INTRA16x16(mb_type)){
1065  cbp= get_ue_golomb(&sl->gb);
1066 
1067  if(decode_chroma){
1068  if(cbp > 47){
1069  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1070  return -1;
1071  }
1072  if (IS_INTRA4x4(mb_type))
1073  cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1074  else
1075  cbp = ff_h264_golomb_to_inter_cbp[cbp];
1076  }else{
1077  if(cbp > 15){
1078  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1079  return -1;
1080  }
1081  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1082  else cbp= golomb_to_inter_cbp_gray[cbp];
1083  }
1084  } else {
1085  if (!decode_chroma && cbp>15) {
1086  av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1087  return AVERROR_INVALIDDATA;
1088  }
1089  }
1090 
1091  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1092  mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1093  }
1094  sl->cbp=
1095  h->cbp_table[mb_xy]= cbp;
1096  h->cur_pic.mb_type[mb_xy] = mb_type;
1097 
1098  if(cbp || IS_INTRA16x16(mb_type)){
1099  int i4x4, i8x8, chroma_idx;
1100  int dquant;
1101  int ret;
1102  GetBitContext *gb = &sl->gb;
1103  const uint8_t *scan, *scan8x8;
1104  const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
1105 
1106  dquant= get_se_golomb(&sl->gb);
1107 
1108  sl->qscale += (unsigned)dquant;
1109 
1110  if (((unsigned)sl->qscale) > max_qp){
1111  if (sl->qscale < 0) sl->qscale += max_qp + 1;
1112  else sl->qscale -= max_qp+1;
1113  if (((unsigned)sl->qscale) > max_qp){
1114  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1115  sl->qscale = max_qp;
1116  return -1;
1117  }
1118  }
1119 
1120  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
1121  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
1122 
1123  if(IS_INTERLACED(mb_type)){
1124  scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1125  scan = sl->qscale ? h->field_scan : h->field_scan_q0;
1126  }else{
1127  scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1128  scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1129  }
1130 
1131  if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1132  return -1;
1133  }
1134  h->cbp_table[mb_xy] |= ret << 12;
1135  if (CHROMA444(h)) {
1136  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1137  return -1;
1138  }
1139  if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1140  return -1;
1141  }
1142  } else {
1143  const int num_c8x8 = h->ps.sps->chroma_format_idc;
1144 
1145  if(cbp&0x30){
1146  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1147  if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1148  CHROMA_DC_BLOCK_INDEX + chroma_idx,
1150  NULL, 4 * num_c8x8) < 0) {
1151  return -1;
1152  }
1153  }
1154 
1155  if(cbp&0x20){
1156  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1157  const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1158  int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1159  for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1160  for (i4x4 = 0; i4x4 < 4; i4x4++) {
1161  const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1162  if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1163  return -1;
1164  mb += 16 << pixel_shift;
1165  }
1166  }
1167  }
1168  }else{
1169  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1170  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1171  }
1172  }
1173  }else{
1174  fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1175  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1176  fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1177  }
1178  h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1180 
1181  return 0;
1182 }
static double val(void *priv, double ch)
Definition: aeval.c:76
#define av_always_inline
Definition: attributes.h:45
#define av_cold
Definition: attributes.h:88
uint8_t
int32_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define NULL
Definition: coverity.c:32
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:828
float re
Definition: fft.c:82
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
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
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
exp golomb vlc stuff
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:241
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:122
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
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:106
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:278
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
int index
Definition: gxfenc.c:89
static const int chroma_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:245
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:244
#define CHROMA_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:274
static int get_level_prefix(GetBitContext *gb)
Definition: h264_cavlc.c:411
static const uint8_t chroma422_dc_total_zeros_bits[7][8]
Definition: h264_cavlc.c:209
static VLC_TYPE total_zeros_vlc_tables[15][512][2]
Definition: h264_cavlc.c:252
static VLC total_zeros_vlc[15+1]
Definition: h264_cavlc.c:251
static const uint8_t coeff_token_bits[4][4 *17]
Definition: h264_cavlc.c:120
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_total_zeros_len[7][8]
Definition: h264_cavlc.c:199
static const int run7_vlc_table_size
Definition: h264_cavlc.c:269
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2]
Definition: h264_cavlc.c:248
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:697
static av_cold void init_cavlc_level_tab(void)
Definition: h264_cavlc.c:301
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2]
Definition: h264_cavlc.c:256
static const int run_vlc_tables_size
Definition: h264_cavlc.c:265
static VLC_TYPE run_vlc_tables[6][8][2]
Definition: h264_cavlc.c:264
static const uint8_t chroma422_dc_coeff_token_len[4 *9]
Definition: h264_cavlc.c:65
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
static VLC coeff_token_vlc[4]
Definition: h264_cavlc.c:239
#define COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:276
static const uint8_t chroma_dc_coeff_token_bits[4 *5]
Definition: h264_cavlc.c:57
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:434
static const int coeff_token_vlc_tables_size[4]
Definition: h264_cavlc.c:241
static const uint8_t chroma_dc_coeff_token_len[4 *5]
Definition: h264_cavlc.c:49
static const uint8_t chroma_dc_total_zeros_bits[3][4]
Definition: h264_cavlc.c:193
static const uint8_t golomb_to_intra4x4_cbp_gray[16]
Definition: h264_cavlc.c:45
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:169
static VLC chroma_dc_coeff_token_vlc
Definition: h264_cavlc.c:243
static const int chroma422_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:261
static const int chroma_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:257
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:278
static VLC run7_vlc
Definition: h264_cavlc.c:267
#define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:279
static const uint8_t chroma422_dc_coeff_token_bits[4 *9]
Definition: h264_cavlc.c:77
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2]
Definition: h264_cavlc.c:240
static const uint8_t chroma_dc_total_zeros_len[3][4]
Definition: h264_cavlc.c:187
static VLC run_vlc[6+1]
Definition: h264_cavlc.c:263
static const int total_zeros_vlc_tables_size
Definition: h264_cavlc.c:253
static const uint8_t total_zeros_len[16][16]
Definition: h264_cavlc.c:151
#define STORE_BLOCK(type)
#define RUN7_VLC_BITS
Definition: h264_cavlc.c:281
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:260
static const int chroma422_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:249
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:219
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
static const uint8_t golomb_to_inter_cbp_gray[16]
Definition: h264_cavlc.c:41
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
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:627
#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:275
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
static VLC chroma_dc_total_zeros_vlc[3+1]
Definition: h264_cavlc.c:255
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:271
static VLC chroma422_dc_total_zeros_vlc[7+1]
Definition: h264_cavlc.c:259
static int8_t cavlc_level_tab[7][1<< LEVEL_TAB_BITS][2]
Definition: h264_cavlc.c:272
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:327
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
Definition: h264_direct.c:721
H.264 / AVC / MPEG-4 part10 motion vector prediction.
static void fill_decode_neighbors(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:357
static void av_unused decode_mb_skip(const H264Context *h, H264SliceContext *sl)
decodes a P_SKIP or B_SKIP macroblock
Definition: h264_mvpred.h:804
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:96
static void fill_decode_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:446
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:202
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:161
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
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
const IMbInfo ff_h264_i_mb_type_info[26]
Definition: h264data.c:66
const PMbInfo ff_h264_p_mb_type_info[5]
Definition: h264data.c:95
const uint8_t ff_h264_golomb_to_inter_cbp[48]
Definition: h264data.c:48
const uint8_t ff_h264_chroma422_dc_scan[8]
Definition: h264data.c:59
const PMbInfo ff_h264_b_sub_mb_type_info[13]
Definition: h264data.c:136
const uint8_t ff_h264_chroma_dc_scan[4]
Definition: h264data.c:54
const PMbInfo ff_h264_b_mb_type_info[23]
Definition: h264data.c:110
const uint8_t ff_h264_golomb_to_intra4x4_cbp[48]
Definition: h264data.c:42
const PMbInfo ff_h264_p_sub_mb_type_info[4]
Definition: h264data.c:103
H.264 / AVC / MPEG-4 part10 codec.
#define MB_MBAFF(h)
Definition: h264dec.h:72
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:651
#define CHROMA444(h)
Definition: h264dec.h:100
static av_always_inline void write_back_motion(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264dec.h:784
static av_always_inline int pred_intra_mode(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264dec.h:696
#define IS_8x8DCT(a)
Definition: h264dec.h:105
#define MB_FIELD(sl)
Definition: h264dec.h:73
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:811
#define LIST_NOT_USED
Definition: h264dec.h:397
static av_always_inline void write_back_non_zero_count(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:724
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:667
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
Definition: h264dec.h:688
#define CHROMA422(h)
Definition: h264dec.h:99
#define PART_NOT_AVAILABLE
Definition: h264dec.h:398
#define LUMA_DC_BLOCK_INDEX
Definition: h264dec.h:647
#define CHROMA_DC_BLOCK_INDEX
Definition: h264dec.h:648
#define IS_REF0(a)
Definition: h264dec.h:104
#define FRAME_MBAFF(h)
Definition: h264dec.h:74
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:712
#define MB_TYPE_8x8DCT
Definition: h264dec.h:103
#define DC_128_PRED8x8
Definition: h264pred.h:76
#define IS_INTRA(x, y)
int i
Definition: input.c:407
#define av_log2
Definition: intmath.h:83
#define AV_ZERO128(d)
Definition: intreadwrite.h:637
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:59
#define ff_tlog(ctx,...)
Definition: internal.h:91
common internal API header
static const uint16_t mask[17]
Definition: lzw.c:38
#define IS_INTRA_PCM(a)
Definition: mpegutils.h:82
#define IS_SUB_8X8(a)
Definition: mpegutils.h:90
#define IS_DIR(a, part, list)
Definition: mpegutils.h:96
#define IS_SUB_4X8(a)
Definition: mpegutils.h:92
#define IS_SUB_8X4(a)
Definition: mpegutils.h:91
#define IS_INTERLACED(a)
Definition: mpegutils.h:83
#define IS_DIRECT(a)
Definition: mpegutils.h:84
#define IS_INTRA4x4(a)
Definition: mpegutils.h:75
#define IS_INTER(a)
Definition: mpegutils.h:79
#define IS_16X8(a)
Definition: mpegutils.h:87
#define IS_8X16(a)
Definition: mpegutils.h:88
#define MB_TYPE_16x8
Definition: mpegutils.h:55
#define IS_16X16(a)
Definition: mpegutils.h:86
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:58
#define MB_TYPE_16x16
Definition: mpegutils.h:54
#define IS_INTRA16x16(a)
Definition: mpegutils.h:76
static const uint16_t table[]
Definition: prosumer.c:206
#define FF_ARRAY_ELEMS(a)
H264Context.
Definition: h264dec.h:344
int mb_field_decoding_flag
Definition: h264dec.h:248
unsigned int list_count
Definition: h264dec.h:275
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:307
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:311
int chroma_pred_mode
Definition: h264dec.h:209
const uint8_t * intra_pcm_ptr
Definition: h264dec.h:287
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:306
unsigned int left_samples_available
Definition: h264dec.h:231
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:191
unsigned int top_samples_available
Definition: h264dec.h:229
int16_t mb[16 *48 *2]
Definition: h264dec.h:314
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:249
GetBitContext gb
Definition: h264dec.h:186
int prev_mb_skipped
Definition: h264dec.h:206
int chroma_qp[2]
Definition: h264dec.h:195
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264dec.h:212
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:301
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:274
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:315
int intra16x16_pred_mode
Definition: h264dec.h:210
uint8_t cbp
Definition: h264data.h:36
uint8_t pred_mode
Definition: h264data.h:35
uint16_t type
Definition: h264data.h:34
uint16_t type
Definition: h264data.h:42
uint8_t partition_count
Definition: h264data.h:43
Definition: vlc.h:26
int table_allocated
Definition: vlc.h:29
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
uint8_t level
Definition: svq3.c:206
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
static int16_t block[64]
Definition: dct.c:116
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
#define mb
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
#define VLC_TYPE
Definition: vlc.h:24