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