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
7 * This file is part of FFmpeg.
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.
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.
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
26 * VC-1 and WMV3 decoder common code
33 #include "mpegvideo.h"
36 #include "msmpeg4data.h"
38 #include "simple_idct.h"
43 /***********************************************************************/
45 * @name VC-1 Bitplane decoding
63 /** @} */ //imode defines
65 /** Decode rows by checking if they are skipped
66 * @param plane Buffer to store decoded bits
67 * @param[in] width Width of this buffer
68 * @param[in] height Height of this buffer
69 * @param[in] stride of this buffer
71 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
76 for (y = 0; y < height; y++) {
77 if (!get_bits1(gb)) //rowskip
78 memset(plane, 0, width);
80 for (x = 0; x < width; x++)
81 plane[x] = get_bits1(gb);
86 /** Decode columns by checking if they are skipped
87 * @param plane Buffer to store decoded bits
88 * @param[in] width Width of this buffer
89 * @param[in] height Height of this buffer
90 * @param[in] stride of this buffer
91 * @todo FIXME: Optimize
93 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
98 for (x = 0; x < width; x++) {
99 if (!get_bits1(gb)) //colskip
100 for (y = 0; y < height; y++)
103 for (y = 0; y < height; y++)
104 plane[y*stride] = get_bits1(gb);
109 /** Decode a bitplane's bits
110 * @param data bitplane where to store the decode bits
111 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
112 * @param v VC-1 context for bit reading and logging
114 * @todo FIXME: Optimize
116 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
118 GetBitContext *gb = &v->s.gb;
120 int imode, x, y, code, offset;
121 uint8_t invert, *planep = data;
122 int width, height, stride;
124 width = v->s.mb_width;
125 height = v->s.mb_height >> v->field_mode;
126 stride = v->s.mb_stride;
127 invert = get_bits1(gb);
128 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
133 //Data is actually read in the MB layer (same for all tests == "raw")
134 *raw_flag = 1; //invert ignored
138 if ((height * width) & 1) {
139 *planep++ = get_bits1(gb);
144 // decode bitplane as one long line
145 for (y = offset; y < height * width; y += 2) {
146 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
147 *planep++ = code & 1;
149 if (offset == width) {
151 planep += stride - width;
153 *planep++ = code >> 1;
155 if (offset == width) {
157 planep += stride - width;
163 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
164 for (y = 0; y < height; y += 3) {
165 for (x = width & 1; x < width; x += 2) {
166 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
168 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
171 planep[x + 0] = (code >> 0) & 1;
172 planep[x + 1] = (code >> 1) & 1;
173 planep[x + 0 + stride] = (code >> 2) & 1;
174 planep[x + 1 + stride] = (code >> 3) & 1;
175 planep[x + 0 + stride * 2] = (code >> 4) & 1;
176 planep[x + 1 + stride * 2] = (code >> 5) & 1;
178 planep += stride * 3;
181 decode_colskip(data, 1, height, stride, &v->s.gb);
183 planep += (height & 1) * stride;
184 for (y = height & 1; y < height; y += 2) {
185 for (x = width % 3; x < width; x += 3) {
186 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
188 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
191 planep[x + 0] = (code >> 0) & 1;
192 planep[x + 1] = (code >> 1) & 1;
193 planep[x + 2] = (code >> 2) & 1;
194 planep[x + 0 + stride] = (code >> 3) & 1;
195 planep[x + 1 + stride] = (code >> 4) & 1;
196 planep[x + 2 + stride] = (code >> 5) & 1;
198 planep += stride * 2;
202 decode_colskip(data, x, height, stride, &v->s.gb);
204 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
208 decode_rowskip(data, width, height, stride, &v->s.gb);
211 decode_colskip(data, width, height, stride, &v->s.gb);
217 /* Applying diff operator */
218 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
221 for (x = 1; x < width; x++)
222 planep[x] ^= planep[x-1];
223 for (y = 1; y < height; y++) {
225 planep[0] ^= planep[-stride];
226 for (x = 1; x < width; x++) {
227 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
228 else planep[x] ^= planep[x-1];
233 for (x = 0; x < stride * height; x++)
234 planep[x] = !planep[x]; //FIXME stride
236 return (imode << 1) + invert;
239 /** @} */ //Bitplane group
241 /***********************************************************************/
242 /** VOP Dquant decoding
243 * @param v VC-1 Context
245 static int vop_dquant_decoding(VC1Context *v)
247 GetBitContext *gb = &v->s.gb;
251 if (v->dquant == 2) {
252 pqdiff = get_bits(gb, 3);
254 v->altpq = get_bits(gb, 5);
256 v->altpq = v->pq + pqdiff + 1;
258 v->dquantfrm = get_bits1(gb);
260 v->dqprofile = get_bits(gb, 2);
261 switch (v->dqprofile) {
262 case DQPROFILE_SINGLE_EDGE:
263 case DQPROFILE_DOUBLE_EDGES:
264 v->dqsbedge = get_bits(gb, 2);
266 case DQPROFILE_ALL_MBS:
267 v->dqbilevel = get_bits1(gb);
273 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
274 pqdiff = get_bits(gb, 3);
276 v->altpq = get_bits(gb, 5);
278 v->altpq = v->pq + pqdiff + 1;
285 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
288 * Decode Simple/Main Profiles sequence header
289 * @see Figure 7-8, p16-17
290 * @param avctx Codec context
291 * @param gb GetBit context initialized from Codec context extra_data
294 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
296 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
297 v->profile = get_bits(gb, 2);
298 if (v->profile == PROFILE_COMPLEX) {
299 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
302 if (v->profile == PROFILE_ADVANCED) {
303 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
304 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
305 return decode_sequence_header_adv(v, gb);
307 v->zz_8x4 = ff_wmv2_scantableA;
308 v->zz_4x8 = ff_wmv2_scantableB;
309 v->res_y411 = get_bits1(gb);
310 v->res_sprite = get_bits1(gb);
312 av_log(avctx, AV_LOG_ERROR,
313 "Old interlaced mode is not supported\n");
319 v->frmrtq_postproc = get_bits(gb, 3); //common
320 // (bitrate-32kbps)/64kbps
321 v->bitrtq_postproc = get_bits(gb, 5); //common
322 v->s.loop_filter = get_bits1(gb); //common
323 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
324 av_log(avctx, AV_LOG_ERROR,
325 "LOOPFILTER shall not be enabled in Simple Profile\n");
327 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
328 v->s.loop_filter = 0;
330 v->res_x8 = get_bits1(gb); //reserved
331 v->multires = get_bits1(gb);
332 v->res_fasttx = get_bits1(gb);
333 if (!v->res_fasttx) {
334 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
335 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
336 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
337 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
338 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
339 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
340 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
341 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
344 v->fastuvmc = get_bits1(gb); //common
345 if (!v->profile && !v->fastuvmc) {
346 av_log(avctx, AV_LOG_ERROR,
347 "FASTUVMC unavailable in Simple Profile\n");
350 v->extended_mv = get_bits1(gb); //common
351 if (!v->profile && v->extended_mv)
353 av_log(avctx, AV_LOG_ERROR,
354 "Extended MVs unavailable in Simple Profile\n");
357 v->dquant = get_bits(gb, 2); //common
358 v->vstransform = get_bits1(gb); //common
360 v->res_transtab = get_bits1(gb);
363 av_log(avctx, AV_LOG_ERROR,
364 "1 for reserved RES_TRANSTAB is forbidden\n");
368 v->overlap = get_bits1(gb); //common
370 v->s.resync_marker = get_bits1(gb);
371 v->rangered = get_bits1(gb);
372 if (v->rangered && v->profile == PROFILE_SIMPLE) {
373 av_log(avctx, AV_LOG_INFO,
374 "RANGERED should be set to 0 in Simple Profile\n");
377 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
378 v->quantizer_mode = get_bits(gb, 2); //common
380 v->finterpflag = get_bits1(gb); //common
383 int w = get_bits(gb, 11);
384 int h = get_bits(gb, 11);
385 avcodec_set_dimensions(v->s.avctx, w, h);
386 skip_bits(gb, 5); //frame rate
387 v->res_x8 = get_bits1(gb);
388 if (get_bits1(gb)) { // something to do with DC VLC selection
389 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
392 skip_bits(gb, 3); //slice code
395 v->res_rtm_flag = get_bits1(gb); //reserved
397 if (!v->res_rtm_flag) {
398 // av_log(avctx, AV_LOG_ERROR,
399 // "0 for reserved RES_RTM_FLAG is forbidden\n");
400 av_log(avctx, AV_LOG_ERROR,
401 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
404 //TODO: figure out what they mean (always 0x402F)
407 av_log(avctx, AV_LOG_DEBUG,
408 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
409 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
410 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
411 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
412 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
413 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
414 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
415 v->dquant, v->quantizer_mode, avctx->max_b_frames);
419 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
423 v->level = get_bits(gb, 3);
425 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
427 v->chromaformat = get_bits(gb, 2);
428 if (v->chromaformat != 1) {
429 av_log(v->s.avctx, AV_LOG_ERROR,
430 "Only 4:2:0 chroma format supported\n");
435 v->frmrtq_postproc = get_bits(gb, 3); //common
436 // (bitrate-32kbps)/64kbps
437 v->bitrtq_postproc = get_bits(gb, 5); //common
438 v->postprocflag = get_bits1(gb); //common
440 w = (get_bits(gb, 12) + 1) << 1;
441 h = (get_bits(gb, 12) + 1) << 1;
442 avcodec_set_dimensions(v->s.avctx, w, h);
443 v->broadcast = get_bits1(gb);
444 v->interlace = get_bits1(gb);
445 v->tfcntrflag = get_bits1(gb);
446 v->finterpflag = get_bits1(gb);
447 skip_bits1(gb); // reserved
449 av_log(v->s.avctx, AV_LOG_DEBUG,
450 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
451 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
452 "TFCTRflag=%i, FINTERPflag=%i\n",
453 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
454 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
455 v->tfcntrflag, v->finterpflag);
457 v->psf = get_bits1(gb);
458 if (v->psf) { //PsF, 6.1.13
459 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
462 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
463 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
465 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
466 w = get_bits(gb, 14) + 1;
467 h = get_bits(gb, 14) + 1;
468 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
470 ar = get_bits(gb, 4);
472 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
473 } else if (ar == 15) {
474 w = get_bits(gb, 8) + 1;
475 h = get_bits(gb, 8) + 1;
476 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
478 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
479 &v->s.avctx->sample_aspect_ratio.den,
480 v->s.avctx->height * w,
481 v->s.avctx->width * h,
484 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
485 v->s.avctx->sample_aspect_ratio.num,
486 v->s.avctx->sample_aspect_ratio.den);
488 if (get_bits1(gb)) { //framerate stuff
490 v->s.avctx->time_base.num = 32;
491 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
494 nr = get_bits(gb, 8);
495 dr = get_bits(gb, 4);
496 if (nr && nr < 8 && dr && dr < 3) {
497 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
498 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
501 if (v->broadcast) { // Pulldown may be present
502 v->s.avctx->time_base.den *= 2;
503 v->s.avctx->ticks_per_frame = 2;
508 v->color_prim = get_bits(gb, 8);
509 v->transfer_char = get_bits(gb, 8);
510 v->matrix_coef = get_bits(gb, 8);
514 v->hrd_param_flag = get_bits1(gb);
515 if (v->hrd_param_flag) {
517 v->hrd_num_leaky_buckets = get_bits(gb, 5);
518 skip_bits(gb, 4); //bitrate exponent
519 skip_bits(gb, 4); //buffer size exponent
520 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
521 skip_bits(gb, 16); //hrd_rate[n]
522 skip_bits(gb, 16); //hrd_buffer[n]
528 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
532 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
533 v->broken_link = get_bits1(gb);
534 v->closed_entry = get_bits1(gb);
535 v->panscanflag = get_bits1(gb);
536 v->refdist_flag = get_bits1(gb);
537 v->s.loop_filter = get_bits1(gb);
538 v->fastuvmc = get_bits1(gb);
539 v->extended_mv = get_bits1(gb);
540 v->dquant = get_bits(gb, 2);
541 v->vstransform = get_bits1(gb);
542 v->overlap = get_bits1(gb);
543 v->quantizer_mode = get_bits(gb, 2);
545 if (v->hrd_param_flag) {
546 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
547 skip_bits(gb, 8); //hrd_full[n]
552 int w = (get_bits(gb, 12)+1)<<1;
553 int h = (get_bits(gb, 12)+1)<<1;
554 avcodec_set_dimensions(avctx, w, h);
557 v->extended_dmv = get_bits1(gb);
558 if ((v->range_mapy_flag = get_bits1(gb))) {
559 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
560 v->range_mapy = get_bits(gb, 3);
562 if ((v->range_mapuv_flag = get_bits1(gb))) {
563 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
564 v->range_mapuv = get_bits(gb, 3);
567 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
568 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
569 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
570 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
571 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
572 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
577 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
579 int pqindex, lowquant, status;
582 v->interpfrm = get_bits1(gb);
583 skip_bits(gb, 2); //framecnt unused
586 v->rangeredfrm = get_bits1(gb);
587 v->s.pict_type = get_bits1(gb);
588 if (v->s.avctx->max_b_frames) {
589 if (!v->s.pict_type) {
591 v->s.pict_type = AV_PICTURE_TYPE_I;
593 v->s.pict_type = AV_PICTURE_TYPE_B;
595 v->s.pict_type = AV_PICTURE_TYPE_P;
597 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
600 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
601 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
602 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
603 if (v->bfraction == 0) {
604 v->s.pict_type = AV_PICTURE_TYPE_BI;
607 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
608 skip_bits(gb, 7); // skip buffer fullness
614 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
616 if (v->s.pict_type == AV_PICTURE_TYPE_P)
619 /* Quantizer stuff */
620 pqindex = get_bits(gb, 5);
623 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
624 v->pq = ff_vc1_pquant_table[0][pqindex];
626 v->pq = ff_vc1_pquant_table[1][pqindex];
629 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
630 v->pquantizer = pqindex < 9;
631 if (v->quantizer_mode == QUANT_NON_UNIFORM)
633 v->pqindex = pqindex;
635 v->halfpq = get_bits1(gb);
638 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
639 v->pquantizer = get_bits1(gb);
641 if (v->extended_mv == 1)
642 v->mvrange = get_unary(gb, 0, 3);
643 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
644 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
645 v->range_x = 1 << (v->k_x - 1);
646 v->range_y = 1 << (v->k_y - 1);
647 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
648 v->respic = get_bits(gb, 2);
650 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
651 v->x8_type = get_bits1(gb);
654 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
655 // (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
657 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
660 switch (v->s.pict_type) {
661 case AV_PICTURE_TYPE_P:
662 if (v->pq < 5) v->tt_index = 0;
663 else if (v->pq < 13) v->tt_index = 1;
664 else v->tt_index = 2;
666 lowquant = (v->pq > 12) ? 0 : 1;
667 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
668 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
670 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
671 v->lumscale = get_bits(gb, 6);
672 v->lumshift = get_bits(gb, 6);
674 /* fill lookup tables for intensity compensation */
677 shift = (255 - v->lumshift * 2) << 6;
678 if (v->lumshift > 31)
681 scale = v->lumscale + 32;
682 if (v->lumshift > 31)
683 shift = (v->lumshift - 64) << 6;
685 shift = v->lumshift << 6;
687 for (i = 0; i < 256; i++) {
688 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
689 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
692 v->qs_last = v->s.quarter_sample;
693 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
694 v->s.quarter_sample = 0;
695 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
696 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
697 v->s.quarter_sample = 0;
699 v->s.quarter_sample = 1;
701 v->s.quarter_sample = 1;
702 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
704 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
705 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
706 v->mv_mode == MV_PMODE_MIXED_MV) {
707 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
710 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
711 "Imode: %i, Invert: %i\n", status>>1, status&1);
713 v->mv_type_is_raw = 0;
714 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
716 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
719 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
720 "Imode: %i, Invert: %i\n", status>>1, status&1);
722 /* Hopefully this is correct for P frames */
723 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
724 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
727 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
728 vop_dquant_decoding(v);
731 v->ttfrm = 0; //FIXME Is that so ?
732 if (v->vstransform) {
733 v->ttmbf = get_bits1(gb);
735 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
742 case AV_PICTURE_TYPE_B:
743 if (v->pq < 5) v->tt_index = 0;
744 else if (v->pq < 13) v->tt_index = 1;
745 else v->tt_index = 2;
747 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
748 v->qs_last = v->s.quarter_sample;
749 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
750 v->s.mspel = v->s.quarter_sample;
752 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
755 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
756 "Imode: %i, Invert: %i\n", status>>1, status&1);
757 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
760 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
761 "Imode: %i, Invert: %i\n", status>>1, status&1);
763 v->s.mv_table_index = get_bits(gb, 2);
764 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
767 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
768 vop_dquant_decoding(v);
772 if (v->vstransform) {
773 v->ttmbf = get_bits1(gb);
775 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
786 v->c_ac_table_index = decode012(gb);
787 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
788 v->y_ac_table_index = decode012(gb);
791 v->s.dc_table_index = get_bits1(gb);
794 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
795 v->s.pict_type = AV_PICTURE_TYPE_B;
801 /* fill lookup tables for intensity compensation */
802 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
805 shift = (255 - lumshift * 2) << 6; \
809 scale = lumscale + 32; \
811 shift = (lumshift - 64) << 6; \
813 shift = lumshift << 6; \
815 for (i = 0; i < 256; i++) { \
816 luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
817 lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
820 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
822 int pqindex, lowquant;
824 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
825 int scale, shift, i; /* for initializing LUT for intensity compensation */
828 v->p_frame_skipped = 0;
829 if (v->second_field) {
830 if(v->fcm!=2 || v->field_mode!=1)
832 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
834 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
835 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
836 if (!v->pic_header_flag)
837 goto parse_common_info;
842 v->fcm = decode012(gb);
844 if (v->fcm == ILACE_FIELD)
846 if (!v->warn_interlaced++)
847 av_log(v->s.avctx, AV_LOG_ERROR,
848 "Interlaced frames/fields support is incomplete\n");
851 v->fcm = PROGRESSIVE;
855 v->fptype = get_bits(gb, 3);
856 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
857 if (v->fptype & 4) // B-picture
858 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
860 switch (get_unary(gb, 0, 4)) {
862 v->s.pict_type = AV_PICTURE_TYPE_P;
865 v->s.pict_type = AV_PICTURE_TYPE_B;
868 v->s.pict_type = AV_PICTURE_TYPE_I;
871 v->s.pict_type = AV_PICTURE_TYPE_BI;
874 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
875 v->p_frame_skipped = 1;
882 if (!v->interlace || v->psf) {
883 v->rptfrm = get_bits(gb, 2);
885 v->tff = get_bits1(gb);
886 v->rff = get_bits1(gb);
889 if (v->panscanflag) {
890 av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
893 if (v->p_frame_skipped) {
896 v->rnd = get_bits1(gb);
898 v->uvsamp = get_bits1(gb);
899 if(!ff_vc1_bfraction_vlc.table)
900 return 0; //parsing only, vlc tables havnt been allocated
902 if (!v->refdist_flag)
904 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
905 v->refdist = get_bits(gb, 2);
907 v->refdist += get_unary(gb, 0, 16);
909 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
910 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
911 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
912 v->frfd = (v->bfraction * v->refdist) >> 8;
913 v->brfd = v->refdist - v->frfd - 1;
917 goto parse_common_info;
919 if (v->fcm == PROGRESSIVE) {
921 v->interpfrm = get_bits1(gb);
922 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
923 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
924 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
925 if (v->bfraction == 0) {
926 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
933 v->cur_field_type = !(v->tff ^ v->second_field);
934 pqindex = get_bits(gb, 5);
937 v->pqindex = pqindex;
938 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
939 v->pq = ff_vc1_pquant_table[0][pqindex];
941 v->pq = ff_vc1_pquant_table[1][pqindex];
944 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
945 v->pquantizer = pqindex < 9;
946 if (v->quantizer_mode == QUANT_NON_UNIFORM)
948 v->pqindex = pqindex;
950 v->halfpq = get_bits1(gb);
953 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
954 v->pquantizer = get_bits1(gb);
956 v->postproc = get_bits(gb, 2);
958 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
964 switch (v->s.pict_type) {
965 case AV_PICTURE_TYPE_I:
966 case AV_PICTURE_TYPE_BI:
967 if (v->fcm == ILACE_FRAME) { //interlace frame picture
968 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
971 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
972 "Imode: %i, Invert: %i\n", status>>1, status&1);
974 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
977 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
978 "Imode: %i, Invert: %i\n", status>>1, status&1);
979 v->condover = CONDOVER_NONE;
980 if (v->overlap && v->pq <= 8) {
981 v->condover = decode012(gb);
982 if (v->condover == CONDOVER_SELECT) {
983 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
986 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
987 "Imode: %i, Invert: %i\n", status>>1, status&1);
991 case AV_PICTURE_TYPE_P:
993 v->numref = get_bits1(gb);
995 v->reffield = get_bits1(gb);
996 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1000 v->mvrange = get_unary(gb, 0, 3);
1004 if (v->extended_dmv)
1005 v->dmvrange = get_unary(gb, 0, 3);
1008 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1009 v->fourmvswitch = get_bits1(gb);
1010 v->intcomp = get_bits1(gb);
1012 v->lumscale = get_bits(gb, 6);
1013 v->lumshift = get_bits(gb, 6);
1014 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1016 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1017 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1018 "Imode: %i, Invert: %i\n", status>>1, status&1);
1019 mbmodetab = get_bits(gb, 2);
1020 if (v->fourmvswitch)
1021 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1023 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1024 imvtab = get_bits(gb, 2);
1025 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1026 // interlaced p-picture cbpcy range is [1, 63]
1027 icbptab = get_bits(gb, 3);
1028 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1029 twomvbptab = get_bits(gb, 2);
1030 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1031 if (v->fourmvswitch) {
1032 fourmvbptab = get_bits(gb, 2);
1033 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1037 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1038 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1039 v->range_x = 1 << (v->k_x - 1);
1040 v->range_y = 1 << (v->k_y - 1);
1044 else if (v->pq < 13)
1048 if (v->fcm != ILACE_FRAME) {
1050 mvmode = get_unary(gb, 1, 4);
1051 lowquant = (v->pq > 12) ? 0 : 1;
1052 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1053 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1055 mvmode2 = get_unary(gb, 1, 3);
1056 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1058 v->intcompfield = decode210(gb);
1059 v->lumscale = get_bits(gb, 6);
1060 v->lumshift = get_bits(gb, 6);
1061 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1062 if ((v->field_mode) && !v->intcompfield) {
1063 v->lumscale2 = get_bits(gb, 6);
1064 v->lumshift2 = get_bits(gb, 6);
1065 INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1069 v->qs_last = v->s.quarter_sample;
1070 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1071 v->s.quarter_sample = 0;
1072 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1073 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1074 v->s.quarter_sample = 0;
1076 v->s.quarter_sample = 1;
1078 v->s.quarter_sample = 1;
1079 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1080 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1081 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1083 if (v->fcm == PROGRESSIVE) { // progressive
1084 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1085 v->mv_mode2 == MV_PMODE_MIXED_MV)
1086 || v->mv_mode == MV_PMODE_MIXED_MV) {
1087 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1090 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1091 "Imode: %i, Invert: %i\n", status>>1, status&1);
1093 v->mv_type_is_raw = 0;
1094 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1096 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1099 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1100 "Imode: %i, Invert: %i\n", status>>1, status&1);
1102 /* Hopefully this is correct for P frames */
1103 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1104 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1105 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1106 v->qs_last = v->s.quarter_sample;
1107 v->s.quarter_sample = 1;
1109 } else { // field interlaced
1110 mbmodetab = get_bits(gb, 3);
1111 imvtab = get_bits(gb, 2 + v->numref);
1113 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1115 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1116 icbptab = get_bits(gb, 3);
1117 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1118 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1119 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1120 fourmvbptab = get_bits(gb, 2);
1121 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1122 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1124 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1128 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1129 vop_dquant_decoding(v);
1132 v->ttfrm = 0; //FIXME Is that so ?
1133 if (v->vstransform) {
1134 v->ttmbf = get_bits1(gb);
1136 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1143 case AV_PICTURE_TYPE_B:
1144 // TODO: implement interlaced frame B picture decoding
1145 if (v->fcm == ILACE_FRAME)
1148 v->mvrange = get_unary(gb, 0, 3);
1151 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1152 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1153 v->range_x = 1 << (v->k_x - 1);
1154 v->range_y = 1 << (v->k_y - 1);
1158 else if (v->pq < 13)
1163 if (v->field_mode) {
1165 av_log(v->s.avctx, AV_LOG_ERROR, "B Fields do not work currently\n");
1167 if (v->extended_dmv)
1168 v->dmvrange = get_unary(gb, 0, 3);
1169 mvmode = get_unary(gb, 1, 3);
1170 lowquant = (v->pq > 12) ? 0 : 1;
1171 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1172 v->qs_last = v->s.quarter_sample;
1173 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1174 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1175 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1178 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1179 "Imode: %i, Invert: %i\n", status>>1, status&1);
1180 mbmodetab = get_bits(gb, 3);
1181 if (v->mv_mode == MV_PMODE_MIXED_MV)
1182 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1184 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1185 imvtab = get_bits(gb, 3);
1186 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1187 icbptab = get_bits(gb, 3);
1188 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1189 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1190 fourmvbptab = get_bits(gb, 2);
1191 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1193 v->numref = 1; // interlaced field B pictures are always 2-ref
1195 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1196 v->qs_last = v->s.quarter_sample;
1197 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1198 v->s.mspel = v->s.quarter_sample;
1199 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1202 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1203 "Imode: %i, Invert: %i\n", status>>1, status&1);
1204 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1207 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1208 "Imode: %i, Invert: %i\n", status>>1, status&1);
1209 v->s.mv_table_index = get_bits(gb, 2);
1210 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1214 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1215 vop_dquant_decoding(v);
1219 if (v->vstransform) {
1220 v->ttmbf = get_bits1(gb);
1222 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1232 v->c_ac_table_index = decode012(gb);
1233 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1234 v->y_ac_table_index = decode012(gb);
1237 v->s.dc_table_index = get_bits1(gb);
1238 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1240 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1241 vop_dquant_decoding(v);
1245 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1246 v->s.pict_type = AV_PICTURE_TYPE_B;
1252 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1254 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1255 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1256 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1257 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1258 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1259 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1260 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1261 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1262 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1263 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1264 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1265 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1266 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1267 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1268 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1269 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1270 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1271 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1272 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1273 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1274 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1275 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1276 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1277 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1278 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1279 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1280 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1281 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1282 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1283 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1284 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1287 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1288 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1289 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1290 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1291 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1292 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1293 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1294 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1295 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1296 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1297 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1298 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1299 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1300 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1301 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1302 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1303 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1304 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1305 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1306 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1307 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1308 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1309 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1310 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1311 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1312 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1313 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1314 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1318 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1319 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1320 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1321 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1322 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1323 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1324 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1325 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1326 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1327 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1328 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1329 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1330 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1331 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1332 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1333 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1334 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1335 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1336 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1337 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1338 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1339 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1343 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1344 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1345 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1346 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1347 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1348 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1349 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1350 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1351 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1352 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1353 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1354 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1355 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1356 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1357 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1358 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1359 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1360 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1361 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1362 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1363 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1364 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1365 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1366 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1367 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1370 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1371 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1372 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1373 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1374 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1375 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1376 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1377 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1378 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1379 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1380 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1381 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1382 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1383 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1384 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1385 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1386 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1390 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1391 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1392 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1393 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1394 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1395 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1396 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1397 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1398 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1399 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1400 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1401 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1402 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1403 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1404 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1405 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1406 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1410 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1411 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1412 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1413 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1414 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1415 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1416 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1417 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1418 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1419 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1420 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1421 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1422 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1423 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1424 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1425 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1426 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1427 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1428 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1429 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1430 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1431 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1432 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1433 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1434 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1435 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1436 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1440 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1441 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1442 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1443 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1444 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1445 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1446 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1447 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1448 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1449 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1450 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1451 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1452 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1453 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1454 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1455 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1456 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1457 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1458 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1459 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1460 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1461 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1462 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1463 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1464 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1465 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1466 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1467 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1468 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1473 static const uint16_t vlc_offs[] = {
1474 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1475 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1476 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1477 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1478 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1479 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1480 31714, 31746, 31778, 32306, 32340, 32372
1484 * Init VC-1 specific tables and VC1Context members
1485 * @param v The VC1Context to initialize
1488 int ff_vc1_init_common(VC1Context *v)
1490 static int done = 0;
1492 static VLC_TYPE vlc_table[32372][2];
1494 v->hrd_rate = v->hrd_buffer = NULL;
1498 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1499 ff_vc1_bfraction_bits, 1, 1,
1500 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1501 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1502 ff_vc1_norm2_bits, 1, 1,
1503 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1504 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1505 ff_vc1_norm6_bits, 1, 1,
1506 ff_vc1_norm6_codes, 2, 2, 556);
1507 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1508 ff_vc1_imode_bits, 1, 1,
1509 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1510 for (i = 0; i < 3; i++) {
1511 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1512 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1513 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1514 ff_vc1_ttmb_bits[i], 1, 1,
1515 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1516 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1517 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1518 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1519 ff_vc1_ttblk_bits[i], 1, 1,
1520 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1521 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1522 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1523 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1524 ff_vc1_subblkpat_bits[i], 1, 1,
1525 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1527 for (i = 0; i < 4; i++) {
1528 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1529 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1530 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1531 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1532 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1533 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1534 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1535 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1536 ff_vc1_cbpcy_p_bits[i], 1, 1,
1537 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1538 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1539 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1540 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1541 ff_vc1_mv_diff_bits[i], 1, 1,
1542 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1544 for (i = 0; i < 8; i++) {
1545 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1546 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1547 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1548 &vc1_ac_tables[i][0][1], 8, 4,
1549 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1550 /* initialize interlaced MVDATA tables (2-Ref) */
1551 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1552 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1553 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1554 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1555 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1557 for (i = 0; i < 4; i++) {
1558 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1559 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1560 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1561 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1562 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1563 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1564 /* initialize NON-4MV MBMODE VLC tables for the same */
1565 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1566 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1567 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1568 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1569 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1570 /* initialize interlaced MVDATA tables (1-Ref) */
1571 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1572 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1573 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1574 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1575 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1577 for (i = 0; i < 4; i++) {
1578 /* Initialize 2MV Block pattern VLC tables */
1579 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1580 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1581 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1582 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1583 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1585 for (i = 0; i < 8; i++) {
1586 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1587 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1588 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1589 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1590 ff_vc1_icbpcy_p_bits[i], 1, 1,
1591 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1592 /* Initialize interlaced field picture MBMODE VLC tables */
1593 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1594 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1595 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1596 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1597 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1598 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1599 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1600 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1601 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1602 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1607 /* Other defaults */
1609 v->mvrange = 0; /* 7.1.1.18, p80 */