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