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