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 "mpegvideo.h"
34 #include "h264.h"
35 #include "h264data.h" // FIXME FIXME FIXME
36 #include "h264_mvpred.h"
37 #include "golomb.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(H264Context *h, int n){
288  const int index8= scan8[n];
289  const int left= h->non_zero_count_cache[index8 - 1];
290  const int top = h->non_zero_count_cache[index8 - 8];
291  int i= left + top;
292 
293  if(i<64) i= (i+1)>>1;
294 
295  tprintf(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
296 
297  return i&31;
298 }
299 
300 static av_cold void init_cavlc_level_tab(void){
301  int suffix_length;
302  unsigned int i;
303 
304  for(suffix_length=0; suffix_length<7; suffix_length++){
305  for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
306  int prefix= LEVEL_TAB_BITS - av_log2(2*i);
307 
308  if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
309  int level_code = (prefix << suffix_length) +
310  (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
311  int mask = -(level_code&1);
312  level_code = (((2 + level_code) >> 1) ^ mask) - mask;
313  cavlc_level_tab[suffix_length][i][0]= level_code;
314  cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
315  }else if(prefix + 1 <= LEVEL_TAB_BITS){
316  cavlc_level_tab[suffix_length][i][0]= prefix+100;
317  cavlc_level_tab[suffix_length][i][1]= prefix + 1;
318  }else{
319  cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
320  cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
321  }
322  }
323  }
324 }
325 
327  static int done = 0;
328 
329  if (!done) {
330  int i;
331  int offset;
332  done = 1;
333 
334  chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
335  chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
336  init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
337  &chroma_dc_coeff_token_len [0], 1, 1,
338  &chroma_dc_coeff_token_bits[0], 1, 1,
340 
341  chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
342  chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
343  init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
344  &chroma422_dc_coeff_token_len [0], 1, 1,
347 
348  offset = 0;
349  for(i=0; i<4; i++){
350  coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
351  coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
352  init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
353  &coeff_token_len [i][0], 1, 1,
354  &coeff_token_bits[i][0], 1, 1,
356  offset += coeff_token_vlc_tables_size[i];
357  }
358  /*
359  * This is a one time safety check to make sure that
360  * the packed static coeff_token_vlc table sizes
361  * were initialized correctly.
362  */
364 
365  for(i=0; i<3; i++){
366  chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
367  chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
368  init_vlc(&chroma_dc_total_zeros_vlc[i],
370  &chroma_dc_total_zeros_len [i][0], 1, 1,
371  &chroma_dc_total_zeros_bits[i][0], 1, 1,
373  }
374 
375  for(i=0; i<7; i++){
376  chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
377  chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
378  init_vlc(&chroma422_dc_total_zeros_vlc[i],
380  &chroma422_dc_total_zeros_len [i][0], 1, 1,
381  &chroma422_dc_total_zeros_bits[i][0], 1, 1,
383  }
384 
385  for(i=0; i<15; i++){
386  total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
387  total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
388  init_vlc(&total_zeros_vlc[i],
390  &total_zeros_len [i][0], 1, 1,
391  &total_zeros_bits[i][0], 1, 1,
393  }
394 
395  for(i=0; i<6; i++){
396  run_vlc[i].table = run_vlc_tables[i];
398  init_vlc(&run_vlc[i],
399  RUN_VLC_BITS, 7,
400  &run_len [i][0], 1, 1,
401  &run_bits[i][0], 1, 1,
403  }
404  run7_vlc.table = run7_vlc_table,
406  init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
407  &run_len [6][0], 1, 1,
408  &run_bits[6][0], 1, 1,
410 
412  }
413 }
414 
415 /**
416  *
417  */
418 static inline int get_level_prefix(GetBitContext *gb){
419  unsigned int buf;
420  int log;
421 
422  OPEN_READER(re, gb);
423  UPDATE_CACHE(re, gb);
424  buf=GET_CACHE(re, gb);
425 
426  log= 32 - av_log2(buf);
427 #ifdef TRACE
428  print_bin(buf>>(32-log), log);
429  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__);
430 #endif
431 
432  LAST_SKIP_BITS(re, gb, log);
433  CLOSE_READER(re, gb);
434 
435  return log-1;
436 }
437 
438 /**
439  * Decode a residual block.
440  * @param n block index
441  * @param scantable scantable
442  * @param max_coeff number of coefficients in the block
443  * @return <0 if an error occurred
444  */
445 static int decode_residual(H264Context *h, GetBitContext *gb, int16_t *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
446  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};
447  int level[16];
448  int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
449 
450  //FIXME put trailing_onex into the context
451 
452  if(max_coeff <= 8){
453  if (max_coeff == 4)
454  coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
455  else
456  coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
457  total_coeff= coeff_token>>2;
458  }else{
459  if(n >= LUMA_DC_BLOCK_INDEX){
460  total_coeff= pred_non_zero_count(h, (n - LUMA_DC_BLOCK_INDEX)*16);
461  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
462  total_coeff= coeff_token>>2;
463  }else{
464  total_coeff= pred_non_zero_count(h, n);
465  coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
466  total_coeff= coeff_token>>2;
467  }
468  }
469  h->non_zero_count_cache[ scan8[n] ]= total_coeff;
470 
471  //FIXME set last_non_zero?
472 
473  if(total_coeff==0)
474  return 0;
475  if(total_coeff > (unsigned)max_coeff) {
476  av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", h->mb_x, h->mb_y, total_coeff);
477  return -1;
478  }
479 
480  trailing_ones= coeff_token&3;
481  tprintf(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
482  av_assert2(total_coeff<=16);
483 
484  i = show_bits(gb, 3);
485  skip_bits(gb, trailing_ones);
486  level[0] = 1-((i&4)>>1);
487  level[1] = 1-((i&2) );
488  level[2] = 1-((i&1)<<1);
489 
490  if(trailing_ones<total_coeff) {
491  int mask, prefix;
492  int suffix_length = total_coeff > 10 & trailing_ones < 3;
493  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
494  int level_code= cavlc_level_tab[suffix_length][bitsi][0];
495 
496  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
497  if(level_code >= 100){
498  prefix= level_code - 100;
499  if(prefix == LEVEL_TAB_BITS)
500  prefix += get_level_prefix(gb);
501 
502  //first coefficient has suffix_length equal to 0 or 1
503  if(prefix<14){ //FIXME try to build a large unified VLC table for all this
504  if(suffix_length)
505  level_code= (prefix<<1) + get_bits1(gb); //part
506  else
507  level_code= prefix; //part
508  }else if(prefix==14){
509  if(suffix_length)
510  level_code= (prefix<<1) + get_bits1(gb); //part
511  else
512  level_code= prefix + get_bits(gb, 4); //part
513  }else{
514  level_code= 30;
515  if(prefix>=16){
516  if(prefix > 25+3){
517  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
518  return -1;
519  }
520  level_code += (1<<(prefix-3))-4096;
521  }
522  level_code += get_bits(gb, prefix-3); //part
523  }
524 
525  if(trailing_ones < 3) level_code += 2;
526 
527  suffix_length = 2;
528  mask= -(level_code&1);
529  level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
530  }else{
531  level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
532 
533  suffix_length = 1 + (level_code + 3U > 6U);
534  level[trailing_ones]= level_code;
535  }
536 
537  //remaining coefficients have suffix_length > 0
538  for(i=trailing_ones+1;i<total_coeff;i++) {
539  static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
540  int bitsi= show_bits(gb, LEVEL_TAB_BITS);
541  level_code= cavlc_level_tab[suffix_length][bitsi][0];
542 
543  skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
544  if(level_code >= 100){
545  prefix= level_code - 100;
546  if(prefix == LEVEL_TAB_BITS){
547  prefix += get_level_prefix(gb);
548  }
549  if(prefix<15){
550  level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
551  }else{
552  level_code = 15<<suffix_length;
553  if (prefix>=16) {
554  if(prefix > 25+3){
555  av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
556  return AVERROR_INVALIDDATA;
557  }
558  level_code += (1<<(prefix-3))-4096;
559  }
560  level_code += get_bits(gb, prefix-3);
561  }
562  mask= -(level_code&1);
563  level_code= (((2+level_code)>>1) ^ mask) - mask;
564  }
565  level[i]= level_code;
566  suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
567  }
568  }
569 
570  if(total_coeff == max_coeff)
571  zeros_left=0;
572  else{
573  if (max_coeff <= 8) {
574  if (max_coeff == 4)
575  zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
577  else
578  zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
580  } else {
581  zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
582  }
583  }
584 
585 #define STORE_BLOCK(type) \
586  scantable += zeros_left + total_coeff - 1; \
587  if(n >= LUMA_DC_BLOCK_INDEX){ \
588  ((type*)block)[*scantable] = level[0]; \
589  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
590  if(zeros_left < 7) \
591  run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
592  else \
593  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
594  zeros_left -= run_before; \
595  scantable -= 1 + run_before; \
596  ((type*)block)[*scantable]= level[i]; \
597  } \
598  for(;i<total_coeff;i++) { \
599  scantable--; \
600  ((type*)block)[*scantable]= level[i]; \
601  } \
602  }else{ \
603  ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
604  for(i=1;i<total_coeff && zeros_left > 0;i++) { \
605  if(zeros_left < 7) \
606  run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
607  else \
608  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
609  zeros_left -= run_before; \
610  scantable -= 1 + run_before; \
611  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
612  } \
613  for(;i<total_coeff;i++) { \
614  scantable--; \
615  ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
616  } \
617  }
618 
619  if (h->pixel_shift) {
621  } else {
622  STORE_BLOCK(int16_t)
623  }
624 
625  if(zeros_left<0){
626  av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
627  return -1;
628  }
629 
630  return 0;
631 }
632 
633 static av_always_inline int decode_luma_residual(H264Context *h, GetBitContext *gb, const uint8_t *scan, const uint8_t *scan8x8, int pixel_shift, int mb_type, int cbp, int p){
634  int i4x4, i8x8;
635  int qscale = p == 0 ? h->qscale : h->chroma_qp[p-1];
636  if(IS_INTRA16x16(mb_type)){
637  AV_ZERO128(h->mb_luma_dc[p]+0);
638  AV_ZERO128(h->mb_luma_dc[p]+8);
639  AV_ZERO128(h->mb_luma_dc[p]+16);
640  AV_ZERO128(h->mb_luma_dc[p]+24);
641  if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX+p, scan, NULL, 16) < 0){
642  return -1; //FIXME continue if partitioned and other return -1 too
643  }
644 
645  av_assert2((cbp&15) == 0 || (cbp&15) == 15);
646 
647  if(cbp&15){
648  for(i8x8=0; i8x8<4; i8x8++){
649  for(i4x4=0; i4x4<4; i4x4++){
650  const int index= i4x4 + 4*i8x8 + p*16;
651  if( decode_residual(h, h->intra_gb_ptr, h->mb + (16*index << pixel_shift),
652  index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
653  return -1;
654  }
655  }
656  }
657  return 0xf;
658  }else{
659  fill_rectangle(&h->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
660  return 0;
661  }
662  }else{
663  int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
664  /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
665  int new_cbp = 0;
666  for(i8x8=0; i8x8<4; i8x8++){
667  if(cbp & (1<<i8x8)){
668  if(IS_8x8DCT(mb_type)){
669  int16_t *buf = &h->mb[64*i8x8+256*p << pixel_shift];
670  uint8_t *nnz;
671  for(i4x4=0; i4x4<4; i4x4++){
672  const int index= i4x4 + 4*i8x8 + p*16;
673  if( decode_residual(h, gb, buf, index, scan8x8+16*i4x4,
674  h->dequant8_coeff[cqm][qscale], 16) < 0 )
675  return -1;
676  }
677  nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
678  nnz[0] += nnz[1] + nnz[8] + nnz[9];
679  new_cbp |= !!nnz[0] << i8x8;
680  }else{
681  for(i4x4=0; i4x4<4; i4x4++){
682  const int index= i4x4 + 4*i8x8 + p*16;
683  if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index,
684  scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
685  return -1;
686  }
687  new_cbp |= h->non_zero_count_cache[ scan8[index] ] << i8x8;
688  }
689  }
690  }else{
691  uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
692  nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
693  }
694  }
695  return new_cbp;
696  }
697 }
698 
700  int mb_xy;
701  int partition_count;
702  unsigned int mb_type, cbp;
703  int dct8x8_allowed= h->pps.transform_8x8_mode;
704  int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
705  const int pixel_shift = h->pixel_shift;
706  unsigned local_ref_count[2];
707 
708  mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
709 
710  tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
711  cbp = 0; /* avoid warning. FIXME: find a solution without slowing
712  down the code */
714  if(h->mb_skip_run==-1)
716 
717  if (h->mb_skip_run--) {
718  if(FRAME_MBAFF(h) && (h->mb_y&1) == 0){
719  if(h->mb_skip_run==0)
721  }
722  decode_mb_skip(h);
723  return 0;
724  }
725  }
726  if (FRAME_MBAFF(h)) {
727  if( (h->mb_y&1) == 0 )
729  }
730 
731  h->prev_mb_skipped= 0;
732 
733  mb_type= get_ue_golomb(&h->gb);
735  if(mb_type < 23){
736  partition_count= b_mb_type_info[mb_type].partition_count;
737  mb_type= b_mb_type_info[mb_type].type;
738  }else{
739  mb_type -= 23;
740  goto decode_intra_mb;
741  }
742  }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
743  if(mb_type < 5){
744  partition_count= p_mb_type_info[mb_type].partition_count;
745  mb_type= p_mb_type_info[mb_type].type;
746  }else{
747  mb_type -= 5;
748  goto decode_intra_mb;
749  }
750  }else{
752  if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
753  mb_type--;
754 decode_intra_mb:
755  if(mb_type > 25){
756  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(h->slice_type), h->mb_x, h->mb_y);
757  return -1;
758  }
759  partition_count=0;
760  cbp= i_mb_type_info[mb_type].cbp;
762  mb_type= i_mb_type_info[mb_type].type;
763  }
764 
765  if(MB_FIELD(h))
766  mb_type |= MB_TYPE_INTERLACED;
767 
768  h->slice_table[ mb_xy ]= h->slice_num;
769 
770  if(IS_INTRA_PCM(mb_type)){
771  const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
772  h->sps.bit_depth_luma;
773 
774  // We assume these blocks are very rare so we do not optimize it.
775  h->intra_pcm_ptr = align_get_bits(&h->gb);
776  skip_bits_long(&h->gb, mb_size);
777 
778  // In deblocking, the quantizer is 0
779  h->cur_pic.qscale_table[mb_xy] = 0;
780  // All coeffs are present
781  memset(h->non_zero_count[mb_xy], 16, 48);
782 
783  h->cur_pic.mb_type[mb_xy] = mb_type;
784  return 0;
785  }
786 
787  local_ref_count[0] = h->ref_count[0] << MB_MBAFF(h);
788  local_ref_count[1] = h->ref_count[1] << MB_MBAFF(h);
789 
790  fill_decode_neighbors(h, mb_type);
791  fill_decode_caches(h, mb_type);
792 
793  //mb_pred
794  if(IS_INTRA(mb_type)){
795  int pred_mode;
796 // init_top_left_availability(h);
797  if(IS_INTRA4x4(mb_type)){
798  int i;
799  int di = 1;
800  if(dct8x8_allowed && get_bits1(&h->gb)){
801  mb_type |= MB_TYPE_8x8DCT;
802  di = 4;
803  }
804 
805 // fill_intra4x4_pred_table(h);
806  for(i=0; i<16; i+=di){
807  int mode= pred_intra_mode(h, i);
808 
809  if(!get_bits1(&h->gb)){
810  const int rem_mode= get_bits(&h->gb, 3);
811  mode = rem_mode + (rem_mode >= mode);
812  }
813 
814  if(di==4)
815  fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
816  else
818  }
821  return -1;
822  }else{
824  if(h->intra16x16_pred_mode < 0)
825  return -1;
826  }
827  if(decode_chroma){
828  pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&h->gb), 1);
829  if(pred_mode < 0)
830  return -1;
831  h->chroma_pred_mode= pred_mode;
832  } else {
834  }
835  }else if(partition_count==4){
836  int i, j, sub_partition_count[4], list, ref[2][4];
837 
839  for(i=0; i<4; i++){
840  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
841  if(h->sub_mb_type[i] >=13){
842  av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], h->mb_x, h->mb_y);
843  return -1;
844  }
845  sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
847  }
848  if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
849  ff_h264_pred_direct_motion(h, &mb_type);
850  h->ref_cache[0][scan8[4]] =
851  h->ref_cache[1][scan8[4]] =
852  h->ref_cache[0][scan8[12]] =
853  h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
854  }
855  }else{
856  av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
857  for(i=0; i<4; i++){
858  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
859  if(h->sub_mb_type[i] >=4){
860  av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], h->mb_x, h->mb_y);
861  return -1;
862  }
863  sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
865  }
866  }
867 
868  for(list=0; list<h->list_count; list++){
869  int ref_count= IS_REF0(mb_type) ? 1 : local_ref_count[list];
870  for(i=0; i<4; i++){
871  if(IS_DIRECT(h->sub_mb_type[i])) continue;
872  if(IS_DIR(h->sub_mb_type[i], 0, list)){
873  unsigned int tmp;
874  if(ref_count == 1){
875  tmp= 0;
876  }else if(ref_count == 2){
877  tmp= get_bits1(&h->gb)^1;
878  }else{
879  tmp= get_ue_golomb_31(&h->gb);
880  if(tmp>=ref_count){
881  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
882  return -1;
883  }
884  }
885  ref[list][i]= tmp;
886  }else{
887  //FIXME
888  ref[list][i] = -1;
889  }
890  }
891  }
892 
893  if(dct8x8_allowed)
894  dct8x8_allowed = get_dct8x8_allowed(h);
895 
896  for(list=0; list<h->list_count; list++){
897  for(i=0; i<4; i++){
898  if(IS_DIRECT(h->sub_mb_type[i])) {
899  h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
900  continue;
901  }
902  h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
903  h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
904 
905  if(IS_DIR(h->sub_mb_type[i], 0, list)){
906  const int sub_mb_type= h->sub_mb_type[i];
907  const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
908  for(j=0; j<sub_partition_count[i]; j++){
909  int mx, my;
910  const int index= 4*i + block_width*j;
911  int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
912  pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
913  mx += get_se_golomb(&h->gb);
914  my += get_se_golomb(&h->gb);
915  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
916 
917  if(IS_SUB_8X8(sub_mb_type)){
918  mv_cache[ 1 ][0]=
919  mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
920  mv_cache[ 1 ][1]=
921  mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
922  }else if(IS_SUB_8X4(sub_mb_type)){
923  mv_cache[ 1 ][0]= mx;
924  mv_cache[ 1 ][1]= my;
925  }else if(IS_SUB_4X8(sub_mb_type)){
926  mv_cache[ 8 ][0]= mx;
927  mv_cache[ 8 ][1]= my;
928  }
929  mv_cache[ 0 ][0]= mx;
930  mv_cache[ 0 ][1]= my;
931  }
932  }else{
933  uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
934  p[0] = p[1]=
935  p[8] = p[9]= 0;
936  }
937  }
938  }
939  }else if(IS_DIRECT(mb_type)){
940  ff_h264_pred_direct_motion(h, &mb_type);
941  dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
942  }else{
943  int list, mx, my, i;
944  //FIXME we should set ref_idx_l? to 0 if we use that later ...
945  if(IS_16X16(mb_type)){
946  for(list=0; list<h->list_count; list++){
947  unsigned int val;
948  if(IS_DIR(mb_type, 0, list)){
949  if(local_ref_count[list]==1){
950  val= 0;
951  }else if(local_ref_count[list]==2){
952  val= get_bits1(&h->gb)^1;
953  }else{
954  val= get_ue_golomb_31(&h->gb);
955  if(val >= local_ref_count[list]){
956  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
957  return -1;
958  }
959  }
960  fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
961  }
962  }
963  for(list=0; list<h->list_count; list++){
964  if(IS_DIR(mb_type, 0, list)){
965  pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
966  mx += get_se_golomb(&h->gb);
967  my += get_se_golomb(&h->gb);
968  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
969 
970  fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
971  }
972  }
973  }
974  else if(IS_16X8(mb_type)){
975  for(list=0; list<h->list_count; list++){
976  for(i=0; i<2; i++){
977  unsigned int val;
978  if(IS_DIR(mb_type, i, list)){
979  if(local_ref_count[list] == 1){
980  val= 0;
981  }else if(local_ref_count[list] == 2){
982  val= get_bits1(&h->gb)^1;
983  }else{
984  val= get_ue_golomb_31(&h->gb);
985  if(val >= local_ref_count[list]){
986  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
987  return -1;
988  }
989  }
990  }else
991  val= LIST_NOT_USED&0xFF;
992  fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
993  }
994  }
995  for(list=0; list<h->list_count; list++){
996  for(i=0; i<2; i++){
997  unsigned int val;
998  if(IS_DIR(mb_type, i, list)){
999  pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1000  mx += get_se_golomb(&h->gb);
1001  my += get_se_golomb(&h->gb);
1002  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1003 
1004  val= pack16to32(mx,my);
1005  }else
1006  val=0;
1007  fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1008  }
1009  }
1010  }else{
1011  av_assert2(IS_8X16(mb_type));
1012  for(list=0; list<h->list_count; list++){
1013  for(i=0; i<2; i++){
1014  unsigned int val;
1015  if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1016  if(local_ref_count[list]==1){
1017  val= 0;
1018  }else if(local_ref_count[list]==2){
1019  val= get_bits1(&h->gb)^1;
1020  }else{
1021  val= get_ue_golomb_31(&h->gb);
1022  if(val >= local_ref_count[list]){
1023  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1024  return -1;
1025  }
1026  }
1027  }else
1028  val= LIST_NOT_USED&0xFF;
1029  fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1030  }
1031  }
1032  for(list=0; list<h->list_count; list++){
1033  for(i=0; i<2; i++){
1034  unsigned int val;
1035  if(IS_DIR(mb_type, i, list)){
1036  pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1037  mx += get_se_golomb(&h->gb);
1038  my += get_se_golomb(&h->gb);
1039  tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1040 
1041  val= pack16to32(mx,my);
1042  }else
1043  val=0;
1044  fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1045  }
1046  }
1047  }
1048  }
1049 
1050  if(IS_INTER(mb_type))
1051  write_back_motion(h, mb_type);
1052 
1053  if(!IS_INTRA16x16(mb_type)){
1054  cbp= get_ue_golomb(&h->gb);
1055 
1056  if(decode_chroma){
1057  if(cbp > 47){
1058  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
1059  return -1;
1060  }
1061  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
1062  else cbp= golomb_to_inter_cbp [cbp];
1063  }else{
1064  if(cbp > 15){
1065  av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
1066  return -1;
1067  }
1068  if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1069  else cbp= golomb_to_inter_cbp_gray[cbp];
1070  }
1071  } else {
1072  if (!decode_chroma && cbp>15) {
1073  av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1074  return AVERROR_INVALIDDATA;
1075  }
1076  }
1077 
1078  if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1079  mb_type |= MB_TYPE_8x8DCT*get_bits1(&h->gb);
1080  }
1081  h->cbp=
1082  h->cbp_table[mb_xy]= cbp;
1083  h->cur_pic.mb_type[mb_xy] = mb_type;
1084 
1085  if(cbp || IS_INTRA16x16(mb_type)){
1086  int i4x4, i8x8, chroma_idx;
1087  int dquant;
1088  int ret;
1089  GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
1090  const uint8_t *scan, *scan8x8;
1091  const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1092 
1093  if(IS_INTERLACED(mb_type)){
1094  scan8x8= h->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1095  scan= h->qscale ? h->field_scan : h->field_scan_q0;
1096  }else{
1097  scan8x8= h->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1098  scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1099  }
1100 
1101  dquant= get_se_golomb(&h->gb);
1102 
1103  h->qscale += dquant;
1104 
1105  if(((unsigned)h->qscale) > max_qp){
1106  if(h->qscale<0) h->qscale+= max_qp+1;
1107  else h->qscale-= max_qp+1;
1108  if(((unsigned)h->qscale) > max_qp){
1109  av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, h->mb_x, h->mb_y);
1110  return -1;
1111  }
1112  }
1113 
1114  h->chroma_qp[0]= get_chroma_qp(h, 0, h->qscale);
1115  h->chroma_qp[1]= get_chroma_qp(h, 1, h->qscale);
1116 
1117  if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
1118  return -1;
1119  }
1120  h->cbp_table[mb_xy] |= ret << 12;
1121  if (CHROMA444(h)) {
1122  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
1123  return -1;
1124  }
1125  if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
1126  return -1;
1127  }
1128  } else {
1129  const int num_c8x8 = h->sps.chroma_format_idc;
1130 
1131  if(cbp&0x30){
1132  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1133  if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1134  CHROMA_DC_BLOCK_INDEX+chroma_idx,
1136  NULL, 4*num_c8x8) < 0) {
1137  return -1;
1138  }
1139  }
1140 
1141  if(cbp&0x20){
1142  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1143  const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1144  int16_t *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1145  for (i8x8=0; i8x8<num_c8x8; i8x8++) {
1146  for (i4x4=0; i4x4<4; i4x4++) {
1147  const int index= 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1148  if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
1149  return -1;
1150  mb += 16<<pixel_shift;
1151  }
1152  }
1153  }
1154  }else{
1155  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1156  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1157  }
1158  }
1159  }else{
1160  fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1161  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1162  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1163  }
1164  h->cur_pic.qscale_table[mb_xy] = h->qscale;
1166 
1167  return 0;
1168 }