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 {
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 }
IS_INTRA4x4
#define IS_INTRA4x4(a)
Definition: mpegutils.h:75
H264SliceContext::mb_xy
int mb_xy
Definition: h264dec.h:238
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
H264SliceContext::ref_cache
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:307
level
uint8_t level
Definition: svq3.c:204
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
CHROMA422
#define CHROMA422(h)
Definition: h264dec.h:99
H264SliceContext::intra_pcm_ptr
const uint8_t * intra_pcm_ptr
Definition: h264dec.h:287
chroma422_dc_total_zeros_bits
static const uint8_t chroma422_dc_total_zeros_bits[7][8]
Definition: h264_cavlc.c:209
chroma_dc_coeff_token_vlc
static VLC chroma_dc_coeff_token_vlc
Definition: h264_cavlc.c:243
ff_h264_mb_sizes
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:59
total_zeros_len
static const uint8_t total_zeros_len[16][16]
Definition: h264_cavlc.c:151
golomb_to_inter_cbp_gray
static const uint8_t golomb_to_inter_cbp_gray[16]
Definition: h264_cavlc.c:41
COEFF_TOKEN_VLC_BITS
#define COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:276
pred_16x8_motion
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
coeff_token_bits
static const uint8_t coeff_token_bits[4][4 *17]
Definition: h264_cavlc.c:120
run_vlc_tables
static VLC_TYPE run_vlc_tables[6][8][2]
Definition: h264_cavlc.c:264
H264SliceContext::mb
int16_t mb[16 *48 *2]
Definition: h264dec.h:314
MB_TYPE_16x8
#define MB_TYPE_16x8
Definition: mpegutils.h:55
MB_MBAFF
#define MB_MBAFF(h)
Definition: h264dec.h:72
chroma422_dc_coeff_token_vlc_table
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2]
Definition: h264_cavlc.c:248
ff_h264_golomb_to_inter_cbp
const uint8_t ff_h264_golomb_to_inter_cbp[48]
Definition: h264data.c:48
total_zeros_vlc
static VLC total_zeros_vlc[15+1]
Definition: h264_cavlc.c:251
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
total_zeros_vlc_tables_size
static const int total_zeros_vlc_tables_size
Definition: h264_cavlc.c:253
index
fg index
Definition: ffmpeg_filter.c:170
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
IMbInfo::cbp
uint8_t cbp
Definition: h264data.h:36
MB_TYPE_8x8DCT
#define MB_TYPE_8x8DCT
Definition: h264dec.h:103
internal.h
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
run_vlc_tables_size
static const int run_vlc_tables_size
Definition: h264_cavlc.c:265
table
static const uint16_t table[]
Definition: prosumer.c:206
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:274
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:54
get_vlc2
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
run7_vlc_table
static VLC_TYPE run7_vlc_table[96][2]
Definition: h264_cavlc.c:268
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:91
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
ff_h264_golomb_to_intra4x4_cbp
const uint8_t ff_h264_golomb_to_intra4x4_cbp[48]
Definition: h264data.c:42
H264SliceContext::sub_mb_type
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
chroma422_dc_coeff_token_vlc
static VLC chroma422_dc_coeff_token_vlc
Definition: h264_cavlc.c:247
CHROMA_DC_COEFF_TOKEN_VLC_BITS
#define CHROMA_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:274
mpegutils.h
coeff_token_vlc_tables_size
static const int coeff_token_vlc_tables_size[4]
Definition: h264_cavlc.c:241
LEVEL_TAB_BITS
#define LEVEL_TAB_BITS
Definition: h264_cavlc.c:271
H264SliceContext::mb_x
int mb_x
Definition: h264dec.h:237
h264_mvpred.h
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
H264SliceContext
Definition: h264dec.h:184
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
golomb.h
exp golomb vlc stuff
MB_FIELD
#define MB_FIELD(sl)
Definition: h264dec.h:73
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
H264SliceContext::mv_cache
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:306
chroma_dc_total_zeros_bits
static const uint8_t chroma_dc_total_zeros_bits[3][4]
Definition: h264_cavlc.c:193
get_chroma_qp
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
Definition: h264dec.h:688
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
U
#define U(x)
Definition: vp56_arith.h:37
golomb_to_intra4x4_cbp_gray
static const uint8_t golomb_to_intra4x4_cbp_gray[16]
Definition: h264_cavlc.c:45
chroma_dc_total_zeros_vlc_tables_size
static const int chroma_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:257
GetBitContext
Definition: get_bits.h:61
run7_vlc
static VLC run7_vlc
Definition: h264_cavlc.c:267
RUN_VLC_BITS
#define RUN_VLC_BITS
Definition: h264_cavlc.c:280
val
static double val(void *priv, double ch)
Definition: aeval.c:76
chroma422_dc_coeff_token_vlc_table_size
static const int chroma422_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:249
PMbInfo::partition_count
uint8_t partition_count
Definition: h264data.h:43
CHROMA422_DC_COEFF_TOKEN_VLC_BITS
#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS
Definition: h264_cavlc.c:275
H264SliceContext::slice_num
int slice_num
Definition: h264dec.h:189
STORE_BLOCK
#define STORE_BLOCK(type)
fill_decode_neighbors
static void fill_decode_neighbors(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:357
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
mask
static const uint16_t mask[17]
Definition: lzw.c:38
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
chroma_dc_total_zeros_len
static const uint8_t chroma_dc_total_zeros_len[3][4]
Definition: h264_cavlc.c:187
run7_vlc_table_size
static const int run7_vlc_table_size
Definition: h264_cavlc.c:269
IS_16X8
#define IS_16X8(a)
Definition: mpegutils.h:87
chroma_dc_coeff_token_vlc_table
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2]
Definition: h264_cavlc.c:244
pred_intra_mode
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
IS_SUB_4X8
#define IS_SUB_4X8(a)
Definition: mpegutils.h:92
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
h264data.h
RUN7_VLC_BITS
#define RUN7_VLC_BITS
Definition: h264_cavlc.c:281
chroma_dc_coeff_token_bits
static const uint8_t chroma_dc_coeff_token_bits[4 *5]
Definition: h264_cavlc.c:57
chroma422_dc_total_zeros_vlc_tables
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2]
Definition: h264_cavlc.c:260
IS_INTRA
#define IS_INTRA(x, y)
ff_h264_pred_direct_motion
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
Definition: h264_direct.c:721
H264SliceContext::slice_type
int slice_type
Definition: h264dec.h:190
chroma422_dc_coeff_token_len
static const uint8_t chroma422_dc_coeff_token_len[4 *9]
Definition: h264_cavlc.c:65
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:241
int32_t
int32_t
Definition: audio_convert.c:194
IMbInfo::pred_mode
uint8_t pred_mode
Definition: h264data.h:35
IS_DIR
#define IS_DIR(a, part, list)
Definition: mpegutils.h:96
NULL
#define NULL
Definition: coverity.c:32
IS_INTRA_PCM
#define IS_INTRA_PCM(a)
Definition: mpegutils.h:82
decode_mb_skip
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
pred_non_zero_count
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
fill_decode_caches
static void fill_decode_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_mvpred.h:446
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:278
H264SliceContext::chroma_qp
int chroma_qp[2]
Definition: h264dec.h:195
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
list
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
Definition: filter_design.txt:25
IS_INTERLACED
#define IS_INTERLACED(a)
Definition: mpegutils.h:83
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
ff_h264_chroma_dc_scan
const uint8_t ff_h264_chroma_dc_scan[4]
Definition: h264data.c:54
H264SliceContext::top_samples_available
unsigned int top_samples_available
Definition: h264dec.h:229
H264SliceContext::mb_luma_dc
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
H264SliceContext::qscale
int qscale
Definition: h264dec.h:194
CHROMA_DC_BLOCK_INDEX
#define CHROMA_DC_BLOCK_INDEX
Definition: h264dec.h:648
write_back_motion
static av_always_inline void write_back_motion(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264dec.h:784
total_zeros_bits
static const uint8_t total_zeros_bits[16][16]
Definition: h264_cavlc.c:169
AV_ZERO128
#define AV_ZERO128(d)
Definition: intreadwrite.h:637
H264SliceContext::mb_skip_run
int mb_skip_run
Definition: h264dec.h:244
get_dct8x8_allowed
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:811
PMbInfo::type
uint16_t type
Definition: h264data.h:42
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
IMbInfo::type
uint16_t type
Definition: h264data.h:34
TOTAL_ZEROS_VLC_BITS
#define TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:277
H264SliceContext::intra4x4_pred_mode_cache
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264dec.h:212
CHROMA422_DC_TOTAL_ZEROS_VLC_BITS
#define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:279
chroma422_dc_total_zeros_len
static const uint8_t chroma422_dc_total_zeros_len[7][8]
Definition: h264_cavlc.c:199
coeff_token_len
static const uint8_t coeff_token_len[4][4 *17]
Definition: h264_cavlc.c:89
H264SliceContext::intra16x16_pred_mode
int intra16x16_pred_mode
Definition: h264dec.h:210
ff_h264_decode_mb_cavlc
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:697
run_bits
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
DC_128_PRED8x8
#define DC_128_PRED8x8
Definition: h264pred.h:76
H264SliceContext::cbp
int cbp
Definition: h264dec.h:262
ff_h264_chroma422_dc_scan
const uint8_t ff_h264_chroma422_dc_scan[8]
Definition: h264data.c:59
MB_TYPE_INTERLACED
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:58
LUMA_DC_BLOCK_INDEX
#define LUMA_DC_BLOCK_INDEX
Definition: h264dec.h:647
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
H264SliceContext::mb_y
int mb_y
Definition: h264dec.h:237
offset
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
Definition: writing_filters.txt:86
pred_motion
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
H264SliceContext::slice_type_nos
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:191
get_level_prefix
static int get_level_prefix(GetBitContext *gb)
Definition: h264_cavlc.c:411
IS_INTRA16x16
#define IS_INTRA16x16(a)
Definition: mpegutils.h:76
mb
#define mb
Definition: vf_colormatrix.c:101
FRAME_MBAFF
#define FRAME_MBAFF(h)
Definition: h264dec.h:74
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:84
IS_16X16
#define IS_16X16(a)
Definition: mpegutils.h:86
ff_h264_b_mb_type_info
const PMbInfo ff_h264_b_mb_type_info[23]
Definition: h264data.c:110
pack16to32
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:667
H264SliceContext::mb_mbaff
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:249
av_get_picture_type_char
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
LIST_NOT_USED
#define LIST_NOT_USED
Definition: h264dec.h:397
IS_SUB_8X4
#define IS_SUB_8X4(a)
Definition: mpegutils.h:91
h264dec.h
IS_REF0
#define IS_REF0(a)
Definition: h264dec.h:104
ff_h264_p_sub_mb_type_info
const PMbInfo ff_h264_p_sub_mb_type_info[4]
Definition: h264data.c:103
H264SliceContext::chroma_pred_mode
int chroma_pred_mode
Definition: h264dec.h:209
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
int i
Definition: input.c:407
H264Context
H264Context.
Definition: h264dec.h:344
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
chroma422_dc_total_zeros_vlc_tables_size
static const int chroma422_dc_total_zeros_vlc_tables_size
Definition: h264_cavlc.c:261
av_always_inline
#define av_always_inline
Definition: attributes.h:49
chroma422_dc_coeff_token_bits
static const uint8_t chroma422_dc_coeff_token_bits[4 *9]
Definition: h264_cavlc.c:77
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_h264_decode_init_vlc
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:327
ff_h264_b_sub_mb_type_info
const PMbInfo ff_h264_b_sub_mb_type_info[13]
Definition: h264data.c:136
PART_NOT_AVAILABLE
#define PART_NOT_AVAILABLE
Definition: h264dec.h:398
H264SliceContext::list_count
unsigned int list_count
Definition: h264dec.h:275
chroma_dc_total_zeros_vlc_tables
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2]
Definition: h264_cavlc.c:256
chroma_dc_coeff_token_vlc_table_size
static const int chroma_dc_coeff_token_vlc_table_size
Definition: h264_cavlc.c:245
avcodec.h
cavlc_level_tab
static int8_t cavlc_level_tab[7][1<< LEVEL_TAB_BITS][2]
Definition: h264_cavlc.c:272
ret
ret
Definition: filter_design.txt:187
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
ff_h264_p_mb_type_info
const PMbInfo ff_h264_p_mb_type_info[5]
Definition: h264data.c:95
left
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:386
run_len
static const uint8_t run_len[7][16]
Definition: h264_cavlc.c:219
pred_8x16_motion
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
chroma422_dc_total_zeros_vlc
static VLC chroma422_dc_total_zeros_vlc[7+1]
Definition: h264_cavlc.c:259
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:122
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
chroma_dc_total_zeros_vlc
static VLC chroma_dc_total_zeros_vlc[3+1]
Definition: h264_cavlc.c:255
mode
mode
Definition: ebur128.h:83
ff_h264_check_intra4x4_pred_mode
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
ff_h264_i_mb_type_info
const IMbInfo ff_h264_i_mb_type_info[26]
Definition: h264data.c:66
VLC
Definition: vlc.h:26
fill_rectangle
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:828
scan8
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:651
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
IS_8X16
#define IS_8X16(a)
Definition: mpegutils.h:88
init_cavlc_level_tab
static av_cold void init_cavlc_level_tab(void)
Definition: h264_cavlc.c:301
CHROMA_DC_TOTAL_ZEROS_VLC_BITS
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS
Definition: h264_cavlc.c:278
H264SliceContext::non_zero_count_cache
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:301
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
IS_INTER
#define IS_INTER(a)
Definition: mpegutils.h:79
get_ue_golomb_long
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
H264SliceContext::left_samples_available
unsigned int left_samples_available
Definition: h264dec.h:231
H264SliceContext::gb
GetBitContext gb
Definition: h264dec.h:186
chroma_dc_coeff_token_len
static const uint8_t chroma_dc_coeff_token_len[4 *5]
Definition: h264_cavlc.c:49
coeff_token_vlc
static VLC coeff_token_vlc[4]
Definition: h264_cavlc.c:239
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
CHROMA444
#define CHROMA444(h)
Definition: h264dec.h:100
coeff_token_vlc_tables
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2]
Definition: h264_cavlc.c:240
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
run_vlc
static VLC run_vlc[6+1]
Definition: h264_cavlc.c:263
decode_residual
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
h
h
Definition: vp9dsp_template.c:2038
write_back_intra_pred_mode
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:712
total_zeros_vlc_tables
static VLC_TYPE total_zeros_vlc_tables[15][512][2]
Definition: h264_cavlc.c:252
decode_luma_residual
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
write_back_non_zero_count
static av_always_inline void write_back_non_zero_count(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:724
IS_8x8DCT
#define IS_8x8DCT(a)
Definition: h264dec.h:105
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
H264SliceContext::prev_mb_skipped
int prev_mb_skipped
Definition: h264dec.h:206
ff_h264_check_intra_pred_mode
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
H264SliceContext::mb_field_decoding_flag
int mb_field_decoding_flag
Definition: h264dec.h:248
re
float re
Definition: fft.c:82
IS_SUB_8X8
#define IS_SUB_8X8(a)
Definition: mpegutils.h:90