lavc/texturedsp: replace rint by lrint
[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(const H264Context *h, H264SliceContext *sl, int n)
288 {
289     const int index8= scan8[n];
290     const int left = sl->non_zero_count_cache[index8 - 1];
291     const int top  = sl->non_zero_count_cache[index8 - 8];
292     int i= left + top;
293
294     if(i<64) i= (i+1)>>1;
295
296     ff_tlog(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
297
298     return i&31;
299 }
300
301 static av_cold void init_cavlc_level_tab(void){
302     int suffix_length;
303     unsigned int i;
304
305     for(suffix_length=0; suffix_length<7; suffix_length++){
306         for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
307             int prefix= LEVEL_TAB_BITS - av_log2(2*i);
308
309             if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
310                 int level_code = (prefix << suffix_length) +
311                     (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
312                 int mask = -(level_code&1);
313                 level_code = (((2 + level_code) >> 1) ^ mask) - mask;
314                 cavlc_level_tab[suffix_length][i][0]= level_code;
315                 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
316             }else if(prefix + 1 <= LEVEL_TAB_BITS){
317                 cavlc_level_tab[suffix_length][i][0]= prefix+100;
318                 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
319             }else{
320                 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
321                 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
322             }
323         }
324     }
325 }
326
327 av_cold void ff_h264_decode_init_vlc(void){
328     static int done = 0;
329
330     if (!done) {
331         int i;
332         int offset;
333         done = 1;
334
335         chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
336         chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
337         init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
338                  &chroma_dc_coeff_token_len [0], 1, 1,
339                  &chroma_dc_coeff_token_bits[0], 1, 1,
340                  INIT_VLC_USE_NEW_STATIC);
341
342         chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
343         chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
344         init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
345                  &chroma422_dc_coeff_token_len [0], 1, 1,
346                  &chroma422_dc_coeff_token_bits[0], 1, 1,
347                  INIT_VLC_USE_NEW_STATIC);
348
349         offset = 0;
350         for(i=0; i<4; i++){
351             coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
352             coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
353             init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
354                      &coeff_token_len [i][0], 1, 1,
355                      &coeff_token_bits[i][0], 1, 1,
356                      INIT_VLC_USE_NEW_STATIC);
357             offset += coeff_token_vlc_tables_size[i];
358         }
359         /*
360          * This is a one time safety check to make sure that
361          * the packed static coeff_token_vlc table sizes
362          * were initialized correctly.
363          */
364         av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
365
366         for(i=0; i<3; i++){
367             chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
368             chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
369             init_vlc(&chroma_dc_total_zeros_vlc[i],
370                      CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
371                      &chroma_dc_total_zeros_len [i][0], 1, 1,
372                      &chroma_dc_total_zeros_bits[i][0], 1, 1,
373                      INIT_VLC_USE_NEW_STATIC);
374         }
375
376         for(i=0; i<7; i++){
377             chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
378             chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
379             init_vlc(&chroma422_dc_total_zeros_vlc[i],
380                      CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
381                      &chroma422_dc_total_zeros_len [i][0], 1, 1,
382                      &chroma422_dc_total_zeros_bits[i][0], 1, 1,
383                      INIT_VLC_USE_NEW_STATIC);
384         }
385
386         for(i=0; i<15; i++){
387             total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
388             total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
389             init_vlc(&total_zeros_vlc[i],
390                      TOTAL_ZEROS_VLC_BITS, 16,
391                      &total_zeros_len [i][0], 1, 1,
392                      &total_zeros_bits[i][0], 1, 1,
393                      INIT_VLC_USE_NEW_STATIC);
394         }
395
396         for(i=0; i<6; i++){
397             run_vlc[i].table = run_vlc_tables[i];
398             run_vlc[i].table_allocated = run_vlc_tables_size;
399             init_vlc(&run_vlc[i],
400                      RUN_VLC_BITS, 7,
401                      &run_len [i][0], 1, 1,
402                      &run_bits[i][0], 1, 1,
403                      INIT_VLC_USE_NEW_STATIC);
404         }
405         run7_vlc.table = run7_vlc_table,
406         run7_vlc.table_allocated = run7_vlc_table_size;
407         init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
408                  &run_len [6][0], 1, 1,
409                  &run_bits[6][0], 1, 1,
410                  INIT_VLC_USE_NEW_STATIC);
411
412         init_cavlc_level_tab();
413     }
414 }
415
416 /**
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(const 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", sl->mb_x, sl->mb_y, total_coeff);
482         return -1;
483     }
484
485     trailing_ones= coeff_token&3;
486     ff_tlog(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", sl->mb_x, sl->mb_y);
632         return -1;
633     }
634
635     return 0;
636 }
637
638 static av_always_inline
639 int decode_luma_residual(const H264Context *h, H264SliceContext *sl,
640                          GetBitContext *gb, const uint8_t *scan,
641                          const uint8_t *scan8x8, int pixel_shift,
642                          int mb_type, int cbp, int p)
643 {
644     int i4x4, i8x8;
645     int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
646     if(IS_INTRA16x16(mb_type)){
647         AV_ZERO128(sl->mb_luma_dc[p]+0);
648         AV_ZERO128(sl->mb_luma_dc[p]+8);
649         AV_ZERO128(sl->mb_luma_dc[p]+16);
650         AV_ZERO128(sl->mb_luma_dc[p]+24);
651         if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
652             return -1; //FIXME continue if partitioned and other return -1 too
653         }
654
655         av_assert2((cbp&15) == 0 || (cbp&15) == 15);
656
657         if(cbp&15){
658             for(i8x8=0; i8x8<4; i8x8++){
659                 for(i4x4=0; i4x4<4; i4x4++){
660                     const int index= i4x4 + 4*i8x8 + p*16;
661                     if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
662                         index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
663                         return -1;
664                     }
665                 }
666             }
667             return 0xf;
668         }else{
669             fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
670             return 0;
671         }
672     }else{
673         int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
674         /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
675         int new_cbp = 0;
676         for(i8x8=0; i8x8<4; i8x8++){
677             if(cbp & (1<<i8x8)){
678                 if(IS_8x8DCT(mb_type)){
679                     int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
680                     uint8_t *nnz;
681                     for(i4x4=0; i4x4<4; i4x4++){
682                         const int index= i4x4 + 4*i8x8 + p*16;
683                         if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
684                                             h->dequant8_coeff[cqm][qscale], 16) < 0 )
685                             return -1;
686                     }
687                     nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
688                     nnz[0] += nnz[1] + nnz[8] + nnz[9];
689                     new_cbp |= !!nnz[0] << i8x8;
690                 }else{
691                     for(i4x4=0; i4x4<4; i4x4++){
692                         const int index= i4x4 + 4*i8x8 + p*16;
693                         if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
694                                             scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
695                             return -1;
696                         }
697                         new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
698                     }
699                 }
700             }else{
701                 uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
702                 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
703             }
704         }
705         return new_cbp;
706     }
707 }
708
709 int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
710 {
711     int mb_xy;
712     int partition_count;
713     unsigned int mb_type, cbp;
714     int dct8x8_allowed= h->pps.transform_8x8_mode;
715     int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
716     const int pixel_shift = h->pixel_shift;
717
718     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
719
720     ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, sl->mb_x, sl->mb_y);
721     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
722                 down the code */
723     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
724         if (sl->mb_skip_run == -1)
725             sl->mb_skip_run = get_ue_golomb_long(&sl->gb);
726
727         if (sl->mb_skip_run--) {
728             if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
729                 if (sl->mb_skip_run == 0)
730                     sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
731             }
732             decode_mb_skip(h, sl);
733             return 0;
734         }
735     }
736     if (FRAME_MBAFF(h)) {
737         if ((sl->mb_y & 1) == 0)
738             sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
739     }
740
741     sl->prev_mb_skipped = 0;
742
743     mb_type= get_ue_golomb(&sl->gb);
744     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
745         if(mb_type < 23){
746             partition_count= b_mb_type_info[mb_type].partition_count;
747             mb_type=         b_mb_type_info[mb_type].type;
748         }else{
749             mb_type -= 23;
750             goto decode_intra_mb;
751         }
752     } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
753         if(mb_type < 5){
754             partition_count= p_mb_type_info[mb_type].partition_count;
755             mb_type=         p_mb_type_info[mb_type].type;
756         }else{
757             mb_type -= 5;
758             goto decode_intra_mb;
759         }
760     }else{
761        av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
762         if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
763             mb_type--;
764 decode_intra_mb:
765         if(mb_type > 25){
766             av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(sl->slice_type), sl->mb_x, sl->mb_y);
767             return -1;
768         }
769         partition_count=0;
770         cbp= i_mb_type_info[mb_type].cbp;
771         sl->intra16x16_pred_mode = i_mb_type_info[mb_type].pred_mode;
772         mb_type= i_mb_type_info[mb_type].type;
773     }
774
775     if (MB_FIELD(sl))
776         mb_type |= MB_TYPE_INTERLACED;
777
778     h->slice_table[mb_xy] = sl->slice_num;
779
780     if(IS_INTRA_PCM(mb_type)){
781         const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
782                             h->sps.bit_depth_luma;
783
784         // We assume these blocks are very rare so we do not optimize it.
785         sl->intra_pcm_ptr = align_get_bits(&sl->gb);
786         if (get_bits_left(&sl->gb) < mb_size) {
787             av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
788             return AVERROR_INVALIDDATA;
789         }
790         skip_bits_long(&sl->gb, mb_size);
791
792         // In deblocking, the quantizer is 0
793         h->cur_pic.qscale_table[mb_xy] = 0;
794         // All coeffs are present
795         memset(h->non_zero_count[mb_xy], 16, 48);
796
797         h->cur_pic.mb_type[mb_xy] = mb_type;
798         return 0;
799     }
800
801     fill_decode_neighbors(h, sl, mb_type);
802     fill_decode_caches(h, sl, mb_type);
803
804     //mb_pred
805     if(IS_INTRA(mb_type)){
806         int pred_mode;
807 //            init_top_left_availability(h);
808         if(IS_INTRA4x4(mb_type)){
809             int i;
810             int di = 1;
811             if(dct8x8_allowed && get_bits1(&sl->gb)){
812                 mb_type |= MB_TYPE_8x8DCT;
813                 di = 4;
814             }
815
816 //                fill_intra4x4_pred_table(h);
817             for(i=0; i<16; i+=di){
818                 int mode = pred_intra_mode(h, sl, i);
819
820                 if(!get_bits1(&sl->gb)){
821                     const int rem_mode= get_bits(&sl->gb, 3);
822                     mode = rem_mode + (rem_mode >= mode);
823                 }
824
825                 if(di==4)
826                     fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
827                 else
828                     sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
829             }
830             write_back_intra_pred_mode(h, sl);
831             if (ff_h264_check_intra4x4_pred_mode(h, sl) < 0)
832                 return -1;
833         }else{
834             sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, sl->intra16x16_pred_mode, 0);
835             if (sl->intra16x16_pred_mode < 0)
836                 return -1;
837         }
838         if(decode_chroma){
839             pred_mode= ff_h264_check_intra_pred_mode(h, sl, get_ue_golomb_31(&sl->gb), 1);
840             if(pred_mode < 0)
841                 return -1;
842             sl->chroma_pred_mode = pred_mode;
843         } else {
844             sl->chroma_pred_mode = DC_128_PRED8x8;
845         }
846     }else if(partition_count==4){
847         int i, j, sub_partition_count[4], list, ref[2][4];
848
849         if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
850             for(i=0; i<4; i++){
851                 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
852                 if(sl->sub_mb_type[i] >=13){
853                     av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
854                     return -1;
855                 }
856                 sub_partition_count[i]= b_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
857                 sl->sub_mb_type[i]=      b_sub_mb_type_info[ sl->sub_mb_type[i] ].type;
858             }
859             if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
860                 ff_h264_pred_direct_motion(h, sl, &mb_type);
861                 sl->ref_cache[0][scan8[4]] =
862                 sl->ref_cache[1][scan8[4]] =
863                 sl->ref_cache[0][scan8[12]] =
864                 sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
865             }
866         }else{
867             av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
868             for(i=0; i<4; i++){
869                 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
870                 if(sl->sub_mb_type[i] >=4){
871                     av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
872                     return -1;
873                 }
874                 sub_partition_count[i]= p_sub_mb_type_info[ sl->sub_mb_type[i] ].partition_count;
875                 sl->sub_mb_type[i]=      p_sub_mb_type_info[ sl->sub_mb_type[i] ].type;
876             }
877         }
878
879         for (list = 0; list < sl->list_count; list++) {
880             int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
881             for(i=0; i<4; i++){
882                 if(IS_DIRECT(sl->sub_mb_type[i])) continue;
883                 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
884                     unsigned int tmp;
885                     if(ref_count == 1){
886                         tmp= 0;
887                     }else if(ref_count == 2){
888                         tmp= get_bits1(&sl->gb)^1;
889                     }else{
890                         tmp= get_ue_golomb_31(&sl->gb);
891                         if(tmp>=ref_count){
892                             av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
893                             return -1;
894                         }
895                     }
896                     ref[list][i]= tmp;
897                 }else{
898                  //FIXME
899                     ref[list][i] = -1;
900                 }
901             }
902         }
903
904         if(dct8x8_allowed)
905             dct8x8_allowed = get_dct8x8_allowed(h, sl);
906
907         for (list = 0; list < sl->list_count; list++) {
908             for(i=0; i<4; i++){
909                 if(IS_DIRECT(sl->sub_mb_type[i])) {
910                     sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
911                     continue;
912                 }
913                 sl->ref_cache[list][ scan8[4*i]   ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
914                 sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
915
916                 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
917                     const int sub_mb_type= sl->sub_mb_type[i];
918                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
919                     for(j=0; j<sub_partition_count[i]; j++){
920                         int mx, my;
921                         const int index= 4*i + block_width*j;
922                         int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
923                         pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
924                         mx += get_se_golomb(&sl->gb);
925                         my += get_se_golomb(&sl->gb);
926                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
927
928                         if(IS_SUB_8X8(sub_mb_type)){
929                             mv_cache[ 1 ][0]=
930                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
931                             mv_cache[ 1 ][1]=
932                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
933                         }else if(IS_SUB_8X4(sub_mb_type)){
934                             mv_cache[ 1 ][0]= mx;
935                             mv_cache[ 1 ][1]= my;
936                         }else if(IS_SUB_4X8(sub_mb_type)){
937                             mv_cache[ 8 ][0]= mx;
938                             mv_cache[ 8 ][1]= my;
939                         }
940                         mv_cache[ 0 ][0]= mx;
941                         mv_cache[ 0 ][1]= my;
942                     }
943                 }else{
944                     uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
945                     p[0] = p[1]=
946                     p[8] = p[9]= 0;
947                 }
948             }
949         }
950     }else if(IS_DIRECT(mb_type)){
951         ff_h264_pred_direct_motion(h, sl, &mb_type);
952         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
953     }else{
954         int list, mx, my, i;
955          //FIXME we should set ref_idx_l? to 0 if we use that later ...
956         if(IS_16X16(mb_type)){
957             for (list = 0; list < sl->list_count; list++) {
958                     unsigned int val;
959                     if(IS_DIR(mb_type, 0, list)){
960                         unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
961                         if (rc == 1) {
962                             val= 0;
963                         } else if (rc == 2) {
964                             val= get_bits1(&sl->gb)^1;
965                         }else{
966                             val= get_ue_golomb_31(&sl->gb);
967                             if (val >= rc) {
968                                 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
969                                 return -1;
970                             }
971                         }
972                     fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
973                     }
974             }
975             for (list = 0; list < sl->list_count; list++) {
976                 if(IS_DIR(mb_type, 0, list)){
977                     pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
978                     mx += get_se_golomb(&sl->gb);
979                     my += get_se_golomb(&sl->gb);
980                     ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
981
982                     fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
983                 }
984             }
985         }
986         else if(IS_16X8(mb_type)){
987             for (list = 0; list < sl->list_count; list++) {
988                     for(i=0; i<2; i++){
989                         unsigned int val;
990                         if(IS_DIR(mb_type, i, list)){
991                             unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
992                             if (rc == 1) {
993                                 val= 0;
994                             } else if (rc == 2) {
995                                 val= get_bits1(&sl->gb)^1;
996                             }else{
997                                 val= get_ue_golomb_31(&sl->gb);
998                                 if (val >= rc) {
999                                     av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1000                                     return -1;
1001                                 }
1002                             }
1003                         }else
1004                             val= LIST_NOT_USED&0xFF;
1005                         fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1006                     }
1007             }
1008             for (list = 0; list < sl->list_count; list++) {
1009                 for(i=0; i<2; i++){
1010                     unsigned int val;
1011                     if(IS_DIR(mb_type, i, list)){
1012                         pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1013                         mx += get_se_golomb(&sl->gb);
1014                         my += get_se_golomb(&sl->gb);
1015                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1016
1017                         val= pack16to32(mx,my);
1018                     }else
1019                         val=0;
1020                     fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1021                 }
1022             }
1023         }else{
1024             av_assert2(IS_8X16(mb_type));
1025             for (list = 0; list < sl->list_count; list++) {
1026                     for(i=0; i<2; i++){
1027                         unsigned int val;
1028                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1029                             unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1030                             if (rc == 1) {
1031                                 val= 0;
1032                             } else if (rc == 2) {
1033                                 val= get_bits1(&sl->gb)^1;
1034                             }else{
1035                                 val= get_ue_golomb_31(&sl->gb);
1036                                 if (val >= rc) {
1037                                     av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1038                                     return -1;
1039                                 }
1040                             }
1041                         }else
1042                             val= LIST_NOT_USED&0xFF;
1043                         fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1044                     }
1045             }
1046             for (list = 0; list < sl->list_count; list++) {
1047                 for(i=0; i<2; i++){
1048                     unsigned int val;
1049                     if(IS_DIR(mb_type, i, list)){
1050                         pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1051                         mx += get_se_golomb(&sl->gb);
1052                         my += get_se_golomb(&sl->gb);
1053                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1054
1055                         val= pack16to32(mx,my);
1056                     }else
1057                         val=0;
1058                     fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1059                 }
1060             }
1061         }
1062     }
1063
1064     if(IS_INTER(mb_type))
1065         write_back_motion(h, sl, mb_type);
1066
1067     if(!IS_INTRA16x16(mb_type)){
1068         cbp= get_ue_golomb(&sl->gb);
1069
1070         if(decode_chroma){
1071             if(cbp > 47){
1072                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1073                 return -1;
1074             }
1075             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
1076             else                     cbp= golomb_to_inter_cbp   [cbp];
1077         }else{
1078             if(cbp > 15){
1079                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1080                 return -1;
1081             }
1082             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1083             else                     cbp= golomb_to_inter_cbp_gray[cbp];
1084         }
1085     } else {
1086         if (!decode_chroma && cbp>15) {
1087             av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1088             return AVERROR_INVALIDDATA;
1089         }
1090     }
1091
1092     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1093         mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1094     }
1095     sl->cbp=
1096     h->cbp_table[mb_xy]= cbp;
1097     h->cur_pic.mb_type[mb_xy] = mb_type;
1098
1099     if(cbp || IS_INTRA16x16(mb_type)){
1100         int i4x4, i8x8, chroma_idx;
1101         int dquant;
1102         int ret;
1103         GetBitContext *gb = &sl->gb;
1104         const uint8_t *scan, *scan8x8;
1105         const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1106
1107         if(IS_INTERLACED(mb_type)){
1108             scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1109             scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
1110         }else{
1111             scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1112             scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1113         }
1114
1115         dquant= get_se_golomb(&sl->gb);
1116
1117         sl->qscale += dquant;
1118
1119         if (((unsigned)sl->qscale) > max_qp){
1120             if (sl->qscale < 0) sl->qscale += max_qp + 1;
1121             else                sl->qscale -= max_qp+1;
1122             if (((unsigned)sl->qscale) > max_qp){
1123                 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1124                 return -1;
1125             }
1126         }
1127
1128         sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
1129         sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
1130
1131         if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1132             return -1;
1133         }
1134         h->cbp_table[mb_xy] |= ret << 12;
1135         if (CHROMA444(h)) {
1136             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1137                 return -1;
1138             }
1139             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1140                 return -1;
1141             }
1142         } else {
1143             const int num_c8x8 = h->sps.chroma_format_idc;
1144
1145             if(cbp&0x30){
1146                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1147                     if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1148                                         CHROMA_DC_BLOCK_INDEX+chroma_idx,
1149                                         CHROMA422(h) ? chroma422_dc_scan : chroma_dc_scan,
1150                                         NULL, 4*num_c8x8) < 0) {
1151                         return -1;
1152                     }
1153             }
1154
1155             if(cbp&0x20){
1156                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1157                     const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1158                     int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1159                     for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1160                         for (i4x4 = 0; i4x4 < 4; i4x4++) {
1161                             const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1162                             if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1163                                 return -1;
1164                             mb += 16 << pixel_shift;
1165                         }
1166                     }
1167                 }
1168             }else{
1169                 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1170                 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1171             }
1172         }
1173     }else{
1174         fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1175         fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1176         fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1177     }
1178     h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1179     write_back_non_zero_count(h, sl);
1180
1181     return 0;
1182 }