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 Libav.
9 * Libav 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 * Libav 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 Libav; 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 v->s.avctx->width = v->s.avctx->coded_width = get_bits(gb, 11);
384 v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11);
385 skip_bits(gb, 5); //frame rate
386 v->res_x8 = get_bits1(gb);
387 if (get_bits1(gb)) { // something to do with DC VLC selection
388 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
391 skip_bits(gb, 3); //slice code
394 v->res_rtm_flag = get_bits1(gb); //reserved
396 if (!v->res_rtm_flag) {
397 av_log(avctx, AV_LOG_ERROR,
398 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
401 //TODO: figure out what they mean (always 0x402F)
404 av_log(avctx, AV_LOG_DEBUG,
405 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
406 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
407 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
408 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
409 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
410 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
411 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
412 v->dquant, v->quantizer_mode, avctx->max_b_frames);
416 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
419 v->level = get_bits(gb, 3);
421 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
423 v->chromaformat = get_bits(gb, 2);
424 if (v->chromaformat != 1) {
425 av_log(v->s.avctx, AV_LOG_ERROR,
426 "Only 4:2:0 chroma format supported\n");
431 v->frmrtq_postproc = get_bits(gb, 3); //common
432 // (bitrate-32kbps)/64kbps
433 v->bitrtq_postproc = get_bits(gb, 5); //common
434 v->postprocflag = get_bits1(gb); //common
436 v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
437 v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
438 v->s.avctx->width = v->s.avctx->coded_width;
439 v->s.avctx->height = v->s.avctx->coded_height;
440 v->broadcast = get_bits1(gb);
441 v->interlace = get_bits1(gb);
442 v->tfcntrflag = get_bits1(gb);
443 v->finterpflag = get_bits1(gb);
444 skip_bits1(gb); // reserved
446 av_log(v->s.avctx, AV_LOG_DEBUG,
447 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
448 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
449 "TFCTRflag=%i, FINTERPflag=%i\n",
450 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
451 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
452 v->tfcntrflag, v->finterpflag);
454 v->psf = get_bits1(gb);
455 if (v->psf) { //PsF, 6.1.13
456 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
459 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
460 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
462 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
463 w = get_bits(gb, 14) + 1;
464 h = get_bits(gb, 14) + 1;
465 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
467 ar = get_bits(gb, 4);
469 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
470 } else if (ar == 15) {
471 w = get_bits(gb, 8) + 1;
472 h = get_bits(gb, 8) + 1;
473 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
475 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
476 &v->s.avctx->sample_aspect_ratio.den,
477 v->s.avctx->height * w,
478 v->s.avctx->width * h,
481 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
482 v->s.avctx->sample_aspect_ratio.num,
483 v->s.avctx->sample_aspect_ratio.den);
485 if (get_bits1(gb)) { //framerate stuff
487 v->s.avctx->time_base.num = 32;
488 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
491 nr = get_bits(gb, 8);
492 dr = get_bits(gb, 4);
493 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
494 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
495 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
498 if (v->broadcast) { // Pulldown may be present
499 v->s.avctx->time_base.den *= 2;
500 v->s.avctx->ticks_per_frame = 2;
505 v->color_prim = get_bits(gb, 8);
506 v->transfer_char = get_bits(gb, 8);
507 v->matrix_coef = get_bits(gb, 8);
511 v->hrd_param_flag = get_bits1(gb);
512 if (v->hrd_param_flag) {
514 v->hrd_num_leaky_buckets = get_bits(gb, 5);
515 skip_bits(gb, 4); //bitrate exponent
516 skip_bits(gb, 4); //buffer size exponent
517 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
518 skip_bits(gb, 16); //hrd_rate[n]
519 skip_bits(gb, 16); //hrd_buffer[n]
525 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
529 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
530 v->broken_link = get_bits1(gb);
531 v->closed_entry = get_bits1(gb);
532 v->panscanflag = get_bits1(gb);
533 v->refdist_flag = get_bits1(gb);
534 v->s.loop_filter = get_bits1(gb);
535 v->fastuvmc = get_bits1(gb);
536 v->extended_mv = get_bits1(gb);
537 v->dquant = get_bits(gb, 2);
538 v->vstransform = get_bits1(gb);
539 v->overlap = get_bits1(gb);
540 v->quantizer_mode = get_bits(gb, 2);
542 if (v->hrd_param_flag) {
543 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
544 skip_bits(gb, 8); //hrd_full[n]
549 avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
550 avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
553 v->extended_dmv = get_bits1(gb);
554 if ((v->range_mapy_flag = get_bits1(gb))) {
555 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
556 v->range_mapy = get_bits(gb, 3);
558 if ((v->range_mapuv_flag = get_bits1(gb))) {
559 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
560 v->range_mapuv = get_bits(gb, 3);
563 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
564 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
565 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
566 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
567 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
568 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
573 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
575 int pqindex, lowquant, status;
578 v->interpfrm = get_bits1(gb);
579 if (v->s.avctx->codec->id == AV_CODEC_ID_MSS2)
582 v->multires = get_bits(gb, 2) == 1;
584 skip_bits(gb, 2); //framecnt unused
587 v->rangeredfrm = get_bits1(gb);
588 v->s.pict_type = get_bits1(gb);
589 if (v->s.avctx->max_b_frames) {
590 if (!v->s.pict_type) {
592 v->s.pict_type = AV_PICTURE_TYPE_I;
594 v->s.pict_type = AV_PICTURE_TYPE_B;
596 v->s.pict_type = AV_PICTURE_TYPE_P;
598 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
601 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
602 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
603 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
604 if (v->bfraction == 0) {
605 v->s.pict_type = AV_PICTURE_TYPE_BI;
608 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
609 skip_bits(gb, 7); // skip buffer fullness
615 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
617 if (v->s.pict_type == AV_PICTURE_TYPE_P)
620 /* Quantizer stuff */
621 pqindex = get_bits(gb, 5);
624 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
625 v->pq = ff_vc1_pquant_table[0][pqindex];
627 v->pq = ff_vc1_pquant_table[1][pqindex];
630 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
631 v->pquantizer = pqindex < 9;
632 if (v->quantizer_mode == QUANT_NON_UNIFORM)
634 v->pqindex = pqindex;
636 v->halfpq = get_bits1(gb);
639 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
640 v->pquantizer = get_bits1(gb);
642 if (v->extended_mv == 1)
643 v->mvrange = get_unary(gb, 0, 3);
644 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
645 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
646 v->range_x = 1 << (v->k_x - 1);
647 v->range_y = 1 << (v->k_y - 1);
648 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
649 v->respic = get_bits(gb, 2);
651 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
652 v->x8_type = get_bits1(gb);
655 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
656 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
657 pqindex, v->pq, v->halfpq, v->rangeredfrm);
659 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
662 switch (v->s.pict_type) {
663 case AV_PICTURE_TYPE_P:
664 if (v->pq < 5) v->tt_index = 0;
665 else if (v->pq < 13) v->tt_index = 1;
666 else v->tt_index = 2;
668 lowquant = (v->pq > 12) ? 0 : 1;
669 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
670 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
672 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
673 v->lumscale = get_bits(gb, 6);
674 v->lumshift = get_bits(gb, 6);
676 /* fill lookup tables for intensity compensation */
679 shift = (255 - v->lumshift * 2) << 6;
680 if (v->lumshift > 31)
683 scale = v->lumscale + 32;
684 if (v->lumshift > 31)
685 shift = (v->lumshift - 64) << 6;
687 shift = v->lumshift << 6;
689 for (i = 0; i < 256; i++) {
690 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
691 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
694 v->qs_last = v->s.quarter_sample;
695 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
696 v->s.quarter_sample = 0;
697 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
698 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
699 v->s.quarter_sample = 0;
701 v->s.quarter_sample = 1;
703 v->s.quarter_sample = 1;
704 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));
706 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
707 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
708 v->mv_mode == MV_PMODE_MIXED_MV) {
709 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
712 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
713 "Imode: %i, Invert: %i\n", status>>1, status&1);
715 v->mv_type_is_raw = 0;
716 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
718 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
721 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
722 "Imode: %i, Invert: %i\n", status>>1, status&1);
724 /* Hopefully this is correct for P frames */
725 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
726 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
729 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
730 vop_dquant_decoding(v);
733 v->ttfrm = 0; //FIXME Is that so ?
734 if (v->vstransform) {
735 v->ttmbf = get_bits1(gb);
737 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
744 case AV_PICTURE_TYPE_B:
745 if (v->pq < 5) v->tt_index = 0;
746 else if (v->pq < 13) v->tt_index = 1;
747 else v->tt_index = 2;
749 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
750 v->qs_last = v->s.quarter_sample;
751 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
752 v->s.mspel = v->s.quarter_sample;
754 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
757 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
758 "Imode: %i, Invert: %i\n", status>>1, status&1);
759 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
762 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
763 "Imode: %i, Invert: %i\n", status>>1, status&1);
765 v->s.mv_table_index = get_bits(gb, 2);
766 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
769 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
770 vop_dquant_decoding(v);
774 if (v->vstransform) {
775 v->ttmbf = get_bits1(gb);
777 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
788 v->c_ac_table_index = decode012(gb);
789 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
790 v->y_ac_table_index = decode012(gb);
793 v->s.dc_table_index = get_bits1(gb);
796 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
797 v->s.pict_type = AV_PICTURE_TYPE_B;
803 /* fill lookup tables for intensity compensation */
804 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
807 shift = (255 - lumshift * 2) << 6; \
811 scale = lumscale + 32; \
813 shift = (lumshift - 64) << 6; \
815 shift = lumshift << 6; \
817 for (i = 0; i < 256; i++) { \
818 luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
819 lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
822 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
824 int pqindex, lowquant;
826 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
827 int scale, shift, i; /* for initializing LUT for intensity compensation */
829 v->p_frame_skipped = 0;
830 if (v->second_field) {
831 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
833 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
834 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
835 if (!v->pic_header_flag)
836 goto parse_common_info;
841 v->fcm = decode012(gb);
843 if (v->fcm == ILACE_FIELD)
845 if (!v->warn_interlaced++)
846 av_log(v->s.avctx, AV_LOG_ERROR,
847 "Interlaced frames/fields support is incomplete\n");
850 v->fcm = PROGRESSIVE;
854 v->fptype = get_bits(gb, 3);
855 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
856 if (v->fptype & 4) // B-picture
857 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
859 switch (get_unary(gb, 0, 4)) {
861 v->s.pict_type = AV_PICTURE_TYPE_P;
864 v->s.pict_type = AV_PICTURE_TYPE_B;
867 v->s.pict_type = AV_PICTURE_TYPE_I;
870 v->s.pict_type = AV_PICTURE_TYPE_BI;
873 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
874 v->p_frame_skipped = 1;
881 if (!v->interlace || v->psf) {
882 v->rptfrm = get_bits(gb, 2);
884 v->tff = get_bits1(gb);
885 v->rff = get_bits1(gb);
888 if (v->panscanflag) {
889 av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
892 if (v->p_frame_skipped) {
895 v->rnd = get_bits1(gb);
897 v->uvsamp = get_bits1(gb);
899 if (!v->refdist_flag)
901 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
902 v->refdist = get_bits(gb, 2);
904 v->refdist += get_unary(gb, 0, 16);
906 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
907 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
908 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
909 v->frfd = (v->bfraction * v->refdist) >> 8;
910 v->brfd = v->refdist - v->frfd - 1;
914 goto parse_common_info;
916 if (v->fcm == PROGRESSIVE) {
918 v->interpfrm = get_bits1(gb);
919 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
920 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
921 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
922 if (v->bfraction == 0) {
923 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
930 v->cur_field_type = !(v->tff ^ v->second_field);
931 pqindex = get_bits(gb, 5);
934 v->pqindex = pqindex;
935 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
936 v->pq = ff_vc1_pquant_table[0][pqindex];
938 v->pq = ff_vc1_pquant_table[1][pqindex];
941 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
942 v->pquantizer = pqindex < 9;
943 if (v->quantizer_mode == QUANT_NON_UNIFORM)
945 v->pqindex = pqindex;
947 v->halfpq = get_bits1(gb);
950 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
951 v->pquantizer = get_bits1(gb);
953 v->postproc = get_bits(gb, 2);
955 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
961 switch (v->s.pict_type) {
962 case AV_PICTURE_TYPE_I:
963 case AV_PICTURE_TYPE_BI:
964 if (v->fcm == ILACE_FRAME) { //interlace frame picture
965 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
968 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
969 "Imode: %i, Invert: %i\n", status>>1, status&1);
971 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
974 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
975 "Imode: %i, Invert: %i\n", status>>1, status&1);
976 v->condover = CONDOVER_NONE;
977 if (v->overlap && v->pq <= 8) {
978 v->condover = decode012(gb);
979 if (v->condover == CONDOVER_SELECT) {
980 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
983 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
984 "Imode: %i, Invert: %i\n", status>>1, status&1);
988 case AV_PICTURE_TYPE_P:
990 v->numref = get_bits1(gb);
992 v->reffield = get_bits1(gb);
993 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
997 v->mvrange = get_unary(gb, 0, 3);
1001 if (v->extended_dmv)
1002 v->dmvrange = get_unary(gb, 0, 3);
1005 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1006 v->fourmvswitch = get_bits1(gb);
1007 v->intcomp = get_bits1(gb);
1009 v->lumscale = get_bits(gb, 6);
1010 v->lumshift = get_bits(gb, 6);
1011 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1013 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1014 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1015 "Imode: %i, Invert: %i\n", status>>1, status&1);
1016 mbmodetab = get_bits(gb, 2);
1017 if (v->fourmvswitch)
1018 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1020 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1021 imvtab = get_bits(gb, 2);
1022 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1023 // interlaced p-picture cbpcy range is [1, 63]
1024 icbptab = get_bits(gb, 3);
1025 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1026 twomvbptab = get_bits(gb, 2);
1027 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1028 if (v->fourmvswitch) {
1029 fourmvbptab = get_bits(gb, 2);
1030 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1034 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1035 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1036 v->range_x = 1 << (v->k_x - 1);
1037 v->range_y = 1 << (v->k_y - 1);
1041 else if (v->pq < 13)
1045 if (v->fcm != ILACE_FRAME) {
1047 mvmode = get_unary(gb, 1, 4);
1048 lowquant = (v->pq > 12) ? 0 : 1;
1049 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1050 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1052 mvmode2 = get_unary(gb, 1, 3);
1053 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1055 v->intcompfield = decode210(gb);
1056 v->lumscale = get_bits(gb, 6);
1057 v->lumshift = get_bits(gb, 6);
1058 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1059 if ((v->field_mode) && !v->intcompfield) {
1060 v->lumscale2 = get_bits(gb, 6);
1061 v->lumshift2 = get_bits(gb, 6);
1062 INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1066 v->qs_last = v->s.quarter_sample;
1067 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1068 v->s.quarter_sample = 0;
1069 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1070 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1071 v->s.quarter_sample = 0;
1073 v->s.quarter_sample = 1;
1075 v->s.quarter_sample = 1;
1076 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1077 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1078 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1080 if (v->fcm == PROGRESSIVE) { // progressive
1081 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1082 v->mv_mode2 == MV_PMODE_MIXED_MV)
1083 || v->mv_mode == MV_PMODE_MIXED_MV) {
1084 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1087 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1088 "Imode: %i, Invert: %i\n", status>>1, status&1);
1090 v->mv_type_is_raw = 0;
1091 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1093 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1096 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1097 "Imode: %i, Invert: %i\n", status>>1, status&1);
1099 /* Hopefully this is correct for P frames */
1100 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1101 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1102 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1103 v->qs_last = v->s.quarter_sample;
1104 v->s.quarter_sample = 1;
1106 } else { // field interlaced
1107 mbmodetab = get_bits(gb, 3);
1108 imvtab = get_bits(gb, 2 + v->numref);
1110 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1112 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1113 icbptab = get_bits(gb, 3);
1114 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1115 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1116 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1117 fourmvbptab = get_bits(gb, 2);
1118 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1119 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1121 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1125 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1126 vop_dquant_decoding(v);
1129 v->ttfrm = 0; //FIXME Is that so ?
1130 if (v->vstransform) {
1131 v->ttmbf = get_bits1(gb);
1133 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1140 case AV_PICTURE_TYPE_B:
1141 // TODO: implement interlaced frame B picture decoding
1142 if (v->fcm == ILACE_FRAME)
1145 v->mvrange = get_unary(gb, 0, 3);
1148 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1149 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1150 v->range_x = 1 << (v->k_x - 1);
1151 v->range_y = 1 << (v->k_y - 1);
1155 else if (v->pq < 13)
1160 if (v->field_mode) {
1162 if (v->extended_dmv)
1163 v->dmvrange = get_unary(gb, 0, 3);
1164 mvmode = get_unary(gb, 1, 3);
1165 lowquant = (v->pq > 12) ? 0 : 1;
1166 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1167 v->qs_last = v->s.quarter_sample;
1168 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1169 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1170 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1173 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1174 "Imode: %i, Invert: %i\n", status>>1, status&1);
1175 mbmodetab = get_bits(gb, 3);
1176 if (v->mv_mode == MV_PMODE_MIXED_MV)
1177 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1179 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1180 imvtab = get_bits(gb, 3);
1181 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1182 icbptab = get_bits(gb, 3);
1183 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1184 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1185 fourmvbptab = get_bits(gb, 2);
1186 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1188 v->numref = 1; // interlaced field B pictures are always 2-ref
1190 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1191 v->qs_last = v->s.quarter_sample;
1192 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1193 v->s.mspel = v->s.quarter_sample;
1194 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1197 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1198 "Imode: %i, Invert: %i\n", status>>1, status&1);
1199 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1202 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1203 "Imode: %i, Invert: %i\n", status>>1, status&1);
1204 v->s.mv_table_index = get_bits(gb, 2);
1205 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1209 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1210 vop_dquant_decoding(v);
1214 if (v->vstransform) {
1215 v->ttmbf = get_bits1(gb);
1217 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1227 v->c_ac_table_index = decode012(gb);
1228 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1229 v->y_ac_table_index = decode012(gb);
1232 v->s.dc_table_index = get_bits1(gb);
1233 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1235 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1236 vop_dquant_decoding(v);
1240 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1241 v->s.pict_type = AV_PICTURE_TYPE_B;
1247 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1249 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1250 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1251 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1252 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1253 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1254 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1255 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1256 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1257 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1258 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1259 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1260 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1261 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1262 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1263 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1264 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1265 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1266 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1267 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1268 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1269 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1270 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1271 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1272 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1273 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1274 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1275 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1276 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1277 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1278 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1279 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1282 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1283 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1284 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1285 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1286 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1287 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1288 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1289 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1290 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1291 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1292 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1293 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1294 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1295 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1296 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1297 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1298 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1299 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1300 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1301 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1302 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1303 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1304 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1305 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1306 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1307 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1308 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1309 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1313 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1314 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1315 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1316 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1317 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1318 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1319 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1320 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1321 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1322 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1323 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1324 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1325 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1326 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1327 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1328 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1329 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1330 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1331 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1332 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1333 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1334 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1338 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1339 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1340 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1341 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1342 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1343 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1344 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1345 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1346 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1347 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1348 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1349 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1350 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1351 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1352 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1353 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1354 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1355 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1356 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1357 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1358 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1359 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1360 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1361 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1362 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1365 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1366 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1367 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1368 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1369 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1370 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1371 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1372 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1373 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1374 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1375 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1376 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1377 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1378 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1379 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1380 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1381 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1385 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1386 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1387 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1388 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1389 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1390 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1391 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1392 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1393 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1394 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1395 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1396 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1397 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1398 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1399 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1400 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1401 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1405 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1406 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1407 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1408 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1409 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1410 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1411 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1412 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1413 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1414 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1415 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1416 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1417 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1418 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1419 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1420 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1421 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1422 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1423 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1424 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1425 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1426 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1427 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1428 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1429 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1430 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1431 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1435 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1436 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1437 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1438 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1439 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1440 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1441 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1442 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1443 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1444 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1445 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1446 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1447 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1448 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1449 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1450 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1451 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1452 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1453 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1454 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1455 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1456 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1457 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1458 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1459 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1460 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1461 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1462 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1463 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1468 static const uint16_t vlc_offs[] = {
1469 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1470 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1471 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1472 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1473 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1474 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1475 31714, 31746, 31778, 32306, 32340, 32372
1479 * Init VC-1 specific tables and VC1Context members
1480 * @param v The VC1Context to initialize
1483 int ff_vc1_init_common(VC1Context *v)
1485 static int done = 0;
1487 static VLC_TYPE vlc_table[32372][2];
1489 v->hrd_rate = v->hrd_buffer = NULL;
1493 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1494 ff_vc1_bfraction_bits, 1, 1,
1495 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1496 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1497 ff_vc1_norm2_bits, 1, 1,
1498 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1499 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1500 ff_vc1_norm6_bits, 1, 1,
1501 ff_vc1_norm6_codes, 2, 2, 556);
1502 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1503 ff_vc1_imode_bits, 1, 1,
1504 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1505 for (i = 0; i < 3; i++) {
1506 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1507 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1508 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1509 ff_vc1_ttmb_bits[i], 1, 1,
1510 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1511 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1512 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1513 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1514 ff_vc1_ttblk_bits[i], 1, 1,
1515 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1516 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1517 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1518 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1519 ff_vc1_subblkpat_bits[i], 1, 1,
1520 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1522 for (i = 0; i < 4; i++) {
1523 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1524 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1525 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1526 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1527 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1528 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1529 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1530 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1531 ff_vc1_cbpcy_p_bits[i], 1, 1,
1532 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1533 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1534 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1535 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1536 ff_vc1_mv_diff_bits[i], 1, 1,
1537 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1539 for (i = 0; i < 8; i++) {
1540 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1541 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1542 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1543 &vc1_ac_tables[i][0][1], 8, 4,
1544 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1545 /* initialize interlaced MVDATA tables (2-Ref) */
1546 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1547 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1548 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1549 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1550 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1552 for (i = 0; i < 4; i++) {
1553 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1554 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1555 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1556 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1557 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1558 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1559 /* initialize NON-4MV MBMODE VLC tables for the same */
1560 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1561 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1562 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1563 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1564 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1565 /* initialize interlaced MVDATA tables (1-Ref) */
1566 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1567 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1568 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1569 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1570 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1572 for (i = 0; i < 4; i++) {
1573 /* Initialize 2MV Block pattern VLC tables */
1574 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1575 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1576 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1577 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1578 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1580 for (i = 0; i < 8; i++) {
1581 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1582 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1583 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1584 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1585 ff_vc1_icbpcy_p_bits[i], 1, 1,
1586 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1587 /* Initialize interlaced field picture MBMODE VLC tables */
1588 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1589 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1590 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1591 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1592 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1593 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1594 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1595 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1596 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1597 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1602 /* Other defaults */
1604 v->mvrange = 0; /* 7.1.1.18, p80 */