GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vc1.c Lines: 764 941 81.2 %
Date: 2021-01-20 23:14:43 Branches: 407 648 62.8 %

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 "libavutil/thread.h"
31
#include "internal.h"
32
#include "avcodec.h"
33
#include "mpegvideo.h"
34
#include "vc1.h"
35
#include "vc1data.h"
36
#include "wmv2data.h"
37
#include "unary.h"
38
#include "simple_idct.h"
39
40
/***********************************************************************/
41
/**
42
 * @name VC-1 Bitplane decoding
43
 * @see 8.7, p56
44
 * @{
45
 */
46
47
/** Decode rows by checking if they are skipped
48
 * @param plane Buffer to store decoded bits
49
 * @param[in] width Width of this buffer
50
 * @param[in] height Height of this buffer
51
 * @param[in] stride of this buffer
52
 */
53
192
static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
54
                           GetBitContext *gb)
55
{
56
    int x, y;
57
58
767
    for (y = 0; y < height; y++) {
59
575
        if (!get_bits1(gb)) //rowskip
60
277
            memset(plane, 0, width);
61
        else
62
7569
            for (x = 0; x < width; x++)
63
7271
                plane[x] = get_bits1(gb);
64
575
        plane += stride;
65
    }
66
192
}
67
68
/** Decode columns by checking if they are skipped
69
 * @param plane Buffer to store decoded bits
70
 * @param[in] width Width of this buffer
71
 * @param[in] height Height of this buffer
72
 * @param[in] stride of this buffer
73
 * @todo FIXME: Optimize
74
 */
75
117
static void decode_colskip(uint8_t* plane, int width, int height, int stride,
76
                           GetBitContext *gb)
77
{
78
    int x, y;
79
80
853
    for (x = 0; x < width; x++) {
81
736
        if (!get_bits1(gb)) //colskip
82
9031
            for (y = 0; y < height; y++)
83
8780
                plane[y*stride] = 0;
84
        else
85
6765
            for (y = 0; y < height; y++)
86
6280
                plane[y*stride] = get_bits1(gb);
87
736
        plane ++;
88
    }
89
117
}
90
91
/** Decode a bitplane's bits
92
 * @param data bitplane where to store the decode bits
93
 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
94
 * @param v VC-1 context for bit reading and logging
95
 * @return Status
96
 * @todo FIXME: Optimize
97
 */
98
1098
static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
99
{
100
1098
    GetBitContext *gb = &v->s.gb;
101
102
    int imode, x, y, code, offset;
103
1098
    uint8_t invert, *planep = data;
104
    int width, height, stride;
105
106
1098
    width  = v->s.mb_width;
107
1098
    height = v->s.mb_height >> v->field_mode;
108
1098
    stride = v->s.mb_stride;
109
1098
    invert = get_bits1(gb);
110
1098
    imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
111
112
1098
    *raw_flag = 0;
113

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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