Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cavlc.c @ 2b3649f6

History | View | Annotate | Download (37.3 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
            if(trailing_ones < 3) level_code += (level_code>>31)|1;
445

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

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

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

    
476
            if(suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length])
477
                suffix_length++;
478
        }
479
    }
480

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

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

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

    
522
            block[j]= (level[i] * qmul[j] + 32)>>6;
523
        }
524
    }
525

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

    
531
    return 0;
532
}
533

    
534
int ff_h264_decode_mb_cavlc(H264Context *h){
535
    MpegEncContext * const s = &h->s;
536
    int mb_xy;
537
    int partition_count;
538
    unsigned int mb_type, cbp;
539
    int dct8x8_allowed= h->pps.transform_8x8_mode;
540

    
541
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
542

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

    
550
        if (s->mb_skip_run--) {
551
            if(FRAME_MBAFF && (s->mb_y&1) == 0){
552
                if(s->mb_skip_run==0)
553
                    h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
554
                else
555
                    predict_field_decoding_flag(h);
556
            }
557
            decode_mb_skip(h);
558
            return 0;
559
        }
560
    }
561
    if(FRAME_MBAFF){
562
        if( (s->mb_y&1) == 0 )
563
            h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
564
    }
565

    
566
    h->prev_mb_skipped= 0;
567

    
568
    mb_type= get_ue_golomb(&s->gb);
569
    if(h->slice_type_nos == FF_B_TYPE){
570
        if(mb_type < 23){
571
            partition_count= b_mb_type_info[mb_type].partition_count;
572
            mb_type=         b_mb_type_info[mb_type].type;
573
        }else{
574
            mb_type -= 23;
575
            goto decode_intra_mb;
576
        }
577
    }else if(h->slice_type_nos == FF_P_TYPE){
578
        if(mb_type < 5){
579
            partition_count= p_mb_type_info[mb_type].partition_count;
580
            mb_type=         p_mb_type_info[mb_type].type;
581
        }else{
582
            mb_type -= 5;
583
            goto decode_intra_mb;
584
        }
585
    }else{
586
       assert(h->slice_type_nos == FF_I_TYPE);
587
        if(h->slice_type == FF_SI_TYPE && mb_type)
588
            mb_type--;
589
decode_intra_mb:
590
        if(mb_type > 25){
591
            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);
592
            return -1;
593
        }
594
        partition_count=0;
595
        cbp= i_mb_type_info[mb_type].cbp;
596
        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
597
        mb_type= i_mb_type_info[mb_type].type;
598
    }
599

    
600
    if(MB_FIELD)
601
        mb_type |= MB_TYPE_INTERLACED;
602

    
603
    h->slice_table[ mb_xy ]= h->slice_num;
604

    
605
    if(IS_INTRA_PCM(mb_type)){
606
        unsigned int x;
607

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

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

    
616
        // In deblocking, the quantizer is 0
617
        s->current_picture.qscale_table[mb_xy]= 0;
618
        // All coeffs are present
619
        memset(h->non_zero_count[mb_xy], 16, 32);
620

    
621
        s->current_picture.mb_type[mb_xy]= mb_type;
622
        return 0;
623
    }
624

    
625
    if(MB_MBAFF){
626
        h->ref_count[0] <<= 1;
627
        h->ref_count[1] <<= 1;
628
    }
629

    
630
    fill_decode_caches(h, mb_type);
631

    
632
    //mb_pred
633
    if(IS_INTRA(mb_type)){
634
        int pred_mode;
635
//            init_top_left_availability(h);
636
        if(IS_INTRA4x4(mb_type)){
637
            int i;
638
            int di = 1;
639
            if(dct8x8_allowed && get_bits1(&s->gb)){
640
                mb_type |= MB_TYPE_8x8DCT;
641
                di = 4;
642
            }
643

    
644
//                fill_intra4x4_pred_table(h);
645
            for(i=0; i<16; i+=di){
646
                int mode= pred_intra_mode(h, i);
647

    
648
                if(!get_bits1(&s->gb)){
649
                    const int rem_mode= get_bits(&s->gb, 3);
650
                    mode = rem_mode + (rem_mode >= mode);
651
                }
652

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

    
675
        if(h->slice_type_nos == FF_B_TYPE){
676
            for(i=0; i<4; i++){
677
                h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
678
                if(h->sub_mb_type[i] >=13){
679
                    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);
680
                    return -1;
681
                }
682
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
683
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
684
            }
685
            if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
686
               || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
687
                ff_h264_pred_direct_motion(h, &mb_type);
688
                h->ref_cache[0][scan8[4]] =
689
                h->ref_cache[1][scan8[4]] =
690
                h->ref_cache[0][scan8[12]] =
691
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
692
            }
693
        }else{
694
            assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ?
695
            for(i=0; i<4; i++){
696
                h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
697
                if(h->sub_mb_type[i] >=4){
698
                    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);
699
                    return -1;
700
                }
701
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
702
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
703
            }
704
        }
705

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

    
731
        if(dct8x8_allowed)
732
            dct8x8_allowed = get_dct8x8_allowed(h);
733

    
734
        for(list=0; list<h->list_count; list++){
735
            for(i=0; i<4; i++){
736
                if(IS_DIRECT(h->sub_mb_type[i])) {
737
                    h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
738
                    continue;
739
                }
740
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
741
                h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
742

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

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

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

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

    
883
                        val= pack16to32(mx,my);
884
                    }else
885
                        val=0;
886
                    fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
887
                }
888
            }
889
        }
890
    }
891

    
892
    if(IS_INTER(mb_type))
893
        write_back_motion(h, mb_type);
894

    
895
    if(!IS_INTRA16x16(mb_type)){
896
        cbp= get_ue_golomb(&s->gb);
897
        if(cbp > 47){
898
            av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
899
            return -1;
900
        }
901

    
902
        if(CHROMA){
903
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
904
            else                     cbp= golomb_to_inter_cbp   [cbp];
905
        }else{
906
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
907
            else                     cbp= golomb_to_inter_cbp_gray[cbp];
908
        }
909
    }
910

    
911
    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
912
        if(get_bits1(&s->gb)){
913
            mb_type |= MB_TYPE_8x8DCT;
914
        }
915
    }
916
    h->cbp=
917
    h->cbp_table[mb_xy]= cbp;
918
    s->current_picture.mb_type[mb_xy]= mb_type;
919

    
920
    if(cbp || IS_INTRA16x16(mb_type)){
921
        int i8x8, i4x4, chroma_idx;
922
        int dquant;
923
        GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
924
        const uint8_t *scan, *scan8x8, *dc_scan;
925

    
926
//        fill_non_zero_count_cache(h);
927

    
928
        if(IS_INTERLACED(mb_type)){
929
            scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
930
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
931
            dc_scan= luma_dc_field_scan;
932
        }else{
933
            scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
934
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
935
            dc_scan= luma_dc_zigzag_scan;
936
        }
937

    
938
        dquant= get_se_golomb(&s->gb);
939

    
940
        if( dquant > 25 || dquant < -26 ){
941
            av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
942
            return -1;
943
        }
944

    
945
        s->qscale += dquant;
946
        if(((unsigned)s->qscale) > 51){
947
            if(s->qscale<0) s->qscale+= 52;
948
            else            s->qscale-= 52;
949
        }
950

    
951
        h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
952
        h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
953
        if(IS_INTRA16x16(mb_type)){
954
            if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
955
                return -1; //FIXME continue if partitioned and other return -1 too
956
            }
957

    
958
            assert((cbp&15) == 0 || (cbp&15) == 15);
959

    
960
            if(cbp&15){
961
                for(i8x8=0; i8x8<4; i8x8++){
962
                    for(i4x4=0; i4x4<4; i4x4++){
963
                        const int index= i4x4 + 4*i8x8;
964
                        if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
965
                            return -1;
966
                        }
967
                    }
968
                }
969
            }else{
970
                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
971
            }
972
        }else{
973
            for(i8x8=0; i8x8<4; i8x8++){
974
                if(cbp & (1<<i8x8)){
975
                    if(IS_8x8DCT(mb_type)){
976
                        DCTELEM *buf = &h->mb[64*i8x8];
977
                        uint8_t *nnz;
978
                        for(i4x4=0; i4x4<4; i4x4++){
979
                            if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
980
                                                h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
981
                                return -1;
982
                        }
983
                        nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
984
                        nnz[0] += nnz[1] + nnz[8] + nnz[9];
985
                    }else{
986
                        for(i4x4=0; i4x4<4; i4x4++){
987
                            const int index= i4x4 + 4*i8x8;
988

    
989
                            if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
990
                                return -1;
991
                            }
992
                        }
993
                    }
994
                }else{
995
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
996
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
997
                }
998
            }
999
        }
1000

    
1001
        if(cbp&0x30){
1002
            for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1003
                if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
1004
                    return -1;
1005
                }
1006
        }
1007

    
1008
        if(cbp&0x20){
1009
            for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1010
                const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
1011
                for(i4x4=0; i4x4<4; i4x4++){
1012
                    const int index= 16 + 4*chroma_idx + i4x4;
1013
                    if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){
1014
                        return -1;
1015
                    }
1016
                }
1017
            }
1018
        }else{
1019
            uint8_t * const nnz= &h->non_zero_count_cache[0];
1020
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1021
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1022
        }
1023
    }else{
1024
        uint8_t * const nnz= &h->non_zero_count_cache[0];
1025
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1026
        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1027
        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1028
    }
1029
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1030
    write_back_non_zero_count(h);
1031

    
1032
    if(MB_MBAFF){
1033
        h->ref_count[0] >>= 1;
1034
        h->ref_count[1] >>= 1;
1035
    }
1036

    
1037
    return 0;
1038
}
1039