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