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