h264: move mb_field_decoding_flag into the per-slice context
[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 / MPEG4 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 "h264.h"
33 #include "h264data.h" // FIXME FIXME FIXME
34 #include "h264_mvpred.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(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     tprintf(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
296
297     return i&31;
298 }
299
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 /**
416  *
417  */
418 static inline int get_level_prefix(GetBitContext *gb){
419     unsigned int buf;
420     int log;
421
422     OPEN_READER(re, gb);
423     UPDATE_CACHE(re, gb);
424     buf=GET_CACHE(re, gb);
425
426     log= 32 - av_log2(buf);
427 #ifdef TRACE
428     print_bin(buf>>(32-log), log);
429     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
430 #endif
431
432     LAST_SKIP_BITS(re, gb, log);
433     CLOSE_READER(re, gb);
434
435     return log-1;
436 }
437
438 /**
439  * Decode a residual block.
440  * @param n block index
441  * @param scantable scantable
442  * @param max_coeff number of coefficients in the block
443  * @return <0 if an error occurred
444  */
445 static int decode_residual(H264Context *h, H264SliceContext *sl,
446                            GetBitContext *gb, int16_t *block, int n,
447                            const uint8_t *scantable, const uint32_t *qmul,
448                            int max_coeff)
449 {
450     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};
451     int level[16];
452     int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
453
454     //FIXME put trailing_onex into the context
455
456     if(max_coeff <= 8){
457         if (max_coeff == 4)
458             coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
459         else
460             coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
461         total_coeff= coeff_token>>2;
462     }else{
463         if(n >= LUMA_DC_BLOCK_INDEX){
464             total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
465             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
466             total_coeff= coeff_token>>2;
467         }else{
468             total_coeff= pred_non_zero_count(h, sl, n);
469             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
470             total_coeff= coeff_token>>2;
471         }
472     }
473     sl->non_zero_count_cache[scan8[n]] = total_coeff;
474
475     //FIXME set last_non_zero?
476
477     if(total_coeff==0)
478         return 0;
479     if(total_coeff > (unsigned)max_coeff) {
480         av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
481         return -1;
482     }
483
484     trailing_ones= coeff_token&3;
485     tprintf(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
486     assert(total_coeff<=16);
487
488     i = show_bits(gb, 3);
489     skip_bits(gb, trailing_ones);
490     level[0] = 1-((i&4)>>1);
491     level[1] = 1-((i&2)   );
492     level[2] = 1-((i&1)<<1);
493
494     if(trailing_ones<total_coeff) {
495         int mask, prefix;
496         int suffix_length = total_coeff > 10 & trailing_ones < 3;
497         int bitsi= show_bits(gb, LEVEL_TAB_BITS);
498         int level_code= cavlc_level_tab[suffix_length][bitsi][0];
499
500         skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
501         if(level_code >= 100){
502             prefix= level_code - 100;
503             if(prefix == LEVEL_TAB_BITS)
504                 prefix += get_level_prefix(gb);
505
506             //first coefficient has suffix_length equal to 0 or 1
507             if(prefix<14){ //FIXME try to build a large unified VLC table for all this
508                 if(suffix_length)
509                     level_code= (prefix<<1) + get_bits1(gb); //part
510                 else
511                     level_code= prefix; //part
512             }else if(prefix==14){
513                 if(suffix_length)
514                     level_code= (prefix<<1) + get_bits1(gb); //part
515                 else
516                     level_code= prefix + get_bits(gb, 4); //part
517             }else{
518                 level_code= 30 + get_bits(gb, prefix-3); //part
519                 if(prefix>=16){
520                     if(prefix > 25+3){
521                         av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
522                         return -1;
523                     }
524                     level_code += (1<<(prefix-3))-4096;
525                 }
526             }
527
528             if(trailing_ones < 3) level_code += 2;
529
530             suffix_length = 2;
531             mask= -(level_code&1);
532             level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
533         }else{
534             level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
535
536             suffix_length = 1 + (level_code + 3U > 6U);
537             level[trailing_ones]= level_code;
538         }
539
540         //remaining coefficients have suffix_length > 0
541         for(i=trailing_ones+1;i<total_coeff;i++) {
542             static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
543             int bitsi= show_bits(gb, LEVEL_TAB_BITS);
544             level_code= cavlc_level_tab[suffix_length][bitsi][0];
545
546             skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
547             if(level_code >= 100){
548                 prefix= level_code - 100;
549                 if(prefix == LEVEL_TAB_BITS){
550                     prefix += get_level_prefix(gb);
551                 }
552                 if(prefix<15){
553                     level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
554                 }else{
555                     level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
556                     if(prefix>=16)
557                         level_code += (1<<(prefix-3))-4096;
558                 }
559                 mask= -(level_code&1);
560                 level_code= (((2+level_code)>>1) ^ mask) - mask;
561             }
562             level[i]= level_code;
563             suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
564         }
565     }
566
567     if(total_coeff == max_coeff)
568         zeros_left=0;
569     else{
570         if (max_coeff <= 8) {
571             if (max_coeff == 4)
572                 zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff - 1].table,
573                                       CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
574             else
575                 zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
576                                       CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
577         } else {
578             zeros_left= get_vlc2(gb, total_zeros_vlc[total_coeff - 1].table, TOTAL_ZEROS_VLC_BITS, 1);
579         }
580     }
581
582 #define STORE_BLOCK(type) \
583     scantable += zeros_left + total_coeff - 1; \
584     if(n >= LUMA_DC_BLOCK_INDEX){ \
585         ((type*)block)[*scantable] = level[0]; \
586         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
587             if(zeros_left < 7) \
588                 run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
589             else \
590                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
591             zeros_left -= run_before; \
592             scantable -= 1 + run_before; \
593             ((type*)block)[*scantable]= level[i]; \
594         } \
595         for(;i<total_coeff;i++) { \
596             scantable--; \
597             ((type*)block)[*scantable]= level[i]; \
598         } \
599     }else{ \
600         ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
601         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
602             if(zeros_left < 7) \
603                 run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
604             else \
605                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
606             zeros_left -= run_before; \
607             scantable -= 1 + run_before; \
608             ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
609         } \
610         for(;i<total_coeff;i++) { \
611             scantable--; \
612             ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
613         } \
614     }
615
616     if (zeros_left < 0) {
617         av_log(h->avctx, AV_LOG_ERROR,
618                "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
619         return AVERROR_INVALIDDATA;
620     }
621
622     if (h->pixel_shift) {
623         STORE_BLOCK(int32_t)
624     } else {
625         STORE_BLOCK(int16_t)
626     }
627
628     return 0;
629 }
630
631 static av_always_inline int decode_luma_residual(H264Context *h, H264SliceContext *sl, GetBitContext *gb, const uint8_t *scan, const uint8_t *scan8x8, int pixel_shift, int mb_type, int cbp, int p){
632     int i4x4, i8x8;
633     int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
634     if(IS_INTRA16x16(mb_type)){
635         AV_ZERO128(sl->mb_luma_dc[p]+0);
636         AV_ZERO128(sl->mb_luma_dc[p]+8);
637         AV_ZERO128(sl->mb_luma_dc[p]+16);
638         AV_ZERO128(sl->mb_luma_dc[p]+24);
639         if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
640             return -1; //FIXME continue if partitioned and other return -1 too
641         }
642
643         assert((cbp&15) == 0 || (cbp&15) == 15);
644
645         if(cbp&15){
646             for(i8x8=0; i8x8<4; i8x8++){
647                 for(i4x4=0; i4x4<4; i4x4++){
648                     const int index= i4x4 + 4*i8x8 + p*16;
649                     if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
650                         index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
651                         return -1;
652                     }
653                 }
654             }
655             return 0xf;
656         }else{
657             fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
658             return 0;
659         }
660     }else{
661         int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
662         /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
663         int new_cbp = 0;
664         for(i8x8=0; i8x8<4; i8x8++){
665             if(cbp & (1<<i8x8)){
666                 if(IS_8x8DCT(mb_type)){
667                     int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
668                     uint8_t *nnz;
669                     for(i4x4=0; i4x4<4; i4x4++){
670                         const int index= i4x4 + 4*i8x8 + p*16;
671                         if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
672                                             h->dequant8_coeff[cqm][qscale], 16) < 0 )
673                             return -1;
674                     }
675                     nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
676                     nnz[0] += nnz[1] + nnz[8] + nnz[9];
677                     new_cbp |= !!nnz[0] << i8x8;
678                 }else{
679                     for(i4x4=0; i4x4<4; i4x4++){
680                         const int index= i4x4 + 4*i8x8 + p*16;
681                         if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
682                                             scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
683                             return -1;
684                         }
685                         new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
686                     }
687                 }
688             }else{
689                 uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
690                 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
691             }
692         }
693         return new_cbp;
694     }
695 }
696
697 int ff_h264_decode_mb_cavlc(H264Context *h, H264SliceContext *sl)
698 {
699     int mb_xy;
700     int partition_count;
701     unsigned int mb_type, cbp;
702     int dct8x8_allowed= h->pps.transform_8x8_mode;
703     int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
704     const int pixel_shift = h->pixel_shift;
705
706     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
707
708     tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, sl->mb_x, sl->mb_y);
709     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
710                 down the code */
711     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
712         if (sl->mb_skip_run == -1)
713             sl->mb_skip_run = get_ue_golomb(&sl->gb);
714
715         if (sl->mb_skip_run--) {
716             if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
717                 if (sl->mb_skip_run == 0)
718                     h->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
719             }
720             decode_mb_skip(h, sl);
721             return 0;
722         }
723     }
724     if (FRAME_MBAFF(h)) {
725         if ((sl->mb_y & 1) == 0)
726             h->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
727     }
728
729     sl->prev_mb_skipped = 0;
730
731     mb_type= get_ue_golomb(&sl->gb);
732     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
733         if(mb_type < 23){
734             partition_count= b_mb_type_info[mb_type].partition_count;
735             mb_type=         b_mb_type_info[mb_type].type;
736         }else{
737             mb_type -= 23;
738             goto decode_intra_mb;
739         }
740     } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
741         if(mb_type < 5){
742             partition_count= p_mb_type_info[mb_type].partition_count;
743             mb_type=         p_mb_type_info[mb_type].type;
744         }else{
745             mb_type -= 5;
746             goto decode_intra_mb;
747         }
748     }else{
749        assert(sl->slice_type_nos == AV_PICTURE_TYPE_I);
750         if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
751             mb_type--;
752 decode_intra_mb:
753         if(mb_type > 25){
754             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);
755             return -1;
756         }
757         partition_count=0;
758         cbp= i_mb_type_info[mb_type].cbp;
759         sl->intra16x16_pred_mode = i_mb_type_info[mb_type].pred_mode;
760         mb_type= i_mb_type_info[mb_type].type;
761     }
762
763     if (MB_FIELD(sl))
764         mb_type |= MB_TYPE_INTERLACED;
765
766     h->slice_table[mb_xy] = sl->slice_num;
767
768     if(IS_INTRA_PCM(mb_type)){
769         const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
770                             h->sps.bit_depth_luma;
771
772         // We assume these blocks are very rare so we do not optimize it.
773         sl->intra_pcm_ptr = align_get_bits(&sl->gb);
774         if (get_bits_left(&sl->gb) < mb_size) {
775             av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
776             return AVERROR_INVALIDDATA;
777         }
778         skip_bits_long(&sl->gb, mb_size);
779
780         // In deblocking, the quantizer is 0
781         h->cur_pic.qscale_table[mb_xy] = 0;
782         // All coeffs are present
783         memset(h->non_zero_count[mb_xy], 16, 48);
784
785         h->cur_pic.mb_type[mb_xy] = mb_type;
786         return 0;
787     }
788
789     fill_decode_neighbors(h, sl, mb_type);
790     fill_decode_caches(h, sl, mb_type);
791
792     //mb_pred
793     if(IS_INTRA(mb_type)){
794         int pred_mode;
795 //            init_top_left_availability(h);
796         if(IS_INTRA4x4(mb_type)){
797             int i;
798             int di = 1;
799             if(dct8x8_allowed && get_bits1(&sl->gb)){
800                 mb_type |= MB_TYPE_8x8DCT;
801                 di = 4;
802             }
803
804 //                fill_intra4x4_pred_table(h);
805             for(i=0; i<16; i+=di){
806                 int mode = pred_intra_mode(h, sl, i);
807
808                 if(!get_bits1(&sl->gb)){
809                     const int rem_mode= get_bits(&sl->gb, 3);
810                     mode = rem_mode + (rem_mode >= mode);
811                 }
812
813                 if(di==4)
814                     fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
815                 else
816                     sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
817             }
818             write_back_intra_pred_mode(h, sl);
819             if (ff_h264_check_intra4x4_pred_mode(h, sl) < 0)
820                 return -1;
821         }else{
822             sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, sl->intra16x16_pred_mode, 0);
823             if (sl->intra16x16_pred_mode < 0)
824                 return -1;
825         }
826         if(decode_chroma){
827             pred_mode= ff_h264_check_intra_pred_mode(h, sl, 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]= b_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
845                 sl->sub_mb_type[i]=      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]= p_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
863                 sl->sub_mb_type[i]=      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(h);
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                         tprintf(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->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(h);
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                     tprintf(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(h);
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                         tprintf(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(h);
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                         tprintf(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)) cbp= golomb_to_intra4x4_cbp[cbp];
1064             else                     cbp= golomb_to_inter_cbp   [cbp];
1065         }else{
1066             if(cbp > 15){
1067                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1068                 return -1;
1069             }
1070             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1071             else                     cbp= golomb_to_inter_cbp_gray[cbp];
1072         }
1073     }
1074
1075     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1076         mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1077     }
1078     sl->cbp=
1079     h->cbp_table[mb_xy]= cbp;
1080     h->cur_pic.mb_type[mb_xy] = mb_type;
1081
1082     if(cbp || IS_INTRA16x16(mb_type)){
1083         int i4x4, i8x8, chroma_idx;
1084         int dquant;
1085         int ret;
1086         GetBitContext *gb = &sl->gb;
1087         const uint8_t *scan, *scan8x8;
1088         const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1089
1090         if(IS_INTERLACED(mb_type)){
1091             scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1092             scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
1093         }else{
1094             scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1095             scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1096         }
1097
1098         dquant= get_se_golomb(&sl->gb);
1099
1100         sl->qscale += dquant;
1101
1102         if (((unsigned)sl->qscale) > max_qp){
1103             if (sl->qscale < 0) sl->qscale += max_qp + 1;
1104             else                sl->qscale -= max_qp+1;
1105             if (((unsigned)sl->qscale) > max_qp){
1106                 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1107                 return -1;
1108             }
1109         }
1110
1111         sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
1112         sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
1113
1114         if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1115             return -1;
1116         }
1117         h->cbp_table[mb_xy] |= ret << 12;
1118         if (CHROMA444(h)) {
1119             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1120                 return -1;
1121             }
1122             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1123                 return -1;
1124             }
1125         } else if (CHROMA422(h)) {
1126             if(cbp&0x30){
1127                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1128                     if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1129                                         CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma422_dc_scan,
1130                                         NULL, 8) < 0) {
1131                         return -1;
1132                     }
1133             }
1134
1135             if(cbp&0x20){
1136                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1137                     const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1138                     int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1139                     for (i8x8 = 0; i8x8 < 2; i8x8++) {
1140                         for (i4x4 = 0; i4x4 < 4; i4x4++) {
1141                             const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1142                             if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1143                                 return -1;
1144                             mb += 16 << pixel_shift;
1145                         }
1146                     }
1147                 }
1148             }else{
1149                 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1150                 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1151             }
1152         } else /* yuv420 */ {
1153             if(cbp&0x30){
1154                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1155                     if( decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift), CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma_dc_scan, NULL, 4) < 0){
1156                         return -1;
1157                     }
1158             }
1159
1160             if(cbp&0x20){
1161                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1162                     const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1163                     for(i4x4=0; i4x4<4; i4x4++){
1164                         const int index= 16 + 16*chroma_idx + i4x4;
1165                         if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
1166                             return -1;
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 }