Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cavlc.c @ 69cc3183

History | View | Annotate | Download (37.1 KB)

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 libavcodec/h264_cavlc.c
24
 * H.264 / AVC / MPEG4 part10 cavlc bitstream decoding.
25
 * @author Michael Niedermayer <michaelni@gmx.at>
26
 */
27

    
28
#define CABAC 0
29

    
30
#include "internal.h"
31
#include "avcodec.h"
32
#include "mpegvideo.h"
33
#include "h264.h"
34
#include "h264data.h" // FIXME FIXME FIXME
35
#include "h264_mvpred.h"
36
#include "golomb.h"
37

    
38
//#undef NDEBUG
39
#include <assert.h>
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 coeff_token_len[4][4*17]={
66
{
67
     1, 0, 0, 0,
68
     6, 2, 0, 0,     8, 6, 3, 0,     9, 8, 7, 5,    10, 9, 8, 6,
69
    11,10, 9, 7,    13,11,10, 8,    13,13,11, 9,    13,13,13,10,
70
    14,14,13,11,    14,14,14,13,    15,15,14,14,    15,15,15,14,
71
    16,15,15,15,    16,16,16,15,    16,16,16,16,    16,16,16,16,
72
},
73
{
74
     2, 0, 0, 0,
75
     6, 2, 0, 0,     6, 5, 3, 0,     7, 6, 6, 4,     8, 6, 6, 4,
76
     8, 7, 7, 5,     9, 8, 8, 6,    11, 9, 9, 6,    11,11,11, 7,
77
    12,11,11, 9,    12,12,12,11,    12,12,12,11,    13,13,13,12,
78
    13,13,13,13,    13,14,13,13,    14,14,14,13,    14,14,14,14,
79
},
80
{
81
     4, 0, 0, 0,
82
     6, 4, 0, 0,     6, 5, 4, 0,     6, 5, 5, 4,     7, 5, 5, 4,
83
     7, 5, 5, 4,     7, 6, 6, 4,     7, 6, 6, 4,     8, 7, 7, 5,
84
     8, 8, 7, 6,     9, 8, 8, 7,     9, 9, 8, 8,     9, 9, 9, 8,
85
    10, 9, 9, 9,    10,10,10,10,    10,10,10,10,    10,10,10,10,
86
},
87
{
88
     6, 0, 0, 0,
89
     6, 6, 0, 0,     6, 6, 6, 0,     6, 6, 6, 6,     6, 6, 6, 6,
90
     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
91
     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
92
     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
93
}
94
};
95

    
96
static const uint8_t coeff_token_bits[4][4*17]={
97
{
98
     1, 0, 0, 0,
99
     5, 1, 0, 0,     7, 4, 1, 0,     7, 6, 5, 3,     7, 6, 5, 3,
100
     7, 6, 5, 4,    15, 6, 5, 4,    11,14, 5, 4,     8,10,13, 4,
101
    15,14, 9, 4,    11,10,13,12,    15,14, 9,12,    11,10,13, 8,
102
    15, 1, 9,12,    11,14,13, 8,     7,10, 9,12,     4, 6, 5, 8,
103
},
104
{
105
     3, 0, 0, 0,
106
    11, 2, 0, 0,     7, 7, 3, 0,     7,10, 9, 5,     7, 6, 5, 4,
107
     4, 6, 5, 6,     7, 6, 5, 8,    15, 6, 5, 4,    11,14,13, 4,
108
    15,10, 9, 4,    11,14,13,12,     8,10, 9, 8,    15,14,13,12,
109
    11,10, 9,12,     7,11, 6, 8,     9, 8,10, 1,     7, 6, 5, 4,
110
},
111
{
112
    15, 0, 0, 0,
113
    15,14, 0, 0,    11,15,13, 0,     8,12,14,12,    15,10,11,11,
114
    11, 8, 9,10,     9,14,13, 9,     8,10, 9, 8,    15,14,13,13,
115
    11,14,10,12,    15,10,13,12,    11,14, 9,12,     8,10,13, 8,
116
    13, 7, 9,12,     9,12,11,10,     5, 8, 7, 6,     1, 4, 3, 2,
117
},
118
{
119
     3, 0, 0, 0,
120
     0, 1, 0, 0,     4, 5, 6, 0,     8, 9,10,11,    12,13,14,15,
121
    16,17,18,19,    20,21,22,23,    24,25,26,27,    28,29,30,31,
122
    32,33,34,35,    36,37,38,39,    40,41,42,43,    44,45,46,47,
123
    48,49,50,51,    52,53,54,55,    56,57,58,59,    60,61,62,63,
124
}
125
};
126

    
127
static const uint8_t total_zeros_len[16][16]= {
128
    {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
129
    {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
130
    {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
131
    {5,3,4,4,3,3,3,4,3,4,5,5,5},
132
    {4,4,4,3,3,3,3,3,4,5,4,5},
133
    {6,5,3,3,3,3,3,3,4,3,6},
134
    {6,5,3,3,3,2,3,4,3,6},
135
    {6,4,5,3,2,2,3,3,6},
136
    {6,6,4,2,2,3,2,5},
137
    {5,5,3,2,2,2,4},
138
    {4,4,3,3,1,3},
139
    {4,4,2,1,3},
140
    {3,3,1,2},
141
    {2,2,1},
142
    {1,1},
143
};
144

    
145
static const uint8_t total_zeros_bits[16][16]= {
146
    {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
147
    {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
148
    {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
149
    {3,7,5,4,6,5,4,3,3,2,2,1,0},
150
    {5,4,3,7,6,5,4,3,2,1,1,0},
151
    {1,1,7,6,5,4,3,2,1,1,0},
152
    {1,1,5,4,3,3,2,1,1,0},
153
    {1,1,1,3,3,2,2,1,0},
154
    {1,0,1,3,2,1,1,1},
155
    {1,0,1,3,2,1,1},
156
    {0,1,1,2,1,3},
157
    {0,1,1,1,1},
158
    {0,1,1,1},
159
    {0,1,1},
160
    {0,1},
161
};
162

    
163
static const uint8_t chroma_dc_total_zeros_len[3][4]= {
164
    { 1, 2, 3, 3,},
165
    { 1, 2, 2, 0,},
166
    { 1, 1, 0, 0,},
167
};
168

    
169
static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
170
    { 1, 1, 1, 0,},
171
    { 1, 1, 0, 0,},
172
    { 1, 0, 0, 0,},
173
};
174

    
175
static const uint8_t run_len[7][16]={
176
    {1,1},
177
    {1,2,2},
178
    {2,2,2,2},
179
    {2,2,2,3,3},
180
    {2,2,3,3,3,3},
181
    {2,3,3,3,3,3,3},
182
    {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
183
};
184

    
185
static const uint8_t run_bits[7][16]={
186
    {1,0},
187
    {1,1,0},
188
    {3,2,1,0},
189
    {3,2,1,1,0},
190
    {3,2,3,2,1,0},
191
    {3,0,1,3,2,5,4},
192
    {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
193
};
194

    
195
static VLC coeff_token_vlc[4];
196
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
197
static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
198

    
199
static VLC chroma_dc_coeff_token_vlc;
200
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
201
static const int chroma_dc_coeff_token_vlc_table_size = 256;
202

    
203
static VLC total_zeros_vlc[15];
204
static VLC_TYPE total_zeros_vlc_tables[15][512][2];
205
static const int total_zeros_vlc_tables_size = 512;
206

    
207
static VLC chroma_dc_total_zeros_vlc[3];
208
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
209
static const int chroma_dc_total_zeros_vlc_tables_size = 8;
210

    
211
static VLC run_vlc[6];
212
static VLC_TYPE run_vlc_tables[6][8][2];
213
static const int run_vlc_tables_size = 8;
214

    
215
static VLC run7_vlc;
216
static VLC_TYPE run7_vlc_table[96][2];
217
static const int run7_vlc_table_size = 96;
218

    
219
#define LEVEL_TAB_BITS 8
220
static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
221

    
222

    
223
/**
224
 * gets the predicted number of non-zero coefficients.
225
 * @param n block index
226
 */
227
static inline int pred_non_zero_count(H264Context *h, int n){
228
    const int index8= scan8[n];
229
    const int left= h->non_zero_count_cache[index8 - 1];
230
    const int top = h->non_zero_count_cache[index8 - 8];
231
    int i= left + top;
232

    
233
    if(i<64) i= (i+1)>>1;
234

    
235
    tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
236

    
237
    return i&31;
238
}
239

    
240
static av_cold void init_cavlc_level_tab(void){
241
    int suffix_length, mask;
242
    unsigned int i;
243

    
244
    for(suffix_length=0; suffix_length<7; suffix_length++){
245
        for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
246
            int prefix= LEVEL_TAB_BITS - av_log2(2*i);
247
            int level_code= (prefix<<suffix_length) + (i>>(LEVEL_TAB_BITS-prefix-1-suffix_length)) - (1<<suffix_length);
248

    
249
            mask= -(level_code&1);
250
            level_code= (((2+level_code)>>1) ^ mask) - mask;
251
            if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
252
                cavlc_level_tab[suffix_length][i][0]= level_code;
253
                cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
254
            }else if(prefix + 1 <= LEVEL_TAB_BITS){
255
                cavlc_level_tab[suffix_length][i][0]= prefix+100;
256
                cavlc_level_tab[suffix_length][i][1]= prefix + 1;
257
            }else{
258
                cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
259
                cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
260
            }
261
        }
262
    }
263
}
264

    
265
av_cold void ff_h264_decode_init_vlc(void){
266
    static int done = 0;
267

    
268
    if (!done) {
269
        int i;
270
        int offset;
271
        done = 1;
272

    
273
        chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
274
        chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
275
        init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
276
                 &chroma_dc_coeff_token_len [0], 1, 1,
277
                 &chroma_dc_coeff_token_bits[0], 1, 1,
278
                 INIT_VLC_USE_NEW_STATIC);
279

    
280
        offset = 0;
281
        for(i=0; i<4; i++){
282
            coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
283
            coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
284
            init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
285
                     &coeff_token_len [i][0], 1, 1,
286
                     &coeff_token_bits[i][0], 1, 1,
287
                     INIT_VLC_USE_NEW_STATIC);
288
            offset += coeff_token_vlc_tables_size[i];
289
        }
290
        /*
291
         * This is a one time safety check to make sure that
292
         * the packed static coeff_token_vlc table sizes
293
         * were initialized correctly.
294
         */
295
        assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
296

    
297
        for(i=0; i<3; i++){
298
            chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
299
            chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
300
            init_vlc(&chroma_dc_total_zeros_vlc[i],
301
                     CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
302
                     &chroma_dc_total_zeros_len [i][0], 1, 1,
303
                     &chroma_dc_total_zeros_bits[i][0], 1, 1,
304
                     INIT_VLC_USE_NEW_STATIC);
305
        }
306
        for(i=0; i<15; i++){
307
            total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
308
            total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
309
            init_vlc(&total_zeros_vlc[i],
310
                     TOTAL_ZEROS_VLC_BITS, 16,
311
                     &total_zeros_len [i][0], 1, 1,
312
                     &total_zeros_bits[i][0], 1, 1,
313
                     INIT_VLC_USE_NEW_STATIC);
314
        }
315

    
316
        for(i=0; i<6; i++){
317
            run_vlc[i].table = run_vlc_tables[i];
318
            run_vlc[i].table_allocated = run_vlc_tables_size;
319
            init_vlc(&run_vlc[i],
320
                     RUN_VLC_BITS, 7,
321
                     &run_len [i][0], 1, 1,
322
                     &run_bits[i][0], 1, 1,
323
                     INIT_VLC_USE_NEW_STATIC);
324
        }
325
        run7_vlc.table = run7_vlc_table,
326
        run7_vlc.table_allocated = run7_vlc_table_size;
327
        init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
328
                 &run_len [6][0], 1, 1,
329
                 &run_bits[6][0], 1, 1,
330
                 INIT_VLC_USE_NEW_STATIC);
331

    
332
        init_cavlc_level_tab();
333
    }
334
}
335

    
336
/**
337
 *
338
 */
339
static inline int get_level_prefix(GetBitContext *gb){
340
    unsigned int buf;
341
    int log;
342

    
343
    OPEN_READER(re, gb);
344
    UPDATE_CACHE(re, gb);
345
    buf=GET_CACHE(re, gb);
346

    
347
    log= 32 - av_log2(buf);
348
#ifdef TRACE
349
    print_bin(buf>>(32-log), log);
350
    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__);
351
#endif
352

    
353
    LAST_SKIP_BITS(re, gb, log);
354
    CLOSE_READER(re, gb);
355

    
356
    return log-1;
357
}
358

    
359
/**
360
 * decodes a residual block.
361
 * @param n block index
362
 * @param scantable scantable
363
 * @param max_coeff number of coefficients in the block
364
 * @return <0 if an error occurred
365
 */
366
static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
367
    MpegEncContext * const s = &h->s;
368
    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};
369
    int level[16];
370
    int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
371

    
372
    //FIXME put trailing_onex into the context
373

    
374
    if(n == CHROMA_DC_BLOCK_INDEX){
375
        coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
376
        total_coeff= coeff_token>>2;
377
    }else{
378
        if(n == LUMA_DC_BLOCK_INDEX){
379
            total_coeff= pred_non_zero_count(h, 0);
380
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
381
            total_coeff= coeff_token>>2;
382
        }else{
383
            total_coeff= pred_non_zero_count(h, n);
384
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
385
            total_coeff= coeff_token>>2;
386
            h->non_zero_count_cache[ scan8[n] ]= total_coeff;
387
        }
388
    }
389

    
390
    //FIXME set last_non_zero?
391

    
392
    if(total_coeff==0)
393
        return 0;
394
    if(total_coeff > (unsigned)max_coeff) {
395
        av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff);
396
        return -1;
397
    }
398

    
399
    trailing_ones= coeff_token&3;
400
    tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
401
    assert(total_coeff<=16);
402

    
403
    i = show_bits(gb, 3);
404
    skip_bits(gb, trailing_ones);
405
    level[0] = 1-((i&4)>>1);
406
    level[1] = 1-((i&2)   );
407
    level[2] = 1-((i&1)<<1);
408

    
409
    if(trailing_ones<total_coeff) {
410
        int mask, prefix;
411
        int suffix_length = total_coeff > 10 & trailing_ones < 3;
412
        int bitsi= show_bits(gb, LEVEL_TAB_BITS);
413
        int level_code= cavlc_level_tab[suffix_length][bitsi][0];
414

    
415
        skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
416
        if(level_code >= 100){
417
            prefix= level_code - 100;
418
            if(prefix == LEVEL_TAB_BITS)
419
                prefix += get_level_prefix(gb);
420

    
421
            //first coefficient has suffix_length equal to 0 or 1
422
            if(prefix<14){ //FIXME try to build a large unified VLC table for all this
423
                if(suffix_length)
424
                    level_code= (prefix<<1) + get_bits1(gb); //part
425
                else
426
                    level_code= prefix; //part
427
            }else if(prefix==14){
428
                if(suffix_length)
429
                    level_code= (prefix<<1) + get_bits1(gb); //part
430
                else
431
                    level_code= prefix + get_bits(gb, 4); //part
432
            }else{
433
                level_code= 30 + get_bits(gb, prefix-3); //part
434
                if(prefix>=16)
435
                    level_code += (1<<(prefix-3))-4096;
436
            }
437

    
438
            if(trailing_ones < 3) level_code += 2;
439

    
440
            suffix_length = 2;
441
            mask= -(level_code&1);
442
            level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
443
        }else{
444
            level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
445

    
446
            suffix_length = 1 + (level_code + 3U > 6U);
447
            level[trailing_ones]= level_code;
448
        }
449

    
450
        //remaining coefficients have suffix_length > 0
451
        for(i=trailing_ones+1;i<total_coeff;i++) {
452
            static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
453
            int bitsi= show_bits(gb, LEVEL_TAB_BITS);
454
            level_code= cavlc_level_tab[suffix_length][bitsi][0];
455

    
456
            skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
457
            if(level_code >= 100){
458
                prefix= level_code - 100;
459
                if(prefix == LEVEL_TAB_BITS){
460
                    prefix += get_level_prefix(gb);
461
                }
462
                if(prefix<15){
463
                    level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
464
                }else{
465
                    level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
466
                    if(prefix>=16)
467
                        level_code += (1<<(prefix-3))-4096;
468
                }
469
                mask= -(level_code&1);
470
                level_code= (((2+level_code)>>1) ^ mask) - mask;
471
            }
472
            level[i]= level_code;
473
            suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
474
        }
475
    }
476

    
477
    if(total_coeff == max_coeff)
478
        zeros_left=0;
479
    else{
480
        if(n == CHROMA_DC_BLOCK_INDEX)
481
            zeros_left= get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[ total_coeff ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
482
        else
483
            zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
484
    }
485

    
486
    coeff_num = zeros_left + total_coeff - 1;
487
    j = scantable[coeff_num];
488
    if(n > 24){
489
        block[j] = level[0];
490
        for(i=1;i<total_coeff;i++) {
491
            if(zeros_left <= 0)
492
                run_before = 0;
493
            else if(zeros_left < 7){
494
                run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
495
            }else{
496
                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
497
            }
498
            zeros_left -= run_before;
499
            coeff_num -= 1 + run_before;
500
            j= scantable[ coeff_num ];
501

    
502
            block[j]= level[i];
503
        }
504
    }else{
505
        block[j] = (level[0] * qmul[j] + 32)>>6;
506
        for(i=1;i<total_coeff;i++) {
507
            if(zeros_left <= 0)
508
                run_before = 0;
509
            else if(zeros_left < 7){
510
                run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
511
            }else{
512
                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
513
            }
514
            zeros_left -= run_before;
515
            coeff_num -= 1 + run_before;
516
            j= scantable[ coeff_num ];
517

    
518
            block[j]= (level[i] * qmul[j] + 32)>>6;
519
        }
520
    }
521

    
522
    if(zeros_left<0){
523
        av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
524
        return -1;
525
    }
526

    
527
    return 0;
528
}
529

    
530
int ff_h264_decode_mb_cavlc(H264Context *h){
531
    MpegEncContext * const s = &h->s;
532
    int mb_xy;
533
    int partition_count;
534
    unsigned int mb_type, cbp;
535
    int dct8x8_allowed= h->pps.transform_8x8_mode;
536

    
537
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
538

    
539
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
540
    cbp = 0; /* avoid warning. FIXME: find a solution without slowing
541
                down the code */
542
    if(h->slice_type_nos != FF_I_TYPE){
543
        if(s->mb_skip_run==-1)
544
            s->mb_skip_run= get_ue_golomb(&s->gb);
545

    
546
        if (s->mb_skip_run--) {
547
            if(FRAME_MBAFF && (s->mb_y&1) == 0){
548
                if(s->mb_skip_run==0)
549
                    h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
550
            }
551
            decode_mb_skip(h);
552
            return 0;
553
        }
554
    }
555
    if(FRAME_MBAFF){
556
        if( (s->mb_y&1) == 0 )
557
            h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
558
    }
559

    
560
    h->prev_mb_skipped= 0;
561

    
562
    mb_type= get_ue_golomb(&s->gb);
563
    if(h->slice_type_nos == FF_B_TYPE){
564
        if(mb_type < 23){
565
            partition_count= b_mb_type_info[mb_type].partition_count;
566
            mb_type=         b_mb_type_info[mb_type].type;
567
        }else{
568
            mb_type -= 23;
569
            goto decode_intra_mb;
570
        }
571
    }else if(h->slice_type_nos == FF_P_TYPE){
572
        if(mb_type < 5){
573
            partition_count= p_mb_type_info[mb_type].partition_count;
574
            mb_type=         p_mb_type_info[mb_type].type;
575
        }else{
576
            mb_type -= 5;
577
            goto decode_intra_mb;
578
        }
579
    }else{
580
       assert(h->slice_type_nos == FF_I_TYPE);
581
        if(h->slice_type == FF_SI_TYPE && mb_type)
582
            mb_type--;
583
decode_intra_mb:
584
        if(mb_type > 25){
585
            av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
586
            return -1;
587
        }
588
        partition_count=0;
589
        cbp= i_mb_type_info[mb_type].cbp;
590
        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
591
        mb_type= i_mb_type_info[mb_type].type;
592
    }
593

    
594
    if(MB_FIELD)
595
        mb_type |= MB_TYPE_INTERLACED;
596

    
597
    h->slice_table[ mb_xy ]= h->slice_num;
598

    
599
    if(IS_INTRA_PCM(mb_type)){
600
        unsigned int x;
601

    
602
        // We assume these blocks are very rare so we do not optimize it.
603
        align_get_bits(&s->gb);
604

    
605
        // The pixels are stored in the same order as levels in h->mb array.
606
        for(x=0; x < (CHROMA ? 384 : 256); x++){
607
            ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
608
        }
609

    
610
        // In deblocking, the quantizer is 0
611
        s->current_picture.qscale_table[mb_xy]= 0;
612
        // All coeffs are present
613
        memset(h->non_zero_count[mb_xy], 16, 32);
614

    
615
        s->current_picture.mb_type[mb_xy]= mb_type;
616
        return 0;
617
    }
618

    
619
    if(MB_MBAFF){
620
        h->ref_count[0] <<= 1;
621
        h->ref_count[1] <<= 1;
622
    }
623

    
624
    fill_decode_neighbors(h, mb_type);
625
    fill_decode_caches(h, mb_type);
626

    
627
    //mb_pred
628
    if(IS_INTRA(mb_type)){
629
        int pred_mode;
630
//            init_top_left_availability(h);
631
        if(IS_INTRA4x4(mb_type)){
632
            int i;
633
            int di = 1;
634
            if(dct8x8_allowed && get_bits1(&s->gb)){
635
                mb_type |= MB_TYPE_8x8DCT;
636
                di = 4;
637
            }
638

    
639
//                fill_intra4x4_pred_table(h);
640
            for(i=0; i<16; i+=di){
641
                int mode= pred_intra_mode(h, i);
642

    
643
                if(!get_bits1(&s->gb)){
644
                    const int rem_mode= get_bits(&s->gb, 3);
645
                    mode = rem_mode + (rem_mode >= mode);
646
                }
647

    
648
                if(di==4)
649
                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
650
                else
651
                    h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
652
            }
653
            ff_h264_write_back_intra_pred_mode(h);
654
            if( ff_h264_check_intra4x4_pred_mode(h) < 0)
655
                return -1;
656
        }else{
657
            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode);
658
            if(h->intra16x16_pred_mode < 0)
659
                return -1;
660
        }
661
        if(CHROMA){
662
            pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb));
663
            if(pred_mode < 0)
664
                return -1;
665
            h->chroma_pred_mode= pred_mode;
666
        }
667
    }else if(partition_count==4){
668
        int i, j, sub_partition_count[4], list, ref[2][4];
669

    
670
        if(h->slice_type_nos == FF_B_TYPE){
671
            for(i=0; i<4; i++){
672
                h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
673
                if(h->sub_mb_type[i] >=13){
674
                    av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
675
                    return -1;
676
                }
677
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
678
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
679
            }
680
            if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
681
                ff_h264_pred_direct_motion(h, &mb_type);
682
                h->ref_cache[0][scan8[4]] =
683
                h->ref_cache[1][scan8[4]] =
684
                h->ref_cache[0][scan8[12]] =
685
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
686
            }
687
        }else{
688
            assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ?
689
            for(i=0; i<4; i++){
690
                h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
691
                if(h->sub_mb_type[i] >=4){
692
                    av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
693
                    return -1;
694
                }
695
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
696
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
697
            }
698
        }
699

    
700
        for(list=0; list<h->list_count; list++){
701
            int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
702
            for(i=0; i<4; i++){
703
                if(IS_DIRECT(h->sub_mb_type[i])) continue;
704
                if(IS_DIR(h->sub_mb_type[i], 0, list)){
705
                    unsigned int tmp;
706
                    if(ref_count == 1){
707
                        tmp= 0;
708
                    }else if(ref_count == 2){
709
                        tmp= get_bits1(&s->gb)^1;
710
                    }else{
711
                        tmp= get_ue_golomb_31(&s->gb);
712
                        if(tmp>=ref_count){
713
                            av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
714
                            return -1;
715
                        }
716
                    }
717
                    ref[list][i]= tmp;
718
                }else{
719
                 //FIXME
720
                    ref[list][i] = -1;
721
                }
722
            }
723
        }
724

    
725
        if(dct8x8_allowed)
726
            dct8x8_allowed = get_dct8x8_allowed(h);
727

    
728
        for(list=0; list<h->list_count; list++){
729
            for(i=0; i<4; i++){
730
                if(IS_DIRECT(h->sub_mb_type[i])) {
731
                    h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
732
                    continue;
733
                }
734
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
735
                h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
736

    
737
                if(IS_DIR(h->sub_mb_type[i], 0, list)){
738
                    const int sub_mb_type= h->sub_mb_type[i];
739
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
740
                    for(j=0; j<sub_partition_count[i]; j++){
741
                        int mx, my;
742
                        const int index= 4*i + block_width*j;
743
                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
744
                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
745
                        mx += get_se_golomb(&s->gb);
746
                        my += get_se_golomb(&s->gb);
747
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
748

    
749
                        if(IS_SUB_8X8(sub_mb_type)){
750
                            mv_cache[ 1 ][0]=
751
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
752
                            mv_cache[ 1 ][1]=
753
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
754
                        }else if(IS_SUB_8X4(sub_mb_type)){
755
                            mv_cache[ 1 ][0]= mx;
756
                            mv_cache[ 1 ][1]= my;
757
                        }else if(IS_SUB_4X8(sub_mb_type)){
758
                            mv_cache[ 8 ][0]= mx;
759
                            mv_cache[ 8 ][1]= my;
760
                        }
761
                        mv_cache[ 0 ][0]= mx;
762
                        mv_cache[ 0 ][1]= my;
763
                    }
764
                }else{
765
                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
766
                    p[0] = p[1]=
767
                    p[8] = p[9]= 0;
768
                }
769
            }
770
        }
771
    }else if(IS_DIRECT(mb_type)){
772
        ff_h264_pred_direct_motion(h, &mb_type);
773
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
774
    }else{
775
        int list, mx, my, i;
776
         //FIXME we should set ref_idx_l? to 0 if we use that later ...
777
        if(IS_16X16(mb_type)){
778
            for(list=0; list<h->list_count; list++){
779
                    unsigned int val;
780
                    if(IS_DIR(mb_type, 0, list)){
781
                        if(h->ref_count[list]==1){
782
                            val= 0;
783
                        }else if(h->ref_count[list]==2){
784
                            val= get_bits1(&s->gb)^1;
785
                        }else{
786
                            val= get_ue_golomb_31(&s->gb);
787
                            if(val >= h->ref_count[list]){
788
                                av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
789
                                return -1;
790
                            }
791
                        }
792
                    }else
793
                        val= LIST_NOT_USED&0xFF;
794
                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
795
            }
796
            for(list=0; list<h->list_count; list++){
797
                unsigned int val;
798
                if(IS_DIR(mb_type, 0, list)){
799
                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
800
                    mx += get_se_golomb(&s->gb);
801
                    my += get_se_golomb(&s->gb);
802
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
803

    
804
                    val= pack16to32(mx,my);
805
                }else
806
                    val=0;
807
                fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4);
808
            }
809
        }
810
        else if(IS_16X8(mb_type)){
811
            for(list=0; list<h->list_count; list++){
812
                    for(i=0; i<2; i++){
813
                        unsigned int val;
814
                        if(IS_DIR(mb_type, i, list)){
815
                            if(h->ref_count[list] == 1){
816
                                val= 0;
817
                            }else if(h->ref_count[list] == 2){
818
                                val= get_bits1(&s->gb)^1;
819
                            }else{
820
                                val= get_ue_golomb_31(&s->gb);
821
                                if(val >= h->ref_count[list]){
822
                                    av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
823
                                    return -1;
824
                                }
825
                            }
826
                        }else
827
                            val= LIST_NOT_USED&0xFF;
828
                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
829
                    }
830
            }
831
            for(list=0; list<h->list_count; list++){
832
                for(i=0; i<2; i++){
833
                    unsigned int val;
834
                    if(IS_DIR(mb_type, i, list)){
835
                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
836
                        mx += get_se_golomb(&s->gb);
837
                        my += get_se_golomb(&s->gb);
838
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
839

    
840
                        val= pack16to32(mx,my);
841
                    }else
842
                        val=0;
843
                    fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
844
                }
845
            }
846
        }else{
847
            assert(IS_8X16(mb_type));
848
            for(list=0; list<h->list_count; list++){
849
                    for(i=0; i<2; i++){
850
                        unsigned int val;
851
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
852
                            if(h->ref_count[list]==1){
853
                                val= 0;
854
                            }else if(h->ref_count[list]==2){
855
                                val= get_bits1(&s->gb)^1;
856
                            }else{
857
                                val= get_ue_golomb_31(&s->gb);
858
                                if(val >= h->ref_count[list]){
859
                                    av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
860
                                    return -1;
861
                                }
862
                            }
863
                        }else
864
                            val= LIST_NOT_USED&0xFF;
865
                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
866
                    }
867
            }
868
            for(list=0; list<h->list_count; list++){
869
                for(i=0; i<2; i++){
870
                    unsigned int val;
871
                    if(IS_DIR(mb_type, i, list)){
872
                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
873
                        mx += get_se_golomb(&s->gb);
874
                        my += get_se_golomb(&s->gb);
875
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
876

    
877
                        val= pack16to32(mx,my);
878
                    }else
879
                        val=0;
880
                    fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
881
                }
882
            }
883
        }
884
    }
885

    
886
    if(IS_INTER(mb_type))
887
        write_back_motion(h, mb_type);
888

    
889
    if(!IS_INTRA16x16(mb_type)){
890
        cbp= get_ue_golomb(&s->gb);
891
        if(cbp > 47){
892
            av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
893
            return -1;
894
        }
895

    
896
        if(CHROMA){
897
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
898
            else                     cbp= golomb_to_inter_cbp   [cbp];
899
        }else{
900
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
901
            else                     cbp= golomb_to_inter_cbp_gray[cbp];
902
        }
903
    }
904

    
905
    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
906
        mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb);
907
    }
908
    h->cbp=
909
    h->cbp_table[mb_xy]= cbp;
910
    s->current_picture.mb_type[mb_xy]= mb_type;
911

    
912
    if(cbp || IS_INTRA16x16(mb_type)){
913
        int i8x8, i4x4, chroma_idx;
914
        int dquant;
915
        GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
916
        const uint8_t *scan, *scan8x8, *dc_scan;
917

    
918
        if(IS_INTERLACED(mb_type)){
919
            scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
920
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
921
            dc_scan= luma_dc_field_scan;
922
        }else{
923
            scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
924
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
925
            dc_scan= luma_dc_zigzag_scan;
926
        }
927

    
928
        dquant= get_se_golomb(&s->gb);
929

    
930
        s->qscale += dquant;
931

    
932
        if(((unsigned)s->qscale) > 51){
933
            if(s->qscale<0) s->qscale+= 52;
934
            else            s->qscale-= 52;
935
            if(((unsigned)s->qscale) > 51){
936
                av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
937
                return -1;
938
            }
939
        }
940

    
941
        h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
942
        h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
943
        if(IS_INTRA16x16(mb_type)){
944
            if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
945
                return -1; //FIXME continue if partitioned and other return -1 too
946
            }
947

    
948
            assert((cbp&15) == 0 || (cbp&15) == 15);
949

    
950
            if(cbp&15){
951
                for(i8x8=0; i8x8<4; i8x8++){
952
                    for(i4x4=0; i4x4<4; i4x4++){
953
                        const int index= i4x4 + 4*i8x8;
954
                        if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
955
                            return -1;
956
                        }
957
                    }
958
                }
959
            }else{
960
                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
961
            }
962
        }else{
963
            for(i8x8=0; i8x8<4; i8x8++){
964
                if(cbp & (1<<i8x8)){
965
                    if(IS_8x8DCT(mb_type)){
966
                        DCTELEM *buf = &h->mb[64*i8x8];
967
                        uint8_t *nnz;
968
                        for(i4x4=0; i4x4<4; i4x4++){
969
                            if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
970
                                                h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
971
                                return -1;
972
                        }
973
                        nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
974
                        nnz[0] += nnz[1] + nnz[8] + nnz[9];
975
                    }else{
976
                        for(i4x4=0; i4x4<4; i4x4++){
977
                            const int index= i4x4 + 4*i8x8;
978

    
979
                            if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
980
                                return -1;
981
                            }
982
                        }
983
                    }
984
                }else{
985
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
986
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
987
                }
988
            }
989
        }
990

    
991
        if(cbp&0x30){
992
            for(chroma_idx=0; chroma_idx<2; chroma_idx++)
993
                if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
994
                    return -1;
995
                }
996
        }
997

    
998
        if(cbp&0x20){
999
            for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1000
                const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1001
                for(i4x4=0; i4x4<4; i4x4++){
1002
                    const int index= 16 + 4*chroma_idx + i4x4;
1003
                    if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){
1004
                        return -1;
1005
                    }
1006
                }
1007
            }
1008
        }else{
1009
            uint8_t * const nnz= &h->non_zero_count_cache[0];
1010
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1011
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1012
        }
1013
    }else{
1014
        uint8_t * const nnz= &h->non_zero_count_cache[0];
1015
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1016
        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1017
        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1018
    }
1019
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1020
    write_back_non_zero_count(h);
1021

    
1022
    if(MB_MBAFF){
1023
        h->ref_count[0] >>= 1;
1024
        h->ref_count[1] >>= 1;
1025
    }
1026

    
1027
    return 0;
1028
}
1029