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