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