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