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