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