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