GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vc1.c Lines: 763 940 81.2 %
Date: 2020-08-14 10:39:37 Branches: 409 650 62.9 %

Line Branch Exec Source
1
/*
2
 * VC-1 and WMV3 decoder common code
3
 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4
 * Copyright (c) 2006-2007 Konstantin Shishkov
5
 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6
 *
7
 * This file is part of FFmpeg.
8
 *
9
 * FFmpeg is free software; you can redistribute it and/or
10
 * modify it under the terms of the GNU Lesser General Public
11
 * License as published by the Free Software Foundation; either
12
 * version 2.1 of the License, or (at your option) any later version.
13
 *
14
 * FFmpeg is distributed in the hope that it will be useful,
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
 * Lesser General Public License for more details.
18
 *
19
 * You should have received a copy of the GNU Lesser General Public
20
 * License along with FFmpeg; if not, write to the Free Software
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
 */
23
24
/**
25
 * @file
26
 * VC-1 and WMV3 decoder common code
27
 */
28
29
#include "libavutil/attributes.h"
30
#include "internal.h"
31
#include "avcodec.h"
32
#include "mpegvideo.h"
33
#include "vc1.h"
34
#include "vc1data.h"
35
#include "wmv2data.h"
36
#include "unary.h"
37
#include "simple_idct.h"
38
39
/***********************************************************************/
40
/**
41
 * @name VC-1 Bitplane decoding
42
 * @see 8.7, p56
43
 * @{
44
 */
45
46
/** Decode rows by checking if they are skipped
47
 * @param plane Buffer to store decoded bits
48
 * @param[in] width Width of this buffer
49
 * @param[in] height Height of this buffer
50
 * @param[in] stride of this buffer
51
 */
52
192
static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
53
                           GetBitContext *gb)
54
{
55
    int x, y;
56
57
767
    for (y = 0; y < height; y++) {
58
575
        if (!get_bits1(gb)) //rowskip
59
277
            memset(plane, 0, width);
60
        else
61
7569
            for (x = 0; x < width; x++)
62
7271
                plane[x] = get_bits1(gb);
63
575
        plane += stride;
64
    }
65
192
}
66
67
/** Decode columns by checking if they are skipped
68
 * @param plane Buffer to store decoded bits
69
 * @param[in] width Width of this buffer
70
 * @param[in] height Height of this buffer
71
 * @param[in] stride of this buffer
72
 * @todo FIXME: Optimize
73
 */
74
117
static void decode_colskip(uint8_t* plane, int width, int height, int stride,
75
                           GetBitContext *gb)
76
{
77
    int x, y;
78
79
853
    for (x = 0; x < width; x++) {
80
736
        if (!get_bits1(gb)) //colskip
81
9031
            for (y = 0; y < height; y++)
82
8780
                plane[y*stride] = 0;
83
        else
84
6765
            for (y = 0; y < height; y++)
85
6280
                plane[y*stride] = get_bits1(gb);
86
736
        plane ++;
87
    }
88
117
}
89
90
/** Decode a bitplane's bits
91
 * @param data bitplane where to store the decode bits
92
 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
93
 * @param v VC-1 context for bit reading and logging
94
 * @return Status
95
 * @todo FIXME: Optimize
96
 */
97
1098
static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
98
{
99
1098
    GetBitContext *gb = &v->s.gb;
100
101
    int imode, x, y, code, offset;
102
1098
    uint8_t invert, *planep = data;
103
    int width, height, stride;
104
105
1098
    width  = v->s.mb_width;
106
1098
    height = v->s.mb_height >> v->field_mode;
107
1098
    stride = v->s.mb_stride;
108
1098
    invert = get_bits1(gb);
109
1098
    imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
110
111
1098
    *raw_flag = 0;
112

1098
    switch (imode) {
113
632
    case IMODE_RAW:
114
        //Data is actually read in the MB layer (same for all tests == "raw")
115
632
        *raw_flag = 1; //invert ignored
116
632
        return invert;
117
164
    case IMODE_DIFF2:
118
    case IMODE_NORM2:
119
164
        if ((height * width) & 1) {
120
112
            *planep++ = get_bits1(gb);
121
112
            y = offset = 1;
122
112
            if (offset == width) {
123
                offset = 0;
124
                planep += stride - width;
125
            }
126
        }
127
        else
128
52
            y = offset = 0;
129
        // decode bitplane as one long line
130
41886
        for (; y < height * width; y += 2) {
131
41722
            code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
132
41722
            *planep++ = code & 1;
133
41722
            offset++;
134
41722
            if (offset == width) {
135
529
                offset  = 0;
136
529
                planep += stride - width;
137
            }
138
41722
            *planep++ = code >> 1;
139
41722
            offset++;
140
41722
            if (offset == width) {
141
1417
                offset  = 0;
142
1417
                planep += stride - width;
143
            }
144
        }
145
164
        break;
146
246
    case IMODE_DIFF6:
147
    case IMODE_NORM6:
148

246
        if (!(height % 3) && (width % 3)) { // use 2x3 decoding
149
92
            for (y = 0; y < height; y += 3) {
150
750
                for (x = width & 1; x < width; x += 2) {
151
675
                    code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
152
675
                    if (code < 0) {
153
                        av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
154
                        return -1;
155
                    }
156
675
                    planep[x + 0]              = (code >> 0) & 1;
157
675
                    planep[x + 1]              = (code >> 1) & 1;
158
675
                    planep[x + 0 + stride]     = (code >> 2) & 1;
159
675
                    planep[x + 1 + stride]     = (code >> 3) & 1;
160
675
                    planep[x + 0 + stride * 2] = (code >> 4) & 1;
161
675
                    planep[x + 1 + stride * 2] = (code >> 5) & 1;
162
                }
163
75
                planep += stride * 3;
164
            }
165
17
            if (width & 1)
166
5
                decode_colskip(data, 1, height, stride, &v->s.gb);
167
        } else { // 3x2
168
229
            planep += (height & 1) * stride;
169
2190
            for (y = height & 1; y < height; y += 2) {
170
32856
                for (x = width % 3; x < width; x += 3) {
171
30895
                    code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
172
30895
                    if (code < 0) {
173
                        av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
174
                        return -1;
175
                    }
176
30895
                    planep[x + 0]          = (code >> 0) & 1;
177
30895
                    planep[x + 1]          = (code >> 1) & 1;
178
30895
                    planep[x + 2]          = (code >> 2) & 1;
179
30895
                    planep[x + 0 + stride] = (code >> 3) & 1;
180
30895
                    planep[x + 1 + stride] = (code >> 4) & 1;
181
30895
                    planep[x + 2 + stride] = (code >> 5) & 1;
182
                }
183
1961
                planep += stride * 2;
184
            }
185
229
            x = width % 3;
186
229
            if (x)
187
89
                decode_colskip(data,             x, height, stride, &v->s.gb);
188
229
            if (height & 1)
189
159
                decode_rowskip(data + x, width - x,      1, stride, &v->s.gb);
190
        }
191
246
        break;
192
33
    case IMODE_ROWSKIP:
193
33
        decode_rowskip(data, width, height, stride, &v->s.gb);
194
33
        break;
195
23
    case IMODE_COLSKIP:
196
23
        decode_colskip(data, width, height, stride, &v->s.gb);
197
23
        break;
198
    default:
199
        break;
200
    }
201
202
    /* Applying diff operator */
203

466
    if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
204
122
        planep = data;
205
122
        planep[0] ^= invert;
206
3773
        for (x = 1; x < width; x++)
207
3651
            planep[x] ^= planep[x-1];
208
1937
        for (y = 1; y < height; y++) {
209
1815
            planep += stride;
210
1815
            planep[0] ^= planep[-stride];
211
96919
            for (x = 1; x < width; x++) {
212
95104
                if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
213
68287
                else                                 planep[x] ^= planep[x-1];
214
            }
215
        }
216
344
    } else if (invert) {
217
41
        planep = data;
218
13395
        for (x = 0; x < stride * height; x++)
219
13354
            planep[x] = !planep[x]; //FIXME stride
220
    }
221
466
    return (imode << 1) + invert;
222
}
223
224
/** @} */ //Bitplane group
225
226
/***********************************************************************/
227
/** VOP Dquant decoding
228
 * @param v VC-1 Context
229
 */
230
146
static int vop_dquant_decoding(VC1Context *v)
231
{
232
146
    GetBitContext *gb = &v->s.gb;
233
    int pqdiff;
234
235
    //variable size
236
146
    if (v->dquant != 2) {
237
146
        v->dquantfrm = get_bits1(gb);
238
146
        if (!v->dquantfrm)
239
65
            return 0;
240
241
81
        v->dqprofile = get_bits(gb, 2);
242
81
        switch (v->dqprofile) {
243
62
        case DQPROFILE_SINGLE_EDGE:
244
        case DQPROFILE_DOUBLE_EDGES:
245
62
            v->dqsbedge = get_bits(gb, 2);
246
62
            break;
247
19
        case DQPROFILE_ALL_MBS:
248
19
            v->dqbilevel = get_bits1(gb);
249
19
            if (!v->dqbilevel) {
250
1
                v->halfpq = 0;
251
1
                return 0;
252
            }
253
        default:
254
18
            break; //Forbidden ?
255
        }
256
    }
257
258
80
    pqdiff = get_bits(gb, 3);
259
80
    if (pqdiff == 7)
260
18
        v->altpq = get_bits(gb, 5);
261
    else
262
62
        v->altpq = v->pq + pqdiff + 1;
263
264
80
    return 0;
265
}
266
267
static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
268
269
/**
270
 * Decode Simple/Main Profiles sequence header
271
 * @see Figure 7-8, p16-17
272
 * @param avctx Codec context
273
 * @param gb GetBit context initialized from Codec context extra_data
274
 * @return Status
275
 */
276
31
int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
277
{
278
31
    av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
279
31
    v->profile = get_bits(gb, 2);
280
31
    if (v->profile == PROFILE_COMPLEX) {
281
        av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
282
    }
283
284
31
    if (v->profile == PROFILE_ADVANCED) {
285
24
        v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
286
24
        v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
287
24
        return decode_sequence_header_adv(v, gb);
288
    } else {
289
7
        v->chromaformat = 1;
290
7
        v->zz_8x4 = ff_wmv2_scantableA;
291
7
        v->zz_4x8 = ff_wmv2_scantableB;
292
7
        v->res_y411   = get_bits1(gb);
293
7
        v->res_sprite = get_bits1(gb);
294
7
        if (v->res_y411) {
295
            av_log(avctx, AV_LOG_ERROR,
296
                   "Old interlaced mode is not supported\n");
297
            return -1;
298
        }
299
    }
300
301
    // (fps-2)/4 (->30)
302
7
    v->frmrtq_postproc = get_bits(gb, 3); //common
303
    // (bitrate-32kbps)/64kbps
304
7
    v->bitrtq_postproc = get_bits(gb, 5); //common
305
7
    v->s.loop_filter   = get_bits1(gb); //common
306

7
    if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
307
        av_log(avctx, AV_LOG_ERROR,
308
               "LOOPFILTER shall not be enabled in Simple Profile\n");
309
    }
310
7
    if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
311
        v->s.loop_filter = 0;
312
313
7
    v->res_x8          = get_bits1(gb); //reserved
314
7
    v->multires        = get_bits1(gb);
315
7
    v->res_fasttx      = get_bits1(gb);
316
7
    if (!v->res_fasttx) {
317
        v->vc1dsp.vc1_inv_trans_8x8    = ff_simple_idct_int16_8bit;
318
        v->vc1dsp.vc1_inv_trans_8x4    = ff_simple_idct84_add;
319
        v->vc1dsp.vc1_inv_trans_4x8    = ff_simple_idct48_add;
320
        v->vc1dsp.vc1_inv_trans_4x4    = ff_simple_idct44_add;
321
        v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_int16_8bit;
322
        v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
323
        v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
324
        v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
325
    }
326
327
7
    v->fastuvmc        = get_bits1(gb); //common
328

7
    if (!v->profile && !v->fastuvmc) {
329
        av_log(avctx, AV_LOG_ERROR,
330
               "FASTUVMC unavailable in Simple Profile\n");
331
        return -1;
332
    }
333
7
    v->extended_mv     = get_bits1(gb); //common
334

7
    if (!v->profile && v->extended_mv) {
335
        av_log(avctx, AV_LOG_ERROR,
336
               "Extended MVs unavailable in Simple Profile\n");
337
        return -1;
338
    }
339
7
    v->dquant          = get_bits(gb, 2); //common
340
7
    v->vstransform     = get_bits1(gb); //common
341
342
7
    v->res_transtab    = get_bits1(gb);
343
7
    if (v->res_transtab) {
344
        av_log(avctx, AV_LOG_ERROR,
345
               "1 for reserved RES_TRANSTAB is forbidden\n");
346
        return -1;
347
    }
348
349
7
    v->overlap         = get_bits1(gb); //common
350
351
7
    v->resync_marker   = get_bits1(gb);
352
7
    v->rangered        = get_bits1(gb);
353

7
    if (v->rangered && v->profile == PROFILE_SIMPLE) {
354
        av_log(avctx, AV_LOG_INFO,
355
               "RANGERED should be set to 0 in Simple Profile\n");
356
    }
357
358
7
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
359
7
    v->quantizer_mode = get_bits(gb, 2); //common
360
361
7
    v->finterpflag = get_bits1(gb); //common
362
363
7
    if (v->res_sprite) {
364
        int w = get_bits(gb, 11);
365
        int h = get_bits(gb, 11);
366
        int ret = ff_set_dimensions(v->s.avctx, w, h);
367
        if (ret < 0) {
368
            av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
369
            return ret;
370
        }
371
        skip_bits(gb, 5); //frame rate
372
        v->res_x8 = get_bits1(gb);
373
        if (get_bits1(gb)) { // something to do with DC VLC selection
374
            av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
375
            return -1;
376
        }
377
        skip_bits(gb, 3); //slice code
378
        v->res_rtm_flag = 0;
379
    } else {
380
7
        v->res_rtm_flag = get_bits1(gb); //reserved
381
    }
382
    //TODO: figure out what they mean (always 0x402F)
383
7
    if (!v->res_fasttx)
384
        skip_bits(gb, 16);
385
7
    av_log(avctx, AV_LOG_DEBUG,
386
           "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
387
           "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
388
           "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
389
           "DQuant=%i, Quantizer mode=%i, Max B-frames=%i\n",
390
           v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
391
           v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
392
           v->rangered, v->vstransform, v->overlap, v->resync_marker,
393
           v->dquant, v->quantizer_mode, avctx->max_b_frames);
394
7
    return 0;
395
}
396
397
24
static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
398
{
399
24
    v->res_rtm_flag = 1;
400
24
    v->level = get_bits(gb, 3);
401
24
    if (v->level >= 5) {
402
        av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
403
    }
404
24
    v->chromaformat = get_bits(gb, 2);
405
24
    if (v->chromaformat != 1) {
406
        av_log(v->s.avctx, AV_LOG_ERROR,
407
               "Only 4:2:0 chroma format supported\n");
408
        return -1;
409
    }
410
411
    // (fps-2)/4 (->30)
412
24
    v->frmrtq_postproc       = get_bits(gb, 3); //common
413
    // (bitrate-32kbps)/64kbps
414
24
    v->bitrtq_postproc       = get_bits(gb, 5); //common
415
24
    v->postprocflag          = get_bits1(gb);   //common
416
417
24
    v->max_coded_width       = (get_bits(gb, 12) + 1) << 1;
418
24
    v->max_coded_height      = (get_bits(gb, 12) + 1) << 1;
419
24
    v->broadcast             = get_bits1(gb);
420
24
    v->interlace             = get_bits1(gb);
421
24
    v->tfcntrflag            = get_bits1(gb);
422
24
    v->finterpflag           = get_bits1(gb);
423
24
    skip_bits1(gb); // reserved
424
425
24
    av_log(v->s.avctx, AV_LOG_DEBUG,
426
           "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
427
           "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
428
           "TFCTRflag=%i, FINTERPflag=%i\n",
429
           v->level, v->frmrtq_postproc, v->bitrtq_postproc,
430
           v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
431
           v->tfcntrflag, v->finterpflag);
432
433
24
    v->psf = get_bits1(gb);
434
24
    if (v->psf) { //PsF, 6.1.13
435
        av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
436
        return -1;
437
    }
438
24
    v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
439
24
    if (get_bits1(gb)) { //Display Info - decoding is not affected by it
440
24
        int w, h, ar = 0;
441
24
        av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
442
24
        w = get_bits(gb, 14) + 1;
443
24
        h = get_bits(gb, 14) + 1;
444
24
        av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
445
24
        if (get_bits1(gb))
446
9
            ar = get_bits(gb, 4);
447

24
        if (ar && ar < 14) {
448
3
            v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
449
21
        } else if (ar == 15) {
450
6
            w = get_bits(gb, 8) + 1;
451
6
            h = get_bits(gb, 8) + 1;
452
6
            v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
453
        } else {
454
15
            if (v->s.avctx->width  > v->max_coded_width ||
455
15
                v->s.avctx->height > v->max_coded_height) {
456
                avpriv_request_sample(v->s.avctx, "Huge resolution");
457
            } else
458
15
                av_reduce(&v->s.avctx->sample_aspect_ratio.num,
459
15
                      &v->s.avctx->sample_aspect_ratio.den,
460
15
                      v->s.avctx->height * w,
461
15
                      v->s.avctx->width * h,
462
                      1 << 30);
463
        }
464
24
        ff_set_sar(v->s.avctx, v->s.avctx->sample_aspect_ratio);
465
24
        av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
466
24
               v->s.avctx->sample_aspect_ratio.num,
467
24
               v->s.avctx->sample_aspect_ratio.den);
468
469
24
        if (get_bits1(gb)) { //framerate stuff
470
9
            if (get_bits1(gb)) {
471
                v->s.avctx->framerate.den = 32;
472
                v->s.avctx->framerate.num = get_bits(gb, 16) + 1;
473
            } else {
474
                int nr, dr;
475
9
                nr = get_bits(gb, 8);
476
9
                dr = get_bits(gb, 4);
477


9
                if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
478
9
                    v->s.avctx->framerate.den = ff_vc1_fps_dr[dr - 1];
479
9
                    v->s.avctx->framerate.num = ff_vc1_fps_nr[nr - 1] * 1000;
480
                }
481
            }
482
9
            if (v->broadcast) { // Pulldown may be present
483
9
                v->s.avctx->ticks_per_frame = 2;
484
            }
485
        }
486
487
24
        if (get_bits1(gb)) {
488
            v->color_prim    = get_bits(gb, 8);
489
            v->transfer_char = get_bits(gb, 8);
490
            v->matrix_coef   = get_bits(gb, 8);
491
        }
492
    }
493
494
24
    v->hrd_param_flag = get_bits1(gb);
495
24
    if (v->hrd_param_flag) {
496
        int i;
497
18
        v->hrd_num_leaky_buckets = get_bits(gb, 5);
498
18
        skip_bits(gb, 4); //bitrate exponent
499
18
        skip_bits(gb, 4); //buffer size exponent
500
276
        for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
501
258
            skip_bits(gb, 16); //hrd_rate[n]
502
258
            skip_bits(gb, 16); //hrd_buffer[n]
503
        }
504
    }
505
24
    return 0;
506
}
507
508
52
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
509
{
510
    int i;
511
    int w,h;
512
    int ret;
513
514
52
    av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
515
52
    v->broken_link    = get_bits1(gb);
516
52
    v->closed_entry   = get_bits1(gb);
517
52
    v->panscanflag    = get_bits1(gb);
518
52
    v->refdist_flag   = get_bits1(gb);
519
52
    v->s.loop_filter  = get_bits1(gb);
520
52
    if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
521
        v->s.loop_filter = 0;
522
52
    v->fastuvmc       = get_bits1(gb);
523
52
    v->extended_mv    = get_bits1(gb);
524
52
    v->dquant         = get_bits(gb, 2);
525
52
    v->vstransform    = get_bits1(gb);
526
52
    v->overlap        = get_bits1(gb);
527
52
    v->quantizer_mode = get_bits(gb, 2);
528
529
52
    if (v->hrd_param_flag) {
530
728
        for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
531
684
            skip_bits(gb, 8); //hrd_full[n]
532
        }
533
    }
534
535
52
    if(get_bits1(gb)){
536
40
        w = (get_bits(gb, 12)+1)<<1;
537
40
        h = (get_bits(gb, 12)+1)<<1;
538
    } else {
539
12
        w = v->max_coded_width;
540
12
        h = v->max_coded_height;
541
    }
542
52
    if ((ret = ff_set_dimensions(avctx, w, h)) < 0) {
543
        av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
544
        return ret;
545
    }
546
547
52
    if (v->extended_mv)
548
12
        v->extended_dmv = get_bits1(gb);
549
52
    if ((v->range_mapy_flag = get_bits1(gb))) {
550
        av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
551
        v->range_mapy = get_bits(gb, 3);
552
    }
553
52
    if ((v->range_mapuv_flag = get_bits1(gb))) {
554
        av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
555
        v->range_mapuv = get_bits(gb, 3);
556
    }
557
558
52
    av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
559
           "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
560
           "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
561
           "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
562
52
           v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
563
           v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
564
565
52
    return 0;
566
}
567
568
/* fill lookup tables for intensity compensation */
569
#define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do {                 \
570
        int scale, shift, i;                                                  \
571
        if (!lumscale) {                                                      \
572
            scale = -64;                                                      \
573
            shift = (255 - lumshift * 2) * 64;                                \
574
            if (lumshift > 31)                                                \
575
                shift += 128 << 6;                                            \
576
        } else {                                                              \
577
            scale = lumscale + 32;                                            \
578
            if (lumshift > 31)                                                \
579
                shift = (lumshift - 64) * 64;                                 \
580
            else                                                              \
581
                shift = lumshift << 6;                                        \
582
        }                                                                     \
583
        for (i = 0; i < 256; i++) {                                           \
584
            int iy = chain ? luty[i]  : i;                                    \
585
            int iu = chain ? lutuv[i] : i;                                    \
586
            luty[i]  = av_clip_uint8((scale * iy + shift + 32) >> 6);         \
587
            lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
588
        }                                                                     \
589
    } while(0)
590
591
409
static void rotate_luts(VC1Context *v)
592
{
593
#define ROTATE(DEF, L, N, C, A) do {                          \
594
        if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
595
            C = A;                                            \
596
        } else {                                              \
597
            DEF;                                              \
598
            memcpy(&tmp, L   , sizeof(tmp));                  \
599
            memcpy(L   , N   , sizeof(tmp));                  \
600
            memcpy(N   , &tmp, sizeof(tmp));                  \
601
            C = N;                                            \
602
        }                                                     \
603
    } while(0)
604
605

409
    ROTATE(int tmp,             &v->last_use_ic, &v->next_use_ic, v->curr_use_ic, &v->aux_use_ic);
606

409
    ROTATE(uint8_t tmp[2][256], v->last_luty,   v->next_luty,   v->curr_luty,   v->aux_luty);
607

409
    ROTATE(uint8_t tmp[2][256], v->last_lutuv,  v->next_lutuv,  v->curr_lutuv,  v->aux_lutuv);
608
609
105113
    INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
610
105113
    INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
611
409
    *v->curr_use_ic = 0;
612
409
}
613
614
167
static int read_bfraction(VC1Context *v, GetBitContext* gb) {
615
167
    int bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
616
617

167
    if (bfraction_lut_index == 21 || bfraction_lut_index < 0) {
618
        av_log(v->s.avctx, AV_LOG_ERROR, "bfraction invalid\n");
619
        return AVERROR_INVALIDDATA;
620
    }
621
167
    v->bfraction_lut_index = bfraction_lut_index;
622
167
    v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
623
167
    return 0;
624
}
625
626
257
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
627
{
628
    int pqindex, lowquant, status;
629
630
257
    v->field_mode = 0;
631
257
    v->fcm = PROGRESSIVE;
632
257
    if (v->finterpflag)
633
        v->interpfrm = get_bits1(gb);
634
257
    if (!v->s.avctx->codec)
635
        return -1;
636
257
    if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
637
79
        v->respic   =
638
79
        v->rangered =
639
79
        v->multires = get_bits(gb, 2) == 1;
640
    else
641
178
        skip_bits(gb, 2); //framecnt unused
642
257
    v->rangeredfrm = 0;
643
257
    if (v->rangered)
644
53
        v->rangeredfrm = get_bits1(gb);
645
257
    if (get_bits1(gb)) {
646
163
        v->s.pict_type = AV_PICTURE_TYPE_P;
647
    } else {
648

94
        if (v->s.avctx->max_b_frames && !get_bits1(gb)) {
649
11
            v->s.pict_type = AV_PICTURE_TYPE_B;
650
        } else
651
83
            v->s.pict_type = AV_PICTURE_TYPE_I;
652
    }
653
654
257
    v->bi_type = 0;
655
257
    if (v->s.pict_type == AV_PICTURE_TYPE_B) {
656
11
        if (read_bfraction(v, gb) < 0)
657
            return AVERROR_INVALIDDATA;
658
11
        if (v->bfraction == 0) {
659
            v->s.pict_type = AV_PICTURE_TYPE_BI;
660
        }
661
    }
662

257
    if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
663
83
        skip_bits(gb, 7); // skip buffer fullness
664
665
257
    if (v->parse_only)
666
        return 0;
667
668
    /* calculate RND */
669

257
    if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
670
83
        v->rnd = 1;
671
257
    if (v->s.pict_type == AV_PICTURE_TYPE_P)
672
163
        v->rnd ^= 1;
673
674
    /* Quantizer stuff */
675
257
    pqindex = get_bits(gb, 5);
676
257
    if (!pqindex)
677
        return -1;
678
257
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
679
257
        v->pq = ff_vc1_pquant_table[0][pqindex];
680
    else
681
        v->pq = ff_vc1_pquant_table[1][pqindex];
682
257
    v->pqindex = pqindex;
683
257
    if (pqindex < 9)
684
165
        v->halfpq = get_bits1(gb);
685
    else
686
92
        v->halfpq = 0;
687

257
    switch (v->quantizer_mode) {
688
257
    case QUANT_FRAME_IMPLICIT:
689
257
        v->pquantizer = pqindex < 9;
690
257
        break;
691
    case QUANT_NON_UNIFORM:
692
        v->pquantizer = 0;
693
        break;
694
    case QUANT_FRAME_EXPLICIT:
695
        v->pquantizer = get_bits1(gb);
696
        break;
697
    default:
698
        v->pquantizer = 1;
699
        break;
700
    }
701
257
    v->dquantfrm = 0;
702
257
    if (v->extended_mv == 1)
703
        v->mvrange = get_unary(gb, 0, 3);
704
257
    v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
705
257
    v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
706
257
    v->range_x = 1 << (v->k_x - 1);
707
257
    v->range_y = 1 << (v->k_y - 1);
708

257
    if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
709
78
        v->respic = get_bits(gb, 2);
710
711

257
    if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
712
        v->x8_type = get_bits1(gb);
713
    } else
714
257
        v->x8_type = 0;
715
    ff_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
716
            (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
717
            pqindex, v->pq, v->halfpq, v->rangeredfrm);
718
719
257
    if (v->first_pic_header_flag)
720
178
        rotate_luts(v);
721
722
257
    switch (v->s.pict_type) {
723
163
    case AV_PICTURE_TYPE_P:
724
163
        v->tt_index = (v->pq > 4) + (v->pq > 12);
725
726
163
        lowquant = (v->pq > 12) ? 0 : 1;
727
163
        v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
728
163
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
729
21
            v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
730
21
            v->lumscale = get_bits(gb, 6);
731
21
            v->lumshift = get_bits(gb, 6);
732
21
            v->last_use_ic = 1;
733
            /* fill lookup tables for intensity compensation */
734


5397
            INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
735


5397
            INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
736
        }
737
163
        v->qs_last = v->s.quarter_sample;
738
163
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
739
39
            v->s.quarter_sample = (v->mv_mode2 != MV_PMODE_1MV_HPEL &&
740
18
                                   v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
741
21
            v->s.mspel          = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
742
        } else {
743
279
            v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
744
137
                                   v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
745
142
            v->s.mspel          = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
746
        }
747
748
163
        if ((v->mv_mode  == MV_PMODE_INTENSITY_COMP &&
749
21
             v->mv_mode2 == MV_PMODE_MIXED_MV)      ||
750
163
            v->mv_mode   == MV_PMODE_MIXED_MV) {
751
12
            status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
752
12
            if (status < 0)
753
                return -1;
754
12
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
755
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
756
        } else {
757
151
            v->mv_type_is_raw = 0;
758
151
            memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
759
        }
760
163
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
761
163
        if (status < 0)
762
            return -1;
763
163
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
764
               "Imode: %i, Invert: %i\n", status>>1, status&1);
765
766
        /* Hopefully this is correct for P-frames */
767
163
        v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
768
163
        v->cbptab = get_bits(gb, 2);
769
163
        v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
770
771
163
        if (v->dquant) {
772
127
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
773
127
            vop_dquant_decoding(v);
774
        }
775
776
163
        if (v->vstransform) {
777
139
            v->ttmbf = get_bits1(gb);
778
139
            if (v->ttmbf) {
779
5
                v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
780
            } else
781
134
                v->ttfrm = 0; //FIXME Is that so ?
782
        } else {
783
24
            v->ttmbf = 1;
784
24
            v->ttfrm = TT_8X8;
785
        }
786
163
        break;
787
11
    case AV_PICTURE_TYPE_B:
788
11
        v->tt_index = (v->pq > 4) + (v->pq > 12);
789
790
11
        v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
791
11
        v->qs_last          = v->s.quarter_sample;
792
11
        v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
793
11
        v->s.mspel          = v->s.quarter_sample;
794
795
11
        status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
796
11
        if (status < 0)
797
            return -1;
798
11
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
799
               "Imode: %i, Invert: %i\n", status>>1, status&1);
800
11
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
801
11
        if (status < 0)
802
            return -1;
803
11
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
804
               "Imode: %i, Invert: %i\n", status>>1, status&1);
805
806
11
        v->s.mv_table_index = get_bits(gb, 2);
807
11
        v->cbptab           = get_bits(gb, 2);
808
11
        v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[v->cbptab];
809
810
11
        if (v->dquant) {
811
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
812
            vop_dquant_decoding(v);
813
        }
814
815
11
        if (v->vstransform) {
816
11
            v->ttmbf = get_bits1(gb);
817
11
            if (v->ttmbf) {
818
                v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
819
            } else
820
11
                v->ttfrm = 0;
821
        } else {
822
            v->ttmbf = 1;
823
            v->ttfrm = TT_8X8;
824
        }
825
11
        break;
826
    }
827
828
257
    if (!v->x8_type) {
829
        /* AC Syntax */
830
257
        v->c_ac_table_index = decode012(gb);
831

257
        if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
832
83
            v->y_ac_table_index = decode012(gb);
833
        }
834
        /* DC Syntax */
835
257
        v->s.dc_table_index = get_bits1(gb);
836
    }
837
838
257
    if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
839
        v->s.pict_type = AV_PICTURE_TYPE_B;
840
        v->bi_type     = 1;
841
    }
842
257
    return 0;
843
}
844
845
910
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
846
{
847
    int pqindex, lowquant;
848
    int status;
849
    int field_mode, fcm;
850
851
910
    v->numref          = 0;
852
910
    v->p_frame_skipped = 0;
853
910
    if (v->second_field) {
854

36
        if (v->fcm != ILACE_FIELD || v->field_mode!=1)
855
            return -1;
856
36
        if (v->fptype & 4)
857
18
            v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
858
        else
859
18
            v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
860
36
        v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
861
36
        if (!v->pic_header_flag)
862
36
            goto parse_common_info;
863
    }
864
865
874
    field_mode = 0;
866
874
    if (v->interlace) {
867
87
        fcm = decode012(gb);
868
87
        if (fcm) {
869
87
            if (fcm == ILACE_FIELD)
870
72
                field_mode = 1;
871
        }
872
    } else {
873
787
        fcm = PROGRESSIVE;
874
    }
875

874
    if (!v->first_pic_header_flag && v->field_mode != field_mode)
876
        return AVERROR_INVALIDDATA;
877
874
    v->field_mode = field_mode;
878
874
    v->fcm = fcm;
879
880

874
    av_assert0(    v->s.mb_height == v->s.height + 15 >> 4
881
                || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
882
874
    if (v->field_mode) {
883
72
        v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
884
72
        v->fptype = get_bits(gb, 3);
885
72
        if (v->fptype & 4) // B-picture
886
36
            v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
887
        else
888
36
            v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
889
    } else {
890
802
        v->s.mb_height = v->s.height + 15 >> 4;
891

802
        switch (get_unary(gb, 0, 4)) {
892
524
        case 0:
893
524
            v->s.pict_type = AV_PICTURE_TYPE_P;
894
524
            break;
895
125
        case 1:
896
125
            v->s.pict_type = AV_PICTURE_TYPE_B;
897
125
            break;
898
17
        case 2:
899
17
            v->s.pict_type = AV_PICTURE_TYPE_I;
900
17
            break;
901
        case 3:
902
            v->s.pict_type = AV_PICTURE_TYPE_BI;
903
            break;
904
136
        case 4:
905
136
            v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
906
136
            v->p_frame_skipped = 1;
907
136
            break;
908
        }
909
874
    }
910
874
    if (v->tfcntrflag)
911
        skip_bits(gb, 8);
912
874
    if (v->broadcast) {
913

874
        if (!v->interlace || v->psf) {
914
787
            v->rptfrm = get_bits(gb, 2);
915
        } else {
916
87
            v->tff = get_bits1(gb);
917
87
            v->rff = get_bits1(gb);
918
        }
919
    } else {
920
        v->tff = 1;
921
    }
922
874
    if (v->panscanflag) {
923
        avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
924
        //...
925
    }
926
874
    if (v->p_frame_skipped) {
927
136
        return 0;
928
    }
929
738
    v->rnd = get_bits1(gb);
930
738
    if (v->interlace)
931
87
        v->uvsamp = get_bits1(gb);
932
738
    if(!ff_vc1_bfraction_vlc.table)
933
        return 0; //parsing only, vlc tables havnt been allocated
934
738
    if (v->field_mode) {
935
72
        if (!v->refdist_flag)
936
            v->refdist = 0;
937

72
        else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
938
36
            v->refdist = get_bits(gb, 2);
939
36
            if (v->refdist == 3)
940
                v->refdist += get_unary(gb, 0, 14);
941
36
            if (v->refdist > 16)
942
                return AVERROR_INVALIDDATA;
943
        }
944

72
        if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
945
36
            if (read_bfraction(v, gb) < 0)
946
                return AVERROR_INVALIDDATA;
947
36
            v->frfd = (v->bfraction * v->refdist) >> 8;
948
36
            v->brfd = v->refdist - v->frfd - 1;
949
36
            if (v->brfd < 0)
950
                v->brfd = 0;
951
        }
952
72
        goto parse_common_info;
953
    }
954
666
    if (v->fcm == PROGRESSIVE) {
955
651
        if (v->finterpflag)
956
            v->interpfrm = get_bits1(gb);
957
651
        if (v->s.pict_type == AV_PICTURE_TYPE_B) {
958
116
            if (read_bfraction(v, gb) < 0)
959
                return AVERROR_INVALIDDATA;
960
116
            if (v->bfraction == 0) {
961
                v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
962
            }
963
        }
964
    }
965
966
666
    parse_common_info:
967
774
    if (v->field_mode)
968
108
        v->cur_field_type = !(v->tff ^ v->second_field);
969
774
    pqindex = get_bits(gb, 5);
970
774
    if (!pqindex)
971
        return -1;
972
774
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
973
497
        v->pq = ff_vc1_pquant_table[0][pqindex];
974
    else
975
277
        v->pq = ff_vc1_pquant_table[1][pqindex];
976
774
    v->pqindex = pqindex;
977
774
    if (pqindex < 9)
978
739
        v->halfpq = get_bits1(gb);
979
    else
980
35
        v->halfpq = 0;
981

774
    switch (v->quantizer_mode) {
982
497
    case QUANT_FRAME_IMPLICIT:
983
497
        v->pquantizer = pqindex < 9;
984
497
        break;
985
    case QUANT_NON_UNIFORM:
986
        v->pquantizer = 0;
987
        break;
988
    case QUANT_FRAME_EXPLICIT:
989
        v->pquantizer = get_bits1(gb);
990
        break;
991
277
    default:
992
277
        v->pquantizer = 1;
993
277
        break;
994
    }
995
774
    v->dquantfrm = 0;
996
774
    if (v->postprocflag)
997
        v->postproc = get_bits(gb, 2);
998
999
774
    if (v->parse_only)
1000
236
        return 0;
1001
1002
538
    if (v->first_pic_header_flag)
1003
231
        rotate_luts(v);
1004
1005

538
    switch (v->s.pict_type) {
1006
10
    case AV_PICTURE_TYPE_I:
1007
    case AV_PICTURE_TYPE_BI:
1008
10
        if (v->fcm == ILACE_FRAME) { //interlace frame picture
1009
1
            status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
1010
1
            if (status < 0)
1011
                return -1;
1012
1
            av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1013
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1014
        } else
1015
9
            v->fieldtx_is_raw = 0;
1016
10
        status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1017
10
        if (status < 0)
1018
            return -1;
1019
10
        av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1020
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1021
10
        v->condover = CONDOVER_NONE;
1022

10
        if (v->overlap && v->pq <= 8) {
1023
7
            v->condover = decode012(gb);
1024
7
            if (v->condover == CONDOVER_SELECT) {
1025
2
                status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1026
2
                if (status < 0)
1027
                    return -1;
1028
2
                av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1029
                       "Imode: %i, Invert: %i\n", status>>1, status&1);
1030
            }
1031
        }
1032
10
        break;
1033
430
    case AV_PICTURE_TYPE_P:
1034
430
        if (v->field_mode) {
1035
35
            v->numref = get_bits1(gb);
1036
35
            if (!v->numref) {
1037
                v->reffield          = get_bits1(gb);
1038
                v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1039
            }
1040
        }
1041
430
        if (v->extended_mv)
1042
66
            v->mvrange = get_unary(gb, 0, 3);
1043
        else
1044
364
            v->mvrange = 0;
1045
430
        if (v->interlace) {
1046
37
            if (v->extended_dmv)
1047
                v->dmvrange = get_unary(gb, 0, 3);
1048
            else
1049
37
                v->dmvrange = 0;
1050
37
            if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1051
2
                v->fourmvswitch = get_bits1(gb);
1052
2
                v->intcomp      = get_bits1(gb);
1053
2
                if (v->intcomp) {
1054
                    v->lumscale = get_bits(gb, 6);
1055
                    v->lumshift = get_bits(gb, 6);
1056
                    INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1057
                    INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1058
                    v->last_use_ic = 1;
1059
                }
1060
2
                status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1061
2
                if (status < 0)
1062
                    return -1;
1063
2
                av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1064
                       "Imode: %i, Invert: %i\n", status>>1, status&1);
1065
2
                v->mbmodetab = get_bits(gb, 2);
1066
2
                if (v->fourmvswitch)
1067
2
                    v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[v->mbmodetab];
1068
                else
1069
                    v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[v->mbmodetab];
1070
2
                v->imvtab      = get_bits(gb, 2);
1071
2
                v->imv_vlc     = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1072
                // interlaced p-picture cbpcy range is [1, 63]
1073
2
                v->icbptab     = get_bits(gb, 3);
1074
2
                v->cbpcy_vlc   = &ff_vc1_icbpcy_vlc[v->icbptab];
1075
2
                v->twomvbptab     = get_bits(gb, 2);
1076
2
                v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[v->twomvbptab];
1077
2
                if (v->fourmvswitch) {
1078
2
                    v->fourmvbptab     = get_bits(gb, 2);
1079
2
                    v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1080
                }
1081
            }
1082
        }
1083
430
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1084
430
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1085
430
        v->range_x = 1 << (v->k_x - 1);
1086
430
        v->range_y = 1 << (v->k_y - 1);
1087
1088
430
        v->tt_index = (v->pq > 4) + (v->pq > 12);
1089
430
        if (v->fcm != ILACE_FRAME) {
1090
            int mvmode;
1091
428
            mvmode     = get_unary(gb, 1, 4);
1092
428
            lowquant   = (v->pq > 12) ? 0 : 1;
1093
428
            v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1094
428
            if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1095
                int mvmode2;
1096
                mvmode2 = get_unary(gb, 1, 3);
1097
                v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1098
                if (v->field_mode) {
1099
                    v->intcompfield = decode210(gb) ^ 3;
1100
                } else
1101
                    v->intcompfield = 3;
1102
1103
                v->lumscale2 = v->lumscale = 32;
1104
                v->lumshift2 = v->lumshift =  0;
1105
                if (v->intcompfield & 1) {
1106
                    v->lumscale = get_bits(gb, 6);
1107
                    v->lumshift = get_bits(gb, 6);
1108
                }
1109
                if ((v->intcompfield & 2) && v->field_mode) {
1110
                    v->lumscale2 = get_bits(gb, 6);
1111
                    v->lumshift2 = get_bits(gb, 6);
1112
                } else if(!v->field_mode) {
1113
                    v->lumscale2 = v->lumscale;
1114
                    v->lumshift2 = v->lumshift;
1115
                }
1116
                if (v->field_mode && v->second_field) {
1117
                    if (v->cur_field_type) {
1118
                        INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1119
                        INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type  ], v->last_lutuv[v->cur_field_type  ], 1);
1120
                    } else {
1121
                        INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1122
                        INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type  ], v->last_lutuv[v->cur_field_type  ], 1);
1123
                    }
1124
                    v->next_use_ic = *v->curr_use_ic = 1;
1125
                } else {
1126
                    INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1127
                    INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1128
                }
1129
                v->last_use_ic = 1;
1130
            }
1131
428
            v->qs_last = v->s.quarter_sample;
1132
428
            if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1133
                v->s.quarter_sample = (v->mv_mode2 != MV_PMODE_1MV_HPEL &&
1134
                                       v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1135
                v->s.mspel          = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1136
            } else {
1137
856
                v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
1138
428
                                       v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1139
428
                v->s.mspel          = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1140
            }
1141
        }
1142
430
        if (v->fcm == PROGRESSIVE) { // progressive
1143
393
            if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1144
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1145
393
                || v->mv_mode == MV_PMODE_MIXED_MV) {
1146
333
                status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1147
333
                if (status < 0)
1148
                    return -1;
1149
333
                av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1150
                       "Imode: %i, Invert: %i\n", status>>1, status&1);
1151
            } else {
1152
60
                v->mv_type_is_raw = 0;
1153
60
                memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1154
            }
1155
393
            status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1156
393
            if (status < 0)
1157
                return -1;
1158
393
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1159
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1160
1161
            /* Hopefully this is correct for P-frames */
1162
393
            v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1163
393
            v->cbptab           = get_bits(gb, 2);
1164
393
            v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[v->cbptab];
1165
37
        } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1166
2
            v->qs_last          = v->s.quarter_sample;
1167
2
            v->s.quarter_sample = 1;
1168
2
            v->s.mspel          = 1;
1169
        } else {    // field interlaced
1170
35
            v->mbmodetab = get_bits(gb, 3);
1171
35
            v->imvtab = get_bits(gb, 2 + v->numref);
1172
35
            if (!v->numref)
1173
                v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1174
            else
1175
35
                v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[v->imvtab];
1176
35
            v->icbptab = get_bits(gb, 3);
1177
35
            v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1178
35
            if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1179

35
                v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1180
31
                v->fourmvbptab     = get_bits(gb, 2);
1181
31
                v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1182
31
                v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[v->mbmodetab];
1183
            } else {
1184
4
                v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[v->mbmodetab];
1185
            }
1186
        }
1187
430
        if (v->dquant) {
1188
6
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1189
6
            vop_dquant_decoding(v);
1190
        }
1191
1192
430
        if (v->vstransform) {
1193
416
            v->ttmbf = get_bits1(gb);
1194
416
            if (v->ttmbf) {
1195
                v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1196
            } else
1197
416
                v->ttfrm = 0; //FIXME Is that so ?
1198
        } else {
1199
14
            v->ttmbf = 1;
1200
14
            v->ttfrm = TT_8X8;
1201
        }
1202
430
        break;
1203
98
    case AV_PICTURE_TYPE_B:
1204
98
        if (v->fcm == ILACE_FRAME) {
1205
4
            if (read_bfraction(v, gb) < 0)
1206
                return AVERROR_INVALIDDATA;
1207
4
            if (v->bfraction == 0) {
1208
                return -1;
1209
            }
1210
        }
1211
98
        if (v->extended_mv)
1212
70
            v->mvrange = get_unary(gb, 0, 3);
1213
        else
1214
28
            v->mvrange = 0;
1215
98
        v->k_x     = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1216
98
        v->k_y     = v->mvrange + 8; //k_y can be 8 9 10 11
1217
98
        v->range_x = 1 << (v->k_x - 1);
1218
98
        v->range_y = 1 << (v->k_y - 1);
1219
1220
98
        v->tt_index = (v->pq > 4) + (v->pq > 12);
1221
1222
98
        if (v->field_mode) {
1223
            int mvmode;
1224
36
            av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1225
36
            if (v->extended_dmv)
1226
                v->dmvrange = get_unary(gb, 0, 3);
1227
36
            mvmode = get_unary(gb, 1, 3);
1228
36
            lowquant = (v->pq > 12) ? 0 : 1;
1229
36
            v->mv_mode          = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1230
36
            v->qs_last          = v->s.quarter_sample;
1231

36
            v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1232
36
            v->s.mspel          = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1233
36
            status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1234
36
            if (status < 0)
1235
                return -1;
1236
36
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1237
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1238
36
            v->mbmodetab = get_bits(gb, 3);
1239
36
            if (v->mv_mode == MV_PMODE_MIXED_MV)
1240
28
                v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[v->mbmodetab];
1241
            else
1242
8
                v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[v->mbmodetab];
1243
36
            v->imvtab     = get_bits(gb, 3);
1244
36
            v->imv_vlc   = &ff_vc1_2ref_mvdata_vlc[v->imvtab];
1245
36
            v->icbptab   = get_bits(gb, 3);
1246
36
            v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1247
36
            if (v->mv_mode == MV_PMODE_MIXED_MV) {
1248
28
                v->fourmvbptab     = get_bits(gb, 2);
1249
28
                v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1250
            }
1251
36
            v->numref = 1; // interlaced field B pictures are always 2-ref
1252
62
        } else if (v->fcm == ILACE_FRAME) {
1253
4
            if (v->extended_dmv)
1254
                v->dmvrange = get_unary(gb, 0, 3);
1255
4
            if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1256
                av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1257
4
            v->intcomp          = 0;
1258
4
            v->mv_mode          = MV_PMODE_1MV;
1259
4
            v->fourmvswitch     = 0;
1260
4
            v->qs_last          = v->s.quarter_sample;
1261
4
            v->s.quarter_sample = 1;
1262
4
            v->s.mspel          = 1;
1263
4
            status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1264
4
            if (status < 0)
1265
                return -1;
1266
4
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1267
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1268
4
            status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1269
4
            if (status < 0)
1270
                return -1;
1271
4
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1272
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1273
4
            v->mbmodetab       = get_bits(gb, 2);
1274
4
            v->mbmode_vlc   = &ff_vc1_intfr_non4mv_mbmode_vlc[v->mbmodetab];
1275
4
            v->imvtab       = get_bits(gb, 2);
1276
4
            v->imv_vlc      = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1277
            // interlaced p/b-picture cbpcy range is [1, 63]
1278
4
            v->icbptab      = get_bits(gb, 3);
1279
4
            v->cbpcy_vlc    = &ff_vc1_icbpcy_vlc[v->icbptab];
1280
4
            v->twomvbptab      = get_bits(gb, 2);
1281
4
            v->twomvbp_vlc  = &ff_vc1_2mv_block_pattern_vlc[v->twomvbptab];
1282
4
            v->fourmvbptab     = get_bits(gb, 2);
1283
4
            v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1284
        } else {
1285
58
            v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1286
58
            v->qs_last          = v->s.quarter_sample;
1287
58
            v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1288
58
            v->s.mspel          = v->s.quarter_sample;
1289
58
            status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1290
58
            if (status < 0)
1291
                return -1;
1292
58
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1293
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1294
58
            status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1295
58
            if (status < 0)
1296
                return -1;
1297
58
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1298
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1299
58
            v->s.mv_table_index = get_bits(gb, 2);
1300
58
            v->cbptab = get_bits(gb, 2);
1301
58
            v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
1302
        }
1303
1304
98
        if (v->dquant) {
1305
12
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1306
12
            vop_dquant_decoding(v);
1307
        }
1308
1309
98
        if (v->vstransform) {
1310
98
            v->ttmbf = get_bits1(gb);
1311
98
            if (v->ttmbf) {
1312
                v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1313
            } else
1314
98
                v->ttfrm = 0;
1315
        } else {
1316
            v->ttmbf = 1;
1317
            v->ttfrm = TT_8X8;
1318
        }
1319
98
        break;
1320
    }
1321
1322
1323
    /* AC Syntax */
1324
538
    v->c_ac_table_index = decode012(gb);
1325

538
    if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1326
10
        v->y_ac_table_index = decode012(gb);
1327
    }
1328

528
    else if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1329
12
        v->range_x <<= 1;
1330
12
        v->range_y <<= 1;
1331
    }
1332
1333
    /* DC Syntax */
1334
538
    v->s.dc_table_index = get_bits1(gb);
1335

538
    if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1336
10
        && v->dquant) {
1337
1
        av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1338
1
        vop_dquant_decoding(v);
1339
    }
1340
1341
538
    v->bi_type = (v->s.pict_type == AV_PICTURE_TYPE_BI);
1342
538
    if (v->bi_type)
1343
        v->s.pict_type = AV_PICTURE_TYPE_B;
1344
1345
538
    return 0;
1346
}
1347
1348
static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1349
{
1350
{ 0x0001,  2}, { 0x0005,  3}, { 0x000D,  4}, { 0x0012,  5}, { 0x000E,  6}, { 0x0015,  7},
1351
{ 0x0013,  8}, { 0x003F,  8}, { 0x004B,  9}, { 0x011F,  9}, { 0x00B8, 10}, { 0x03E3, 10},
1352
{ 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1353
{ 0x3EAE, 14}, { 0x0000,  4}, { 0x0010,  5}, { 0x0008,  7}, { 0x0020,  8}, { 0x0029,  9},
1354
{ 0x01F4,  9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1355
{ 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003,  5}, { 0x0011,  7},
1356
{ 0x00C4,  8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1357
{ 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013,  5}, { 0x0078,  7},
1358
{ 0x0069,  9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1359
{ 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C,  6}, { 0x0024,  9}, { 0x0094, 11},
1360
{ 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D,  6}, { 0x0053,  9}, { 0x01A0, 11},
1361
{ 0x02D6, 13}, { 0x0F08, 14}, { 0x0013,  7}, { 0x007C,  9}, { 0x07C1, 11}, { 0x04AC, 14},
1362
{ 0x001B,  7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079,  7}, { 0x03E1, 10},
1363
{ 0x02D4, 13}, { 0x2306, 14}, { 0x0021,  8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1364
{ 0x0035,  8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5,  8}, { 0x0174, 11}, { 0x0785, 13},
1365
{ 0x0048,  9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C,  9}, { 0x00FA, 10}, { 0x07D6, 11},
1366
{ 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1367
{ 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1368
{ 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1369
{ 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E,  4},
1370
{ 0x0045,  7}, { 0x01F3,  9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019,  5},
1371
{ 0x0028,  9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030,  6}, { 0x00A2, 10},
1372
{ 0x02EF, 12}, { 0x05B8, 14}, { 0x003F,  6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1373
{ 0x0044,  7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063,  7}, { 0x03C3, 12}, { 0x0015,  8},
1374
{ 0x08F6, 12}, { 0x0017,  8}, { 0x0498, 13}, { 0x002C,  8}, { 0x07B2, 13}, { 0x002F,  8},
1375
{ 0x1F54, 13}, { 0x008D,  8}, { 0x07BD, 13}, { 0x008E,  8}, { 0x1182, 13}, { 0x00FB,  8},
1376
{ 0x050B, 13}, { 0x002D,  8}, { 0x07C0, 11}, { 0x0079,  9}, { 0x1F5F, 13}, { 0x007A,  9},
1377
{ 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1378
{ 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1379
{ 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1380
{ 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A,  9}
1381
},
1382
{
1383
{ 0x0000,  3}, { 0x0003,  4}, { 0x000B,  5}, { 0x0014,  6}, { 0x003F,  6}, { 0x005D,  7},
1384
{ 0x00A2,  8}, { 0x00AC,  9}, { 0x016E,  9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1385
{ 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1386
{ 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004,  4},
1387
{ 0x001E,  5}, { 0x0042,  7}, { 0x00B6,  8}, { 0x0173,  9}, { 0x0395, 10}, { 0x072E, 11},
1388
{ 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005,  5}, { 0x0040,  7},
1389
{ 0x0049,  9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1390
{ 0x0018,  5}, { 0x0025,  8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1391
{ 0x139C, 15}, { 0x0029,  6}, { 0x004F,  9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1392
{ 0x0038,  6}, { 0x010E,  9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058,  7},
1393
{ 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023,  8}, { 0x02E3, 10}, { 0x04E5, 13},
1394
{ 0x2E40, 14}, { 0x00A1,  8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083,  8}, { 0x013A, 11},
1395
{ 0x1721, 13}, { 0x0044,  9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1396
{ 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1397
{ 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1398
{ 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1399
{ 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003,  3}, { 0x002A,  6}, { 0x00E4,  8},
1400
{ 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1401
{ 0x0009,  4}, { 0x0054,  8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D,  4},
1402
{ 0x00AD,  9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011,  5}, { 0x016B,  9}, { 0x0B7F, 12},
1403
{ 0x51A4, 15}, { 0x0019,  5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D,  5}, { 0x0394, 10},
1404
{ 0x28D3, 14}, { 0x002B,  6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F,  6}, { 0x0247, 12},
1405
{ 0x0010,  7}, { 0x0A35, 12}, { 0x003E,  6}, { 0x0B7A, 12}, { 0x0059,  7}, { 0x105E, 13},
1406
{ 0x0026,  8}, { 0x09CF, 14}, { 0x0055,  8}, { 0x1CB5, 13}, { 0x0057,  8}, { 0x0E5B, 12},
1407
{ 0x00A0,  8}, { 0x1468, 13}, { 0x0170,  9}, { 0x0090, 10}, { 0x01CE,  9}, { 0x021A, 10},
1408
{ 0x0218, 10}, { 0x0168,  9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1409
{ 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1410
{ 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1411
{ 0x0169,  9}
1412
},
1413
{
1414
{ 0x0001,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x0016,  5}, { 0x0020,  6}, { 0x0018,  7},
1415
{ 0x0008,  8}, { 0x009A,  8}, { 0x0056,  9}, { 0x013E,  9}, { 0x00F0, 10}, { 0x03A5, 10},
1416
{ 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001,  4}, { 0x0011,  5},
1417
{ 0x0002,  7}, { 0x000B,  8}, { 0x0012,  9}, { 0x01D6,  9}, { 0x027E, 10}, { 0x0191, 11},
1418
{ 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004,  5}, { 0x0014,  7}, { 0x009E,  8},
1419
{ 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017,  5},
1420
{ 0x004E,  7}, { 0x005E,  9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1421
{ 0x000E,  6}, { 0x00E1,  8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B,  6},
1422
{ 0x001C,  9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006,  7}, { 0x007A,  9}, { 0x0190, 11},
1423
{ 0x0137, 13}, { 0x001B,  7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071,  7}, { 0x00D7, 10},
1424
{ 0x09BF, 12}, { 0x0007,  8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034,  8}, { 0x0265, 10},
1425
{ 0x009F, 12}, { 0x00E0,  8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015,  9}, { 0x017D, 11},
1426
{ 0x0EBB, 12}, { 0x0014,  9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1427
{ 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1428
{ 0x013A, 13}, { 0x000A,  4}, { 0x0042,  7}, { 0x01D3,  9}, { 0x04DD, 11}, { 0x0012,  5},
1429
{ 0x00E8,  8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039,  6}, { 0x0264, 10}, { 0x0EBA, 12},
1430
{ 0x0000,  7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F,  7}, { 0x04DE, 11}, { 0x0043,  7},
1431
{ 0x04DC, 11}, { 0x0003,  8}, { 0x03CB, 12}, { 0x0006,  8}, { 0x099E, 12}, { 0x002A,  8},
1432
{ 0x05F1, 13}, { 0x000F,  8}, { 0x09FE, 12}, { 0x0033,  8}, { 0x09FF, 12}, { 0x0098,  8},
1433
{ 0x099F, 12}, { 0x00EA,  8}, { 0x013C, 13}, { 0x002E,  8}, { 0x0192, 11}, { 0x0136,  9},
1434
{ 0x006A,  9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1435
{ 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1436
{ 0x0016,  7}
1437
},
1438
{
1439
{ 0x0004,  3}, { 0x0014,  5}, { 0x0017,  7}, { 0x007F,  8}, { 0x0154,  9}, { 0x01F2, 10},
1440
{ 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1441
{ 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B,  4}, { 0x0037,  7}, { 0x0062,  9}, { 0x0007, 11},
1442
{ 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007,  5},
1443
{ 0x006D,  8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002,  6}, { 0x0061,  9},
1444
{ 0x0055, 12}, { 0x01DF, 14}, { 0x001A,  6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1445
{ 0x001E,  6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006,  7}, { 0x0004, 11},
1446
{ 0x02F8, 13}, { 0x0019,  7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057,  7}, { 0x0182, 11},
1447
{ 0x2AA2, 14}, { 0x0004,  8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D,  8}, { 0x0164, 12},
1448
{ 0x076D, 15}, { 0x0002,  9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD,  8}, { 0x0060, 12},
1449
{ 0x0C67, 14}, { 0x001C,  9}, { 0x00EE, 13}, { 0x0003,  9}, { 0x02CF, 13}, { 0x00D9,  9},
1450
{ 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1451
{ 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1452
{ 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003,  2}, { 0x0054,  7}, { 0x02AB, 10},
1453
{ 0x0016, 13}, { 0x05F7, 14}, { 0x0005,  4}, { 0x00F8,  9}, { 0x0AA9, 12}, { 0x005F, 15},
1454
{ 0x0004,  4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004,  5}, { 0x0077, 11}, { 0x076C, 15},
1455
{ 0x000E,  5}, { 0x000A, 12}, { 0x000C,  5}, { 0x0562, 11}, { 0x0004,  6}, { 0x031C, 12},
1456
{ 0x0006,  6}, { 0x00C8, 13}, { 0x000D,  6}, { 0x01DA, 13}, { 0x0007,  6}, { 0x00C9, 13},
1457
{ 0x0001,  7}, { 0x002E, 14}, { 0x0014,  7}, { 0x1596, 13}, { 0x000A,  7}, { 0x0AC2, 12},
1458
{ 0x0016,  7}, { 0x015B, 14}, { 0x0015,  7}, { 0x015A, 14}, { 0x000F,  8}, { 0x005E, 15},
1459
{ 0x007E,  8}, { 0x00AB,  8}, { 0x002D,  9}, { 0x00D8,  9}, { 0x000B,  9}, { 0x0014, 10},
1460
{ 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E,  9},
1461
{ 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1462
{ 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1463
{ 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D,  9}
1464
},
1465
{
1466
{ 0x0002,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x000D,  5}, { 0x000C,  5}, { 0x0015,  6},
1467
{ 0x0013,  6}, { 0x0012,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x001E,  8}, { 0x001D,  8},
1468
{ 0x0025,  9}, { 0x0024,  9}, { 0x0023,  9}, { 0x0021,  9}, { 0x0021, 10}, { 0x0020, 10},
1469
{ 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1470
{ 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E,  4}, { 0x0014,  6}, { 0x0016,  7},
1471
{ 0x001C,  8}, { 0x0020,  9}, { 0x001F,  9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1472
{ 0x0055, 12}, { 0x000B,  5}, { 0x0015,  7}, { 0x001E,  9}, { 0x000C, 10}, { 0x0056, 12},
1473
{ 0x0011,  6}, { 0x001B,  8}, { 0x001D,  9}, { 0x000B, 10}, { 0x0010,  6}, { 0x0022,  9},
1474
{ 0x000A, 10}, { 0x000D,  6}, { 0x001C,  9}, { 0x0008, 10}, { 0x0012,  7}, { 0x001B,  9},
1475
{ 0x0054, 12}, { 0x0014,  7}, { 0x001A,  9}, { 0x0057, 12}, { 0x0019,  8}, { 0x0009, 10},
1476
{ 0x0018,  8}, { 0x0023, 11}, { 0x0017,  8}, { 0x0019,  9}, { 0x0018,  9}, { 0x0007, 10},
1477
{ 0x0058, 12}, { 0x0007,  4}, { 0x000C,  6}, { 0x0016,  8}, { 0x0017,  9}, { 0x0006, 10},
1478
{ 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F,  6}, { 0x0016,  9}, { 0x0005, 10},
1479
{ 0x000E,  6}, { 0x0004, 10}, { 0x0011,  7}, { 0x0024, 11}, { 0x0010,  7}, { 0x0025, 11},
1480
{ 0x0013,  7}, { 0x005A, 12}, { 0x0015,  8}, { 0x005B, 12}, { 0x0014,  8}, { 0x0013,  8},
1481
{ 0x001A,  8}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9}, { 0x0012,  9}, { 0x0011,  9},
1482
{ 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1483
{ 0x0003,  7}
1484
},
1485
{
1486
{ 0x0002,  2}, { 0x000F,  4}, { 0x0015,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x0025,  9},
1487
{ 0x0024,  9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1488
{ 0x0006,  3}, { 0x0014,  6}, { 0x001E,  8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1489
{ 0x000E,  4}, { 0x001D,  8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D,  5}, { 0x0023,  9},
1490
{ 0x000D, 10}, { 0x000C,  5}, { 0x0022,  9}, { 0x0052, 12}, { 0x000B,  5}, { 0x000C, 10},
1491
{ 0x0053, 12}, { 0x0013,  6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012,  6}, { 0x000A, 10},
1492
{ 0x0011,  6}, { 0x0009, 10}, { 0x0010,  6}, { 0x0008, 10}, { 0x0016,  7}, { 0x0055, 12},
1493
{ 0x0015,  7}, { 0x0014,  7}, { 0x001C,  8}, { 0x001B,  8}, { 0x0021,  9}, { 0x0020,  9},
1494
{ 0x001F,  9}, { 0x001E,  9}, { 0x001D,  9}, { 0x001C,  9}, { 0x001B,  9}, { 0x001A,  9},
1495
{ 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007,  4}, { 0x0019,  9},
1496
{ 0x0005, 11}, { 0x000F,  6}, { 0x0004, 11}, { 0x000E,  6}, { 0x000D,  6}, { 0x000C,  6},
1497
{ 0x0013,  7}, { 0x0012,  7}, { 0x0011,  7}, { 0x0010,  7}, { 0x001A,  8}, { 0x0019,  8},
1498
{ 0x0018,  8}, { 0x0017,  8}, { 0x0016,  8}, { 0x0015,  8}, { 0x0014,  8}, { 0x0013,  8},
1499
{ 0x0018,  9}, { 0x0017,  9}, { 0x0016,  9}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9},
1500
{ 0x0012,  9}, { 0x0011,  9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1501
{ 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1502
{ 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1503
{ 0x0003,  7}
1504
},
1505
{
1506
{ 0x0000,  2}, { 0x0003,  3}, { 0x000D,  4}, { 0x0005,  4}, { 0x001C,  5}, { 0x0016,  5},
1507
{ 0x003F,  6}, { 0x003A,  6}, { 0x002E,  6}, { 0x0022,  6}, { 0x007B,  7}, { 0x0067,  7},
1508
{ 0x005F,  7}, { 0x0047,  7}, { 0x0026,  7}, { 0x00EF,  8}, { 0x00CD,  8}, { 0x00C1,  8},
1509
{ 0x00A9,  8}, { 0x004F,  8}, { 0x01F2,  9}, { 0x01DD,  9}, { 0x0199,  9}, { 0x0185,  9},
1510
{ 0x015D,  9}, { 0x011B,  9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1511
{ 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1512
{ 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1513
{ 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1514
{ 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1515
{ 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009,  4}, { 0x0010,  5}, { 0x0029,  6}, { 0x0062,  7},
1516
{ 0x00F3,  8}, { 0x00AD,  8}, { 0x01E5,  9}, { 0x0179,  9}, { 0x009C,  9}, { 0x03B1, 10},
1517
{ 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1518
{ 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008,  5}, { 0x0063,  7},
1519
{ 0x00AF,  8}, { 0x017B,  9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1520
{ 0x0BC1, 12}, { 0x0491, 12}, { 0x0028,  6}, { 0x00C3,  8}, { 0x0151,  9}, { 0x02A1, 10},
1521
{ 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065,  7}, { 0x01DA,  9}, { 0x02AF, 10},
1522
{ 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025,  7}, { 0x0118,  9}, { 0x0646, 11},
1523
{ 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9,  8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1524
{ 0x0048,  8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180,  9}, { 0x0465, 11}, { 0x1905, 13},
1525
{ 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1526
{ 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1527
{ 0x0078,  7}, { 0x0155,  9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA,  8}, { 0x07DC, 11},
1528
{ 0x1907, 13}, { 0x00AC,  8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6,  9}, { 0x0AE2, 12},
1529
{ 0x01DC,  9}, { 0x04ED, 12}, { 0x0184,  9}, { 0x1904, 13}, { 0x0156,  9}, { 0x09D9, 13},
1530
{ 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1531
{ 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1532
{ 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1533
{ 0x007A,  7}
1534
},
1535
{
1536
{ 0x0002,  2}, { 0x0000,  3}, { 0x001E,  5}, { 0x0004,  5}, { 0x0012,  6}, { 0x0070,  7},
1537
{ 0x001A,  7}, { 0x005F,  8}, { 0x0047,  8}, { 0x01D3,  9}, { 0x00B5,  9}, { 0x0057,  9},
1538
{ 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1539
{ 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1540
{ 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1541
{ 0x08C0, 13}, { 0x055D, 13}, { 0x0003,  3}, { 0x000A,  5}, { 0x0077,  7}, { 0x00E5,  8},
1542
{ 0x01D9,  9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1543
{ 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C,  4}, { 0x007D,  7}, { 0x0044,  8},
1544
{ 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B,  5},
1545
{ 0x00E2,  8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007,  5},
1546
{ 0x01D8,  9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035,  6}, { 0x03E1, 10},
1547
{ 0x059C, 12}, { 0x38C3, 14}, { 0x000C,  6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1548
{ 0x0068,  7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020,  7}, { 0x0F90, 12}, { 0x7CF6, 15},
1549
{ 0x00E8,  8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045,  8}, { 0x0B3A, 13}, { 0x01F1,  9},
1550
{ 0x3B46, 14}, { 0x01A7,  9}, { 0x1676, 14}, { 0x0056,  9}, { 0x692A, 15}, { 0x038D, 10},
1551
{ 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1552
{ 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1553
{ 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1554
{ 0x055F, 13}, { 0x003F,  6}, { 0x006D,  9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013,  6},
1555
{ 0x0119, 10}, { 0x0B66, 13}, { 0x000B,  6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075,  7},
1556
{ 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E,  7}, { 0x1F22, 13}, { 0x0021,  7}, { 0x054F, 13},
1557
{ 0x0014,  7}, { 0x3A44, 14}, { 0x00E4,  8}, { 0x7CF7, 15}, { 0x005E,  8}, { 0x7185, 15},
1558
{ 0x0037,  8}, { 0x2C73, 15}, { 0x01DB,  9}, { 0x59DD, 16}, { 0x01C7,  9}, { 0x692B, 15},
1559
{ 0x01A6,  9}, { 0x58E5, 16}, { 0x00B4,  9}, { 0x1F3D0, 17}, { 0x00B0,  9}, { 0xB1C9, 17},
1560
{ 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1561
{ 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1562
{ 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1563
{ 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1564
{ 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1565
{ 0x0073,  7}
1566
}
1567
};
1568
1569
static const uint16_t vlc_offs[] = {
1570
        0,   520,   552,   616,  1128,  1160,  1224,  1740,  1772,  1836,  1900,  2436,
1571
     2986,  3050,  3610,  4154,  4218,  4746,  5326,  5390,  5902,  6554,  7658,  8342,
1572
     9304,  9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1573
    20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1574
    27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1575
    29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1576
    31714, 31746, 31778, 32306, 32340, 32372
1577
};
1578
1579
/**
1580
 * Init VC-1 specific tables and VC1Context members
1581
 * @param v The VC1Context to initialize
1582
 * @return Status
1583
 */
1584
40
av_cold int ff_vc1_init_common(VC1Context *v)
1585
{
1586
    static int done = 0;
1587
40
    int i = 0;
1588
    static VLC_TYPE vlc_table[32372][2];
1589
1590
40
    v->hrd_rate = v->hrd_buffer = NULL;
1591
1592
    /* VLC tables */
1593
40
    if (!done) {
1594
17
        INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1595
                        ff_vc1_bfraction_bits, 1, 1,
1596
                        ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1597
17
        INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1598
                        ff_vc1_norm2_bits, 1, 1,
1599
                        ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1600
17
        INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1601
                        ff_vc1_norm6_bits, 1, 1,
1602
                        ff_vc1_norm6_codes, 2, 2, 556);
1603
17
        INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1604
                        ff_vc1_imode_bits, 1, 1,
1605
                        ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1606
68
        for (i = 0; i < 3; i++) {
1607
51
            ff_vc1_ttmb_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 0]];
1608
51
            ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1609
51
            init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1610
                     ff_vc1_ttmb_bits[i], 1, 1,
1611
                     ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1612
51
            ff_vc1_ttblk_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 1]];
1613
51
            ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1614
51
            init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1615
                     ff_vc1_ttblk_bits[i], 1, 1,
1616
                     ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1617
51
            ff_vc1_subblkpat_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 2]];
1618
51
            ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1619
51
            init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1620
                     ff_vc1_subblkpat_bits[i], 1, 1,
1621
                     ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1622
        }
1623
85
        for (i = 0; i < 4; i++) {
1624
68
            ff_vc1_4mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 9]];
1625
68
            ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1626
68
            init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1627
                     ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1628
                     ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1629
68
            ff_vc1_cbpcy_p_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 10]];
1630
68
            ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1631
68
            init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1632
                     ff_vc1_cbpcy_p_bits[i], 1, 1,
1633
                     ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1634
68
            ff_vc1_mv_diff_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 11]];
1635
68
            ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1636
68
            init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1637
                     ff_vc1_mv_diff_bits[i], 1, 1,
1638
                     ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1639
        }
1640
153
        for (i = 0; i < 8; i++) {
1641
136
            ff_vc1_ac_coeff_table[i].table           = &vlc_table[vlc_offs[i * 2 + 21]];
1642
136
            ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1643
136
            init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1644
                     &vc1_ac_tables[i][0][1], 8, 4,
1645
                     &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1646
            /* initialize interlaced MVDATA tables (2-Ref) */
1647
136
            ff_vc1_2ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 2 + 22]];
1648
136
            ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1649
136
            init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1650
                     ff_vc1_2ref_mvdata_bits[i], 1, 1,
1651
                     ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1652
        }
1653
85
        for (i = 0; i < 4; i++) {
1654
            /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1655
68
            ff_vc1_intfr_4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 37]];
1656
68
            ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1657
68
            init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1658
                     ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1659
                     ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1660
            /* initialize NON-4MV MBMODE VLC tables for the same */
1661
68
            ff_vc1_intfr_non4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 38]];
1662
68
            ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1663
68
            init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1664
                     ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1665
                     ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1666
            /* initialize interlaced MVDATA tables (1-Ref) */
1667
68
            ff_vc1_1ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 39]];
1668
68
            ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1669
68
            init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1670
                     ff_vc1_1ref_mvdata_bits[i], 1, 1,
1671
                     ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1672
        }
1673
85
        for (i = 0; i < 4; i++) {
1674
            /* Initialize 2MV Block pattern VLC tables */
1675
68
            ff_vc1_2mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i + 49]];
1676
68
            ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1677
68
            init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1678
                     ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1679
                     ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1680
        }
1681
153
        for (i = 0; i < 8; i++) {
1682
            /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1683
136
            ff_vc1_icbpcy_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 53]];
1684
136
            ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1685
136
            init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1686
                     ff_vc1_icbpcy_p_bits[i], 1, 1,
1687
                     ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1688
            /* Initialize interlaced field picture MBMODE VLC tables */
1689
136
            ff_vc1_if_mmv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 54]];
1690
136
            ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1691
136
            init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1692
                     ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1693
                     ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1694
136
            ff_vc1_if_1mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 55]];
1695
136
            ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1696
136
            init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1697
                     ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1698
                     ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1699
        }
1700
17
        done = 1;
1701
    }
1702
1703
    /* Other defaults */
1704
40
    v->pq      = -1;
1705
40
    v->mvrange = 0; /* 7.1.1.18, p80 */
1706
1707
40
    ff_vc1dsp_init(&v->vc1dsp);
1708
1709
40
    return 0;
1710
}