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