cosmetics: Drop particularly redundant silly comments
[libav.git] / libavcodec / h264_cavlc.c
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 Libav.
6 *
7 * Libav 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 * Libav 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 Libav; 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
30 #include "internal.h"
31 #include "avcodec.h"
32 #include "h264.h"
33 #include "h264data.h" // FIXME FIXME FIXME
34 #include "h264_mvpred.h"
35 #include "golomb.h"
36 #include "mpegutils.h"
37
38 #include <assert.h>
39
40 static const uint8_t golomb_to_inter_cbp_gray[16]={
41 0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
42 };
43
44 static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
45 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
46 };
47
48 static const uint8_t chroma_dc_coeff_token_len[4*5]={
49 2, 0, 0, 0,
50 6, 1, 0, 0,
51 6, 6, 3, 0,
52 6, 7, 7, 6,
53 6, 8, 8, 7,
54 };
55
56 static const uint8_t chroma_dc_coeff_token_bits[4*5]={
57 1, 0, 0, 0,
58 7, 1, 0, 0,
59 4, 6, 1, 0,
60 3, 3, 2, 5,
61 2, 3, 2, 0,
62 };
63
64 static const uint8_t chroma422_dc_coeff_token_len[4*9]={
65 1, 0, 0, 0,
66 7, 2, 0, 0,
67 7, 7, 3, 0,
68 9, 7, 7, 5,
69 9, 9, 7, 6,
70 10, 10, 9, 7,
71 11, 11, 10, 7,
72 12, 12, 11, 10,
73 13, 12, 12, 11,
74 };
75
76 static const uint8_t chroma422_dc_coeff_token_bits[4*9]={
77 1, 0, 0, 0,
78 15, 1, 0, 0,
79 14, 13, 1, 0,
80 7, 12, 11, 1,
81 6, 5, 10, 1,
82 7, 6, 4, 9,
83 7, 6, 5, 8,
84 7, 6, 5, 4,
85 7, 5, 4, 4,
86 };
87
88 static const uint8_t coeff_token_len[4][4*17]={
89 {
90 1, 0, 0, 0,
91 6, 2, 0, 0, 8, 6, 3, 0, 9, 8, 7, 5, 10, 9, 8, 6,
92 11,10, 9, 7, 13,11,10, 8, 13,13,11, 9, 13,13,13,10,
93 14,14,13,11, 14,14,14,13, 15,15,14,14, 15,15,15,14,
94 16,15,15,15, 16,16,16,15, 16,16,16,16, 16,16,16,16,
95 },
96 {
97 2, 0, 0, 0,
98 6, 2, 0, 0, 6, 5, 3, 0, 7, 6, 6, 4, 8, 6, 6, 4,
99 8, 7, 7, 5, 9, 8, 8, 6, 11, 9, 9, 6, 11,11,11, 7,
100 12,11,11, 9, 12,12,12,11, 12,12,12,11, 13,13,13,12,
101 13,13,13,13, 13,14,13,13, 14,14,14,13, 14,14,14,14,
102 },
103 {
104 4, 0, 0, 0,
105 6, 4, 0, 0, 6, 5, 4, 0, 6, 5, 5, 4, 7, 5, 5, 4,
106 7, 5, 5, 4, 7, 6, 6, 4, 7, 6, 6, 4, 8, 7, 7, 5,
107 8, 8, 7, 6, 9, 8, 8, 7, 9, 9, 8, 8, 9, 9, 9, 8,
108 10, 9, 9, 9, 10,10,10,10, 10,10,10,10, 10,10,10,10,
109 },
110 {
111 6, 0, 0, 0,
112 6, 6, 0, 0, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6,
113 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
114 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
115 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
116 }
117 };
118
119 static const uint8_t coeff_token_bits[4][4*17]={
120 {
121 1, 0, 0, 0,
122 5, 1, 0, 0, 7, 4, 1, 0, 7, 6, 5, 3, 7, 6, 5, 3,
123 7, 6, 5, 4, 15, 6, 5, 4, 11,14, 5, 4, 8,10,13, 4,
124 15,14, 9, 4, 11,10,13,12, 15,14, 9,12, 11,10,13, 8,
125 15, 1, 9,12, 11,14,13, 8, 7,10, 9,12, 4, 6, 5, 8,
126 },
127 {
128 3, 0, 0, 0,
129 11, 2, 0, 0, 7, 7, 3, 0, 7,10, 9, 5, 7, 6, 5, 4,
130 4, 6, 5, 6, 7, 6, 5, 8, 15, 6, 5, 4, 11,14,13, 4,
131 15,10, 9, 4, 11,14,13,12, 8,10, 9, 8, 15,14,13,12,
132 11,10, 9,12, 7,11, 6, 8, 9, 8,10, 1, 7, 6, 5, 4,
133 },
134 {
135 15, 0, 0, 0,
136 15,14, 0, 0, 11,15,13, 0, 8,12,14,12, 15,10,11,11,
137 11, 8, 9,10, 9,14,13, 9, 8,10, 9, 8, 15,14,13,13,
138 11,14,10,12, 15,10,13,12, 11,14, 9,12, 8,10,13, 8,
139 13, 7, 9,12, 9,12,11,10, 5, 8, 7, 6, 1, 4, 3, 2,
140 },
141 {
142 3, 0, 0, 0,
143 0, 1, 0, 0, 4, 5, 6, 0, 8, 9,10,11, 12,13,14,15,
144 16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31,
145 32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47,
146 48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63,
147 }
148 };
149
150 static const uint8_t total_zeros_len[16][16]= {
151 {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
152 {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
153 {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
154 {5,3,4,4,3,3,3,4,3,4,5,5,5},
155 {4,4,4,3,3,3,3,3,4,5,4,5},
156 {6,5,3,3,3,3,3,3,4,3,6},
157 {6,5,3,3,3,2,3,4,3,6},
158 {6,4,5,3,2,2,3,3,6},
159 {6,6,4,2,2,3,2,5},
160 {5,5,3,2,2,2,4},
161 {4,4,3,3,1,3},
162 {4,4,2,1,3},
163 {3,3,1,2},
164 {2,2,1},
165 {1,1},
166 };
167
168 static const uint8_t total_zeros_bits[16][16]= {
169 {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
170 {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
171 {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
172 {3,7,5,4,6,5,4,3,3,2,2,1,0},
173 {5,4,3,7,6,5,4,3,2,1,1,0},
174 {1,1,7,6,5,4,3,2,1,1,0},
175 {1,1,5,4,3,3,2,1,1,0},
176 {1,1,1,3,3,2,2,1,0},
177 {1,0,1,3,2,1,1,1},
178 {1,0,1,3,2,1,1},
179 {0,1,1,2,1,3},
180 {0,1,1,1,1},
181 {0,1,1,1},
182 {0,1,1},
183 {0,1},
184 };
185
186 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
187 { 1, 2, 3, 3,},
188 { 1, 2, 2, 0,},
189 { 1, 1, 0, 0,},
190 };
191
192 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
193 { 1, 1, 1, 0,},
194 { 1, 1, 0, 0,},
195 { 1, 0, 0, 0,},
196 };
197
198 static const uint8_t chroma422_dc_total_zeros_len[7][8]= {
199 { 1, 3, 3, 4, 4, 4, 5, 5 },
200 { 3, 2, 3, 3, 3, 3, 3 },
201 { 3, 3, 2, 2, 3, 3 },
202 { 3, 2, 2, 2, 3 },
203 { 2, 2, 2, 2 },
204 { 2, 2, 1 },
205 { 1, 1 },
206 };
207
208 static const uint8_t chroma422_dc_total_zeros_bits[7][8]= {
209 { 1, 2, 3, 2, 3, 1, 1, 0 },
210 { 0, 1, 1, 4, 5, 6, 7 },
211 { 0, 1, 1, 2, 6, 7 },
212 { 6, 0, 1, 2, 7 },
213 { 0, 1, 2, 3 },
214 { 0, 1, 1 },
215 { 0, 1 },
216 };
217
218 static const uint8_t run_len[7][16]={
219 {1,1},
220 {1,2,2},
221 {2,2,2,2},
222 {2,2,2,3,3},
223 {2,2,3,3,3,3},
224 {2,3,3,3,3,3,3},
225 {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
226 };
227
228 static const uint8_t run_bits[7][16]={
229 {1,0},
230 {1,1,0},
231 {3,2,1,0},
232 {3,2,1,1,0},
233 {3,2,3,2,1,0},
234 {3,0,1,3,2,5,4},
235 {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
236 };
237
238 static VLC coeff_token_vlc[4];
239 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
240 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
241
242 static VLC chroma_dc_coeff_token_vlc;
243 static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
244 static const int chroma_dc_coeff_token_vlc_table_size = 256;
245
246 static VLC chroma422_dc_coeff_token_vlc;
247 static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
248 static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
249
250 static VLC total_zeros_vlc[15];
251 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
252 static const int total_zeros_vlc_tables_size = 512;
253
254 static VLC chroma_dc_total_zeros_vlc[3];
255 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
256 static const int chroma_dc_total_zeros_vlc_tables_size = 8;
257
258 static VLC chroma422_dc_total_zeros_vlc[7];
259 static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
260 static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
261
262 static VLC run_vlc[6];
263 static VLC_TYPE run_vlc_tables[6][8][2];
264 static const int run_vlc_tables_size = 8;
265
266 static VLC run7_vlc;
267 static VLC_TYPE run7_vlc_table[96][2];
268 static const int run7_vlc_table_size = 96;
269
270 #define LEVEL_TAB_BITS 8
271 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
272
273 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
274 #define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
275 #define COEFF_TOKEN_VLC_BITS 8
276 #define TOTAL_ZEROS_VLC_BITS 9
277 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
278 #define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
279 #define RUN_VLC_BITS 3
280 #define RUN7_VLC_BITS 6
281
282 /**
283 * Get the predicted number of non-zero coefficients.
284 * @param n block index
285 */
286 static inline int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
287 {
288 const int index8= scan8[n];
289 const int left = sl->non_zero_count_cache[index8 - 1];
290 const int top = sl->non_zero_count_cache[index8 - 8];
291 int i= left + top;
292
293 if(i<64) i= (i+1)>>1;
294
295 ff_tlog(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
326 av_cold void ff_h264_decode_init_vlc(void){
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,
339 INIT_VLC_USE_NEW_STATIC);
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,
345 &chroma422_dc_coeff_token_bits[0], 1, 1,
346 INIT_VLC_USE_NEW_STATIC);
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,
355 INIT_VLC_USE_NEW_STATIC);
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 */
363 assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
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],
369 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
370 &chroma_dc_total_zeros_len [i][0], 1, 1,
371 &chroma_dc_total_zeros_bits[i][0], 1, 1,
372 INIT_VLC_USE_NEW_STATIC);
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],
379 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
380 &chroma422_dc_total_zeros_len [i][0], 1, 1,
381 &chroma422_dc_total_zeros_bits[i][0], 1, 1,
382 INIT_VLC_USE_NEW_STATIC);
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],
389 TOTAL_ZEROS_VLC_BITS, 16,
390 &total_zeros_len [i][0], 1, 1,
391 &total_zeros_bits[i][0], 1, 1,
392 INIT_VLC_USE_NEW_STATIC);
393 }
394
395 for(i=0; i<6; i++){
396 run_vlc[i].table = run_vlc_tables[i];
397 run_vlc[i].table_allocated = run_vlc_tables_size;
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,
402 INIT_VLC_USE_NEW_STATIC);
403 }
404 run7_vlc.table = run7_vlc_table,
405 run7_vlc.table_allocated = run7_vlc_table_size;
406 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
407 &run_len [6][0], 1, 1,
408 &run_bits[6][0], 1, 1,
409 INIT_VLC_USE_NEW_STATIC);
410
411 init_cavlc_level_tab();
412 }
413 }
414
415 static inline int get_level_prefix(GetBitContext *gb){
416 unsigned int buf;
417 int log;
418
419 OPEN_READER(re, gb);
420 UPDATE_CACHE(re, gb);
421 buf=GET_CACHE(re, gb);
422
423 log= 32 - av_log2(buf);
424 #ifdef TRACE
425 print_bin(buf>>(32-log), log);
426 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__);
427 #endif
428
429 LAST_SKIP_BITS(re, gb, log);
430 CLOSE_READER(re, gb);
431
432 return log-1;
433 }
434
435 /**
436 * Decode a residual block.
437 * @param n block index
438 * @param scantable scantable
439 * @param max_coeff number of coefficients in the block
440 * @return <0 if an error occurred
441 */
442 static int decode_residual(const H264Context *h, H264SliceContext *sl,
443 GetBitContext *gb, int16_t *block, int n,
444 const uint8_t *scantable, const uint32_t *qmul,
445 int max_coeff)
446 {
447 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};
448 int level[16];
449 int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
450
451 //FIXME put trailing_onex into the context
452
453 if(max_coeff <= 8){
454 if (max_coeff == 4)
455 coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
456 else
457 coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
458 total_coeff= coeff_token>>2;
459 }else{
460 if(n >= LUMA_DC_BLOCK_INDEX){
461 total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
462 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
463 total_coeff= coeff_token>>2;
464 }else{
465 total_coeff= pred_non_zero_count(h, sl, n);
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 }
469 }
470 sl->non_zero_count_cache[scan8[n]] = total_coeff;
471
472 //FIXME set last_non_zero?
473
474 if(total_coeff==0)
475 return 0;
476 if(total_coeff > (unsigned)max_coeff) {
477 av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
478 return -1;
479 }
480
481 trailing_ones= coeff_token&3;
482 ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
483 assert(total_coeff<=16);
484
485 i = show_bits(gb, 3);
486 skip_bits(gb, trailing_ones);
487 level[0] = 1-((i&4)>>1);
488 level[1] = 1-((i&2) );
489 level[2] = 1-((i&1)<<1);
490
491 if(trailing_ones<total_coeff) {
492 int mask, prefix;
493 int suffix_length = total_coeff > 10 & trailing_ones < 3;
494 int bitsi= show_bits(gb, LEVEL_TAB_BITS);
495 int level_code= cavlc_level_tab[suffix_length][bitsi][0];
496
497 skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
498 if(level_code >= 100){
499 prefix= level_code - 100;
500 if(prefix == LEVEL_TAB_BITS)
501 prefix += get_level_prefix(gb);
502
503 //first coefficient has suffix_length equal to 0 or 1
504 if(prefix<14){ //FIXME try to build a large unified VLC table for all this
505 if(suffix_length)
506 level_code= (prefix<<1) + get_bits1(gb); //part
507 else
508 level_code= prefix; //part
509 }else if(prefix==14){
510 if(suffix_length)
511 level_code= (prefix<<1) + get_bits1(gb); //part
512 else
513 level_code= prefix + get_bits(gb, 4); //part
514 }else{
515 level_code= 30 + get_bits(gb, prefix-3); //part
516 if(prefix>=16){
517 if(prefix > 25+3){
518 av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
519 return -1;
520 }
521 level_code += (1<<(prefix-3))-4096;
522 }
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) + get_bits(gb, prefix-3);
553 if(prefix>=16)
554 level_code += (1<<(prefix-3))-4096;
555 }
556 mask= -(level_code&1);
557 level_code= (((2+level_code)>>1) ^ mask) - mask;
558 }
559 level[i]= level_code;
560 suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
561 }
562 }
563
564 if(total_coeff == max_coeff)
565 zeros_left=0;
566 else{
567 if (max_coeff <= 8) {
568 if (max_coeff == 4)
569 zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff - 1].table,
570 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
571 else
572 zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
573 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
574 } else {
575 zeros_left= get_vlc2(gb, total_zeros_vlc[total_coeff - 1].table, TOTAL_ZEROS_VLC_BITS, 1);
576 }
577 }
578
579 #define STORE_BLOCK(type) \
580 scantable += zeros_left + total_coeff - 1; \
581 if(n >= LUMA_DC_BLOCK_INDEX){ \
582 ((type*)block)[*scantable] = level[0]; \
583 for(i=1;i<total_coeff && zeros_left > 0;i++) { \
584 if(zeros_left < 7) \
585 run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
586 else \
587 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
588 zeros_left -= run_before; \
589 scantable -= 1 + run_before; \
590 ((type*)block)[*scantable]= level[i]; \
591 } \
592 for(;i<total_coeff;i++) { \
593 scantable--; \
594 ((type*)block)[*scantable]= level[i]; \
595 } \
596 }else{ \
597 ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
598 for(i=1;i<total_coeff && zeros_left > 0;i++) { \
599 if(zeros_left < 7) \
600 run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
601 else \
602 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
603 zeros_left -= run_before; \
604 scantable -= 1 + run_before; \
605 ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
606 } \
607 for(;i<total_coeff;i++) { \
608 scantable--; \
609 ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
610 } \
611 }
612
613 if (zeros_left < 0) {
614 av_log(h->avctx, AV_LOG_ERROR,
615 "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
616 return AVERROR_INVALIDDATA;
617 }
618
619 if (h->pixel_shift) {
620 STORE_BLOCK(int32_t)
621 } else {
622 STORE_BLOCK(int16_t)
623 }
624
625 return 0;
626 }
627
628 static av_always_inline
629 int decode_luma_residual(const H264Context *h, H264SliceContext *sl,
630 GetBitContext *gb, const uint8_t *scan,
631 const uint8_t *scan8x8, int pixel_shift,
632 int mb_type, int cbp, int p)
633 {
634 int i4x4, i8x8;
635 int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
636 if(IS_INTRA16x16(mb_type)){
637 AV_ZERO128(sl->mb_luma_dc[p]+0);
638 AV_ZERO128(sl->mb_luma_dc[p]+8);
639 AV_ZERO128(sl->mb_luma_dc[p]+16);
640 AV_ZERO128(sl->mb_luma_dc[p]+24);
641 if (decode_residual(h, sl, gb, sl->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 assert((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, sl, gb, sl->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(&sl->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 = &sl->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, sl, gb, buf, index, scan8x8+16*i4x4,
674 h->dequant8_coeff[cqm][qscale], 16) < 0 )
675 return -1;
676 }
677 nnz = &sl->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, sl, gb, sl->mb + (16*index << pixel_shift), index,
684 scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
685 return -1;
686 }
687 new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
688 }
689 }
690 }else{
691 uint8_t * const nnz = &sl->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
699 int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
700 {
701 int mb_xy;
702 int partition_count;
703 unsigned int mb_type, cbp;
704 int dct8x8_allowed= h->pps.transform_8x8_mode;
705 int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
706 const int pixel_shift = h->pixel_shift;
707
708 mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
709
710 ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, sl->mb_x, sl->mb_y);
711 cbp = 0; /* avoid warning. FIXME: find a solution without slowing
712 down the code */
713 if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
714 if (sl->mb_skip_run == -1)
715 sl->mb_skip_run = get_ue_golomb(&sl->gb);
716
717 if (sl->mb_skip_run--) {
718 if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
719 if (sl->mb_skip_run == 0)
720 sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
721 }
722 decode_mb_skip(h, sl);
723 return 0;
724 }
725 }
726 if (FRAME_MBAFF(h)) {
727 if ((sl->mb_y & 1) == 0)
728 sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
729 }
730
731 sl->prev_mb_skipped = 0;
732
733 mb_type= get_ue_golomb(&sl->gb);
734 if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
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 (sl->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{
751 assert(sl->slice_type_nos == AV_PICTURE_TYPE_I);
752 if (sl->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(sl->slice_type), sl->mb_x, sl->mb_y);
757 return -1;
758 }
759 partition_count=0;
760 cbp= i_mb_type_info[mb_type].cbp;
761 sl->intra16x16_pred_mode = i_mb_type_info[mb_type].pred_mode;
762 mb_type= i_mb_type_info[mb_type].type;
763 }
764
765 if (MB_FIELD(sl))
766 mb_type |= MB_TYPE_INTERLACED;
767
768 h->slice_table[mb_xy] = sl->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 sl->intra_pcm_ptr = align_get_bits(&sl->gb);
776 if (get_bits_left(&sl->gb) < mb_size) {
777 av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
778 return AVERROR_INVALIDDATA;
779 }
780 skip_bits_long(&sl->gb, mb_size);
781
782 // In deblocking, the quantizer is 0
783 h->cur_pic.qscale_table[mb_xy] = 0;
784 // All coeffs are present
785 memset(h->non_zero_count[mb_xy], 16, 48);
786
787 h->cur_pic.mb_type[mb_xy] = mb_type;
788 return 0;
789 }
790
791 fill_decode_neighbors(h, sl, mb_type);
792 fill_decode_caches(h, sl, mb_type);
793
794 //mb_pred
795 if(IS_INTRA(mb_type)){
796 int pred_mode;
797 // init_top_left_availability(h);
798 if(IS_INTRA4x4(mb_type)){
799 int i;
800 int di = 1;
801 if(dct8x8_allowed && get_bits1(&sl->gb)){
802 mb_type |= MB_TYPE_8x8DCT;
803 di = 4;
804 }
805
806 // fill_intra4x4_pred_table(h);
807 for(i=0; i<16; i+=di){
808 int mode = pred_intra_mode(h, sl, i);
809
810 if(!get_bits1(&sl->gb)){
811 const int rem_mode= get_bits(&sl->gb, 3);
812 mode = rem_mode + (rem_mode >= mode);
813 }
814
815 if(di==4)
816 fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
817 else
818 sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
819 }
820 write_back_intra_pred_mode(h, sl);
821 if (ff_h264_check_intra4x4_pred_mode(h, sl) < 0)
822 return -1;
823 }else{
824 sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, sl->intra16x16_pred_mode, 0);
825 if (sl->intra16x16_pred_mode < 0)
826 return -1;
827 }
828 if(decode_chroma){
829 pred_mode= ff_h264_check_intra_pred_mode(h, sl, get_ue_golomb_31(&sl->gb), 1);
830 if(pred_mode < 0)
831 return -1;
832 sl->chroma_pred_mode = pred_mode;
833 } else {
834 sl->chroma_pred_mode = DC_128_PRED8x8;
835 }
836 }else if(partition_count==4){
837 int i, j, sub_partition_count[4], list, ref[2][4];
838
839 if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
840 for(i=0; i<4; i++){
841 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
842 if(sl->sub_mb_type[i] >=13){
843 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);
844 return -1;
845 }
846 sub_partition_count[i]= b_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
847 sl->sub_mb_type[i]= b_sub_mb_type_info[ sl->sub_mb_type[i] ].type;
848 }
849 if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
850 ff_h264_pred_direct_motion(h, sl, &mb_type);
851 sl->ref_cache[0][scan8[4]] =
852 sl->ref_cache[1][scan8[4]] =
853 sl->ref_cache[0][scan8[12]] =
854 sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
855 }
856 }else{
857 assert(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
858 for(i=0; i<4; i++){
859 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
860 if(sl->sub_mb_type[i] >=4){
861 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);
862 return -1;
863 }
864 sub_partition_count[i]= p_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
865 sl->sub_mb_type[i]= p_sub_mb_type_info[ sl->sub_mb_type[i] ].type;
866 }
867 }
868
869 for (list = 0; list < sl->list_count; list++) {
870 int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
871 for(i=0; i<4; i++){
872 if(IS_DIRECT(sl->sub_mb_type[i])) continue;
873 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
874 unsigned int tmp;
875 if(ref_count == 1){
876 tmp= 0;
877 }else if(ref_count == 2){
878 tmp= get_bits1(&sl->gb)^1;
879 }else{
880 tmp= get_ue_golomb_31(&sl->gb);
881 if(tmp>=ref_count){
882 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
883 return -1;
884 }
885 }
886 ref[list][i]= tmp;
887 }else{
888 //FIXME
889 ref[list][i] = -1;
890 }
891 }
892 }
893
894 if(dct8x8_allowed)
895 dct8x8_allowed = get_dct8x8_allowed(h, sl);
896
897 for (list = 0; list < sl->list_count; list++) {
898 for(i=0; i<4; i++){
899 if(IS_DIRECT(sl->sub_mb_type[i])) {
900 sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
901 continue;
902 }
903 sl->ref_cache[list][ scan8[4*i] ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
904 sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
905
906 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
907 const int sub_mb_type= sl->sub_mb_type[i];
908 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
909 for(j=0; j<sub_partition_count[i]; j++){
910 int mx, my;
911 const int index= 4*i + block_width*j;
912 int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
913 pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
914 mx += get_se_golomb(&sl->gb);
915 my += get_se_golomb(&sl->gb);
916 ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
917
918 if(IS_SUB_8X8(sub_mb_type)){
919 mv_cache[ 1 ][0]=
920 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
921 mv_cache[ 1 ][1]=
922 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
923 }else if(IS_SUB_8X4(sub_mb_type)){
924 mv_cache[ 1 ][0]= mx;
925 mv_cache[ 1 ][1]= my;
926 }else if(IS_SUB_4X8(sub_mb_type)){
927 mv_cache[ 8 ][0]= mx;
928 mv_cache[ 8 ][1]= my;
929 }
930 mv_cache[ 0 ][0]= mx;
931 mv_cache[ 0 ][1]= my;
932 }
933 }else{
934 uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
935 p[0] = p[1]=
936 p[8] = p[9]= 0;
937 }
938 }
939 }
940 }else if(IS_DIRECT(mb_type)){
941 ff_h264_pred_direct_motion(h, sl, &mb_type);
942 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
943 }else{
944 int list, mx, my, i;
945 //FIXME we should set ref_idx_l? to 0 if we use that later ...
946 if(IS_16X16(mb_type)){
947 for (list = 0; list < sl->list_count; list++) {
948 unsigned int val;
949 if(IS_DIR(mb_type, 0, list)){
950 int rc = sl->ref_count[list] << MB_MBAFF(sl);
951 if (rc == 1) {
952 val= 0;
953 } else if (rc == 2) {
954 val= get_bits1(&sl->gb)^1;
955 }else{
956 val= get_ue_golomb_31(&sl->gb);
957 if (val >= rc) {
958 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
959 return -1;
960 }
961 }
962 fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
963 }
964 }
965 for (list = 0; list < sl->list_count; list++) {
966 if(IS_DIR(mb_type, 0, list)){
967 pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
968 mx += get_se_golomb(&sl->gb);
969 my += get_se_golomb(&sl->gb);
970 ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
971
972 fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
973 }
974 }
975 }
976 else if(IS_16X8(mb_type)){
977 for (list = 0; list < sl->list_count; list++) {
978 for(i=0; i<2; i++){
979 unsigned int val;
980 if(IS_DIR(mb_type, i, list)){
981 int rc = sl->ref_count[list] << MB_MBAFF(sl);
982 if (rc == 1) {
983 val= 0;
984 } else if (rc == 2) {
985 val= get_bits1(&sl->gb)^1;
986 }else{
987 val= get_ue_golomb_31(&sl->gb);
988 if (val >= rc) {
989 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
990 return -1;
991 }
992 }
993 }else
994 val= LIST_NOT_USED&0xFF;
995 fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
996 }
997 }
998 for (list = 0; list < sl->list_count; list++) {
999 for(i=0; i<2; i++){
1000 unsigned int val;
1001 if(IS_DIR(mb_type, i, list)){
1002 pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1003 mx += get_se_golomb(&sl->gb);
1004 my += get_se_golomb(&sl->gb);
1005 ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1006
1007 val= pack16to32(mx,my);
1008 }else
1009 val=0;
1010 fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1011 }
1012 }
1013 }else{
1014 assert(IS_8X16(mb_type));
1015 for (list = 0; list < sl->list_count; list++) {
1016 for(i=0; i<2; i++){
1017 unsigned int val;
1018 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1019 int rc = sl->ref_count[list] << MB_MBAFF(sl);
1020 if (rc == 1) {
1021 val= 0;
1022 } else if (rc == 2) {
1023 val= get_bits1(&sl->gb)^1;
1024 }else{
1025 val= get_ue_golomb_31(&sl->gb);
1026 if (val >= rc) {
1027 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1028 return -1;
1029 }
1030 }
1031 }else
1032 val= LIST_NOT_USED&0xFF;
1033 fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1034 }
1035 }
1036 for (list = 0; list < sl->list_count; list++) {
1037 for(i=0; i<2; i++){
1038 unsigned int val;
1039 if(IS_DIR(mb_type, i, list)){
1040 pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1041 mx += get_se_golomb(&sl->gb);
1042 my += get_se_golomb(&sl->gb);
1043 ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1044
1045 val= pack16to32(mx,my);
1046 }else
1047 val=0;
1048 fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1049 }
1050 }
1051 }
1052 }
1053
1054 if(IS_INTER(mb_type))
1055 write_back_motion(h, sl, mb_type);
1056
1057 if(!IS_INTRA16x16(mb_type)){
1058 cbp= get_ue_golomb(&sl->gb);
1059
1060 if(decode_chroma){
1061 if(cbp > 47){
1062 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1063 return -1;
1064 }
1065 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
1066 else cbp= golomb_to_inter_cbp [cbp];
1067 }else{
1068 if(cbp > 15){
1069 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1070 return -1;
1071 }
1072 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1073 else cbp= golomb_to_inter_cbp_gray[cbp];
1074 }
1075 }
1076
1077 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1078 mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1079 }
1080 sl->cbp=
1081 h->cbp_table[mb_xy]= cbp;
1082 h->cur_pic.mb_type[mb_xy] = mb_type;
1083
1084 if(cbp || IS_INTRA16x16(mb_type)){
1085 int i4x4, i8x8, chroma_idx;
1086 int dquant;
1087 int ret;
1088 GetBitContext *gb = &sl->gb;
1089 const uint8_t *scan, *scan8x8;
1090 const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1091
1092 if(IS_INTERLACED(mb_type)){
1093 scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1094 scan = sl->qscale ? h->field_scan : h->field_scan_q0;
1095 }else{
1096 scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1097 scan = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1098 }
1099
1100 dquant= get_se_golomb(&sl->gb);
1101
1102 sl->qscale += dquant;
1103
1104 if (((unsigned)sl->qscale) > max_qp){
1105 if (sl->qscale < 0) sl->qscale += max_qp + 1;
1106 else sl->qscale -= max_qp+1;
1107 if (((unsigned)sl->qscale) > max_qp){
1108 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1109 return -1;
1110 }
1111 }
1112
1113 sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
1114 sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
1115
1116 if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1117 return -1;
1118 }
1119 h->cbp_table[mb_xy] |= ret << 12;
1120 if (CHROMA444(h)) {
1121 if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1122 return -1;
1123 }
1124 if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1125 return -1;
1126 }
1127 } else if (CHROMA422(h)) {
1128 if(cbp&0x30){
1129 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1130 if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1131 CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma422_dc_scan,
1132 NULL, 8) < 0) {
1133 return -1;
1134 }
1135 }
1136
1137 if(cbp&0x20){
1138 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1139 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1140 int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1141 for (i8x8 = 0; i8x8 < 2; i8x8++) {
1142 for (i4x4 = 0; i4x4 < 4; i4x4++) {
1143 const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1144 if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1145 return -1;
1146 mb += 16 << pixel_shift;
1147 }
1148 }
1149 }
1150 }else{
1151 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1152 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1153 }
1154 } else /* yuv420 */ {
1155 if(cbp&0x30){
1156 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1157 if( decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift), CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma_dc_scan, NULL, 4) < 0){
1158 return -1;
1159 }
1160 }
1161
1162 if(cbp&0x20){
1163 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1164 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1165 for(i4x4=0; i4x4<4; i4x4++){
1166 const int index= 16 + 16*chroma_idx + i4x4;
1167 if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
1168 return -1;
1169 }
1170 }
1171 }
1172 }else{
1173 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1174 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1175 }
1176 }
1177 }else{
1178 fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1179 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1180 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1181 }
1182 h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1183 write_back_non_zero_count(h, sl);
1184
1185 return 0;
1186 }