repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.4.3~trusty1
[deb_ffmpeg.git] / ffmpeg / libavcodec / h264_cavlc.c
CommitLineData
2ba45a60
DM		 1/*
2 * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22/**
23 * @file
24 * H.264 / AVC / MPEG4 part10 cavlc bitstream decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
28#define CABAC(h) 0
29#define UNCHECKED_BITSTREAM_READER 1
30
31#include "internal.h"
32#include "avcodec.h"
33#include "h264.h"
34#include "h264data.h" // FIXME FIXME FIXME
35#include "h264_mvpred.h"
36#include "golomb.h"
37#include "mpegutils.h"
38#include "libavutil/avassert.h"
39
40
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 chroma422_dc_coeff_token_len[4*9]={
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
77static const uint8_t chroma422_dc_coeff_token_bits[4*9]={
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
89static 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
120static 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
151static 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
169static 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
187static 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
193static 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
199static const uint8_t chroma422_dc_total_zeros_len[7][8]= {
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
209static const uint8_t chroma422_dc_total_zeros_bits[7][8]= {
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
219static 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
229static 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
239static VLC coeff_token_vlc[4];
240static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
241static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
242
243static VLC chroma_dc_coeff_token_vlc;
244static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
245static const int chroma_dc_coeff_token_vlc_table_size = 256;
246
247static VLC chroma422_dc_coeff_token_vlc;
248static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
249static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
250
251static VLC total_zeros_vlc[15];
252static VLC_TYPE total_zeros_vlc_tables[15][512][2];
253static const int total_zeros_vlc_tables_size = 512;
254
255static VLC chroma_dc_total_zeros_vlc[3];
256static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
257static const int chroma_dc_total_zeros_vlc_tables_size = 8;
258
259static VLC chroma422_dc_total_zeros_vlc[7];
260static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
261static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
262
263static VLC run_vlc[6];
264static VLC_TYPE run_vlc_tables[6][8][2];
265static const int run_vlc_tables_size = 8;
266
267static VLC run7_vlc;
268static VLC_TYPE run7_vlc_table[96][2];
269static const int run7_vlc_table_size = 96;
270
271#define LEVEL_TAB_BITS 8
272static 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 */
287static 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
300static 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
326av_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 av_assert0(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/**
416 *
417 */
418static 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 */
445static 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,
576 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
577 else
578 zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
579 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
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) {
620 STORE_BLOCK(int32_t)
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
633static 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
699int ff_h264_decode_mb_cavlc(H264Context *h){
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 */
713 if(h->slice_type_nos != AV_PICTURE_TYPE_I){
714 if(h->mb_skip_run==-1)
715 h->mb_skip_run= get_ue_golomb_long(&h->gb);
716
717 if (h->mb_skip_run--) {
718 if(FRAME_MBAFF(h) && (h->mb_y&1) == 0){
719 if(h->mb_skip_run==0)
720 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&h->gb);
721 }
722 decode_mb_skip(h);
723 return 0;
724 }
725 }
726 if (FRAME_MBAFF(h)) {
727 if( (h->mb_y&1) == 0 )
728 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&h->gb);
729 }
730
731 h->prev_mb_skipped= 0;
732
733 mb_type= get_ue_golomb(&h->gb);
734 if(h->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(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{
751 av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_I);
752 if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
753 mb_type--;
754decode_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;
761 h->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(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 if (get_bits_left(&h->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(&h->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 local_ref_count[0] = h->ref_count[0] << MB_MBAFF(h);
792 local_ref_count[1] = h->ref_count[1] << MB_MBAFF(h);
793
794 fill_decode_neighbors(h, mb_type);
795 fill_decode_caches(h, mb_type);
796
797 //mb_pred
798 if(IS_INTRA(mb_type)){
799 int pred_mode;
800// init_top_left_availability(h);
801 if(IS_INTRA4x4(mb_type)){
802 int i;
803 int di = 1;
804 if(dct8x8_allowed && get_bits1(&h->gb)){
805 mb_type |= MB_TYPE_8x8DCT;
806 di = 4;
807 }
808
809// fill_intra4x4_pred_table(h);
810 for(i=0; i<16; i+=di){
811 int mode= pred_intra_mode(h, i);
812
813 if(!get_bits1(&h->gb)){
814 const int rem_mode= get_bits(&h->gb, 3);
815 mode = rem_mode + (rem_mode >= mode);
816 }
817
818 if(di==4)
819 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
820 else
821 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
822 }
823 write_back_intra_pred_mode(h);
824 if( ff_h264_check_intra4x4_pred_mode(h) < 0)
825 return -1;
826 }else{
827 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode, 0);
828 if(h->intra16x16_pred_mode < 0)
829 return -1;
830 }
831 if(decode_chroma){
832 pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&h->gb), 1);
833 if(pred_mode < 0)
834 return -1;
835 h->chroma_pred_mode= pred_mode;
836 } else {
837 h->chroma_pred_mode = DC_128_PRED8x8;
838 }
839 }else if(partition_count==4){
840 int i, j, sub_partition_count[4], list, ref[2][4];
841
842 if(h->slice_type_nos == AV_PICTURE_TYPE_B){
843 for(i=0; i<4; i++){
844 h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
845 if(h->sub_mb_type[i] >=13){
846 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);
847 return -1;
848 }
849 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
850 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
851 }
852 if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
853 ff_h264_pred_direct_motion(h, &mb_type);
854 h->ref_cache[0][scan8[4]] =
855 h->ref_cache[1][scan8[4]] =
856 h->ref_cache[0][scan8[12]] =
857 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
858 }
859 }else{
860 av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
861 for(i=0; i<4; i++){
862 h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
863 if(h->sub_mb_type[i] >=4){
864 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);
865 return -1;
866 }
867 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
868 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
869 }
870 }
871
872 for(list=0; list<h->list_count; list++){
873 int ref_count = IS_REF0(mb_type) ? 1 : local_ref_count[list];
874 for(i=0; i<4; i++){
875 if(IS_DIRECT(h->sub_mb_type[i])) continue;
876 if(IS_DIR(h->sub_mb_type[i], 0, list)){
877 unsigned int tmp;
878 if(ref_count == 1){
879 tmp= 0;
880 }else if(ref_count == 2){
881 tmp= get_bits1(&h->gb)^1;
882 }else{
883 tmp= get_ue_golomb_31(&h->gb);
884 if(tmp>=ref_count){
885 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
886 return -1;
887 }
888 }
889 ref[list][i]= tmp;
890 }else{
891 //FIXME
892 ref[list][i] = -1;
893 }
894 }
895 }
896
897 if(dct8x8_allowed)
898 dct8x8_allowed = get_dct8x8_allowed(h);
899
900 for(list=0; list<h->list_count; list++){
901 for(i=0; i<4; i++){
902 if(IS_DIRECT(h->sub_mb_type[i])) {
903 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
904 continue;
905 }
906 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
907 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
908
909 if(IS_DIR(h->sub_mb_type[i], 0, list)){
910 const int sub_mb_type= h->sub_mb_type[i];
911 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
912 for(j=0; j<sub_partition_count[i]; j++){
913 int mx, my;
914 const int index= 4*i + block_width*j;
915 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
916 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
917 mx += get_se_golomb(&h->gb);
918 my += get_se_golomb(&h->gb);
919 tprintf(h->avctx, "final mv:%d %d\n", mx, my);
920
921 if(IS_SUB_8X8(sub_mb_type)){
922 mv_cache[ 1 ][0]=
923 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
924 mv_cache[ 1 ][1]=
925 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
926 }else if(IS_SUB_8X4(sub_mb_type)){
927 mv_cache[ 1 ][0]= mx;
928 mv_cache[ 1 ][1]= my;
929 }else if(IS_SUB_4X8(sub_mb_type)){
930 mv_cache[ 8 ][0]= mx;
931 mv_cache[ 8 ][1]= my;
932 }
933 mv_cache[ 0 ][0]= mx;
934 mv_cache[ 0 ][1]= my;
935 }
936 }else{
937 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
938 p[0] = p[1]=
939 p[8] = p[9]= 0;
940 }
941 }
942 }
943 }else if(IS_DIRECT(mb_type)){
944 ff_h264_pred_direct_motion(h, &mb_type);
945 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
946 }else{
947 int list, mx, my, i;
948 //FIXME we should set ref_idx_l? to 0 if we use that later ...
949 if(IS_16X16(mb_type)){
950 for(list=0; list<h->list_count; list++){
951 unsigned int val;
952 if(IS_DIR(mb_type, 0, list)){
953 if(local_ref_count[list]==1){
954 val= 0;
955 } else if(local_ref_count[list]==2){
956 val= get_bits1(&h->gb)^1;
957 }else{
958 val= get_ue_golomb_31(&h->gb);
959 if (val >= local_ref_count[list]){
960 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
961 return -1;
962 }
963 }
964 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
965 }
966 }
967 for(list=0; list<h->list_count; list++){
968 if(IS_DIR(mb_type, 0, list)){
969 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
970 mx += get_se_golomb(&h->gb);
971 my += get_se_golomb(&h->gb);
972 tprintf(h->avctx, "final mv:%d %d\n", mx, my);
973
974 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
975 }
976 }
977 }
978 else if(IS_16X8(mb_type)){
979 for(list=0; list<h->list_count; list++){
980 for(i=0; i<2; i++){
981 unsigned int val;
982 if(IS_DIR(mb_type, i, list)){
983 if(local_ref_count[list] == 1) {
984 val= 0;
985 } else if(local_ref_count[list] == 2) {
986 val= get_bits1(&h->gb)^1;
987 }else{
988 val= get_ue_golomb_31(&h->gb);
989 if (val >= local_ref_count[list]){
990 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
991 return -1;
992 }
993 }
994 }else
995 val= LIST_NOT_USED&0xFF;
996 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
997 }
998 }
999 for(list=0; list<h->list_count; list++){
1000 for(i=0; i<2; i++){
1001 unsigned int val;
1002 if(IS_DIR(mb_type, i, list)){
1003 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1004 mx += get_se_golomb(&h->gb);
1005 my += get_se_golomb(&h->gb);
1006 tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1007
1008 val= pack16to32(mx,my);
1009 }else
1010 val=0;
1011 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1012 }
1013 }
1014 }else{
1015 av_assert2(IS_8X16(mb_type));
1016 for(list=0; list<h->list_count; list++){
1017 for(i=0; i<2; i++){
1018 unsigned int val;
1019 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1020 if(local_ref_count[list]==1){
1021 val= 0;
1022 } else if(local_ref_count[list]==2){
1023 val= get_bits1(&h->gb)^1;
1024 }else{
1025 val= get_ue_golomb_31(&h->gb);
1026 if (val >= local_ref_count[list]){
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(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1034 }
1035 }
1036 for(list=0; list<h->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, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1041 mx += get_se_golomb(&h->gb);
1042 my += get_se_golomb(&h->gb);
1043 tprintf(h->avctx, "final mv:%d %d\n", mx, my);
1044
1045 val= pack16to32(mx,my);
1046 }else
1047 val=0;
1048 fill_rectangle(h->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, mb_type);
1056
1057 if(!IS_INTRA16x16(mb_type)){
1058 cbp= get_ue_golomb(&h->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, h->mb_x, h->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, h->mb_x, h->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 } else {
1076 if (!decode_chroma && cbp>15) {
1077 av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1078 return AVERROR_INVALIDDATA;
1079 }
1080 }
1081
1082 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1083 mb_type |= MB_TYPE_8x8DCT*get_bits1(&h->gb);
1084 }
1085 h->cbp=
1086 h->cbp_table[mb_xy]= cbp;
1087 h->cur_pic.mb_type[mb_xy] = mb_type;
1088
1089 if(cbp || IS_INTRA16x16(mb_type)){
1090 int i4x4, i8x8, chroma_idx;
1091 int dquant;
1092 int ret;
1093 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
1094 const uint8_t *scan, *scan8x8;
1095 const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1096
1097 if(IS_INTERLACED(mb_type)){
1098 scan8x8= h->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1099 scan= h->qscale ? h->field_scan : h->field_scan_q0;
1100 }else{
1101 scan8x8= h->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1102 scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1103 }
1104
1105 dquant= get_se_golomb(&h->gb);
1106
1107 h->qscale += dquant;
1108
1109 if(((unsigned)h->qscale) > max_qp){
1110 if(h->qscale<0) h->qscale+= max_qp+1;
1111 else h->qscale-= max_qp+1;
1112 if(((unsigned)h->qscale) > max_qp){
1113 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, h->mb_x, h->mb_y);
1114 return -1;
1115 }
1116 }
1117
1118 h->chroma_qp[0]= get_chroma_qp(h, 0, h->qscale);
1119 h->chroma_qp[1]= get_chroma_qp(h, 1, h->qscale);
1120
1121 if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
1122 return -1;
1123 }
1124 h->cbp_table[mb_xy] |= ret << 12;
1125 if (CHROMA444(h)) {
1126 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
1127 return -1;
1128 }
1129 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
1130 return -1;
1131 }
1132 } else {
1133 const int num_c8x8 = h->sps.chroma_format_idc;
1134
1135 if(cbp&0x30){
1136 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1137 if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1138 CHROMA_DC_BLOCK_INDEX+chroma_idx,
1139 CHROMA422(h) ? chroma422_dc_scan : chroma_dc_scan,
1140 NULL, 4*num_c8x8) < 0) {
1141 return -1;
1142 }
1143 }
1144
1145 if(cbp&0x20){
1146 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1147 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1148 int16_t *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1149 for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1150 for (i4x4 = 0; i4x4 < 4; i4x4++) {
1151 const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1152 if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
1153 return -1;
1154 mb += 16 << pixel_shift;
1155 }
1156 }
1157 }
1158 }else{
1159 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1160 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1161 }
1162 }
1163 }else{
1164 fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1165 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1166 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1167 }
1168 h->cur_pic.qscale_table[mb_xy] = h->qscale;
1169 write_back_non_zero_count(h);
1170
1171 return 0;
1172}
ffmpeg Piment Noir Debian package repository