git.sesse.net Git - ffmpeg/blob - libavcodec/vc1.c

   1 /*
   2  * VC-1 and WMV3 decoder common code
   3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
   4  * Copyright (c) 2006-2007 Konstantin Shishkov
   5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 /**
  25  * @file
  26  * VC-1 and WMV3 decoder common code
  27  *
  28  */
  29
  30 #include "internal.h"
  31 #include "avcodec.h"
  32 #include "mpegvideo.h"
  33 #include "vc1.h"
  34 #include "vc1data.h"
  35 #include "msmpeg4data.h"
  36 #include "unary.h"
  37 #include "simple_idct.h"
  38
  39 #undef NDEBUG
  40 #include <assert.h>
  41
  42 /***********************************************************************/
  43 /**
  44  * @name VC-1 Bitplane decoding
  45  * @see 8.7, p56
  46  * @{
  47  */
  48
  49 /**
  50  * Imode types
  51  * @{
  52  */
  53 enum Imode {
  54     IMODE_RAW,
  55     IMODE_NORM2,
  56     IMODE_DIFF2,
  57     IMODE_NORM6,
  58     IMODE_DIFF6,
  59     IMODE_ROWSKIP,
  60     IMODE_COLSKIP
  61 };
  62 /** @} */ //imode defines
  63
  64 /** Decode rows by checking if they are skipped
  65  * @param plane Buffer to store decoded bits
  66  * @param[in] width Width of this buffer
  67  * @param[in] height Height of this buffer
  68  * @param[in] stride of this buffer
  69  */
  70 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
  71                            GetBitContext *gb)
  72 {
  73     int x, y;
  74
  75     for (y = 0; y < height; y++) {
  76         if (!get_bits1(gb)) //rowskip
  77             memset(plane, 0, width);
  78         else
  79             for (x = 0; x < width; x++)
  80                 plane[x] = get_bits1(gb);
  81         plane += stride;
  82     }
  83 }
  84
  85 /** Decode columns by checking if they are skipped
  86  * @param plane Buffer to store decoded bits
  87  * @param[in] width Width of this buffer
  88  * @param[in] height Height of this buffer
  89  * @param[in] stride of this buffer
  90  * @todo FIXME: Optimize
  91  */
  92 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
  93                            GetBitContext *gb)
  94 {
  95     int x, y;
  96
  97     for (x = 0; x < width; x++) {
  98         if (!get_bits1(gb)) //colskip
  99             for (y = 0; y < height; y++)
 100                 plane[y*stride] = 0;
 101         else
 102             for (y = 0; y < height; y++)
 103                 plane[y*stride] = get_bits1(gb);
 104         plane ++;
 105     }
 106 }
 107
 108 /** Decode a bitplane's bits
 109  * @param data bitplane where to store the decode bits
 110  * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
 111  * @param v VC-1 context for bit reading and logging
 112  * @return Status
 113  * @todo FIXME: Optimize
 114  */
 115 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
 116 {
 117     GetBitContext *gb = &v->s.gb;
 118
 119     int imode, x, y, code, offset;
 120     uint8_t invert, *planep = data;
 121     int width, height, stride;
 122
 123     width  = v->s.mb_width;
 124     height = v->s.mb_height >> v->field_mode;
 125     stride = v->s.mb_stride;
 126     invert = get_bits1(gb);
 127     imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
 128
 129     *raw_flag = 0;
 130     switch (imode) {
 131     case IMODE_RAW:
 132         //Data is actually read in the MB layer (same for all tests == "raw")
 133         *raw_flag = 1; //invert ignored
 134         return invert;
 135     case IMODE_DIFF2:
 136     case IMODE_NORM2:
 137         if ((height * width) & 1) {
 138             *planep++ = get_bits1(gb);
 139             offset    = 1;
 140         }
 141         else
 142             offset = 0;
 143         // decode bitplane as one long line
 144         for (y = offset; y < height * width; y += 2) {
 145             code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
 146             *planep++ = code & 1;
 147             offset++;
 148             if (offset == width) {
 149                 offset  = 0;
 150                 planep += stride - width;
 151             }
 152             *planep++ = code >> 1;
 153             offset++;
 154             if (offset == width) {
 155                 offset  = 0;
 156                 planep += stride - width;
 157             }
 158         }
 159         break;
 160     case IMODE_DIFF6:
 161     case IMODE_NORM6:
 162         if (!(height % 3) && (width % 3)) { // use 2x3 decoding
 163             for (y = 0; y < height; y += 3) {
 164                 for (x = width & 1; x < width; x += 2) {
 165                     code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
 166                     if (code < 0) {
 167                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
 168                         return -1;
 169                     }
 170                     planep[x + 0]              = (code >> 0) & 1;
 171                     planep[x + 1]              = (code >> 1) & 1;
 172                     planep[x + 0 + stride]     = (code >> 2) & 1;
 173                     planep[x + 1 + stride]     = (code >> 3) & 1;
 174                     planep[x + 0 + stride * 2] = (code >> 4) & 1;
 175                     planep[x + 1 + stride * 2] = (code >> 5) & 1;
 176                 }
 177                 planep += stride * 3;
 178             }
 179             if (width & 1)
 180                 decode_colskip(data, 1, height, stride, &v->s.gb);
 181         } else { // 3x2
 182             planep += (height & 1) * stride;
 183             for (y = height & 1; y < height; y += 2) {
 184                 for (x = width % 3; x < width; x += 3) {
 185                     code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
 186                     if (code < 0) {
 187                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
 188                         return -1;
 189                     }
 190                     planep[x + 0]          = (code >> 0) & 1;
 191                     planep[x + 1]          = (code >> 1) & 1;
 192                     planep[x + 2]          = (code >> 2) & 1;
 193                     planep[x + 0 + stride] = (code >> 3) & 1;
 194                     planep[x + 1 + stride] = (code >> 4) & 1;
 195                     planep[x + 2 + stride] = (code >> 5) & 1;
 196                 }
 197                 planep += stride * 2;
 198             }
 199             x = width % 3;
 200             if (x)
 201                 decode_colskip(data,             x, height, stride, &v->s.gb);
 202             if (height & 1)
 203                 decode_rowskip(data + x, width - x,      1, stride, &v->s.gb);
 204         }
 205         break;
 206     case IMODE_ROWSKIP:
 207         decode_rowskip(data, width, height, stride, &v->s.gb);
 208         break;
 209     case IMODE_COLSKIP:
 210         decode_colskip(data, width, height, stride, &v->s.gb);
 211         break;
 212     default:
 213         break;
 214     }
 215
 216     /* Applying diff operator */
 217     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
 218         planep = data;
 219         planep[0] ^= invert;
 220         for (x = 1; x < width; x++)
 221             planep[x] ^= planep[x-1];
 222         for (y = 1; y < height; y++) {
 223             planep += stride;
 224             planep[0] ^= planep[-stride];
 225             for (x = 1; x < width; x++) {
 226                 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
 227                 else                                 planep[x] ^= planep[x-1];
 228             }
 229         }
 230     } else if (invert) {
 231         planep = data;
 232         for (x = 0; x < stride * height; x++)
 233             planep[x] = !planep[x]; //FIXME stride
 234     }
 235     return (imode << 1) + invert;
 236 }
 237
 238 /** @} */ //Bitplane group
 239
 240 /***********************************************************************/
 241 /** VOP Dquant decoding
 242  * @param v VC-1 Context
 243  */
 244 static int vop_dquant_decoding(VC1Context *v)
 245 {
 246     GetBitContext *gb = &v->s.gb;
 247     int pqdiff;
 248
 249     //variable size
 250     if (v->dquant == 2) {
 251         pqdiff = get_bits(gb, 3);
 252         if (pqdiff == 7)
 253             v->altpq = get_bits(gb, 5);
 254         else
 255             v->altpq = v->pq + pqdiff + 1;
 256     } else {
 257         v->dquantfrm = get_bits1(gb);
 258         if (v->dquantfrm) {
 259             v->dqprofile = get_bits(gb, 2);
 260             switch (v->dqprofile) {
 261             case DQPROFILE_SINGLE_EDGE:
 262             case DQPROFILE_DOUBLE_EDGES:
 263                 v->dqsbedge = get_bits(gb, 2);
 264                 break;
 265             case DQPROFILE_ALL_MBS:
 266                 v->dqbilevel = get_bits1(gb);
 267                 if (!v->dqbilevel)
 268                     v->halfpq = 0;
 269             default:
 270                 break; //Forbidden ?
 271             }
 272             if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
 273                 pqdiff = get_bits(gb, 3);
 274                 if (pqdiff == 7)
 275                     v->altpq = get_bits(gb, 5);
 276                 else
 277                     v->altpq = v->pq + pqdiff + 1;
 278             }
 279         }
 280     }
 281     return 0;
 282 }
 283
 284 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
 285
 286 /**
 287  * Decode Simple/Main Profiles sequence header
 288  * @see Figure 7-8, p16-17
 289  * @param avctx Codec context
 290  * @param gb GetBit context initialized from Codec context extra_data
 291  * @return Status
 292  */
 293 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
 294 {
 295     av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
 296     v->profile = get_bits(gb, 2);
 297     if (v->profile == PROFILE_COMPLEX) {
 298         av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
 299     }
 300
 301     if (v->profile == PROFILE_ADVANCED) {
 302         v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
 303         v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
 304         return decode_sequence_header_adv(v, gb);
 305     } else {
 306         v->zz_8x4 = ff_wmv2_scantableA;
 307         v->zz_4x8 = ff_wmv2_scantableB;
 308         v->res_y411   = get_bits1(gb);
 309         v->res_sprite = get_bits1(gb);
 310         if (v->res_y411) {
 311             av_log(avctx, AV_LOG_ERROR,
 312                    "Old interlaced mode is not supported\n");
 313             return -1;
 314         }
 315     }
 316
 317     // (fps-2)/4 (->30)
 318     v->frmrtq_postproc = get_bits(gb, 3); //common
 319     // (bitrate-32kbps)/64kbps
 320     v->bitrtq_postproc = get_bits(gb, 5); //common
 321     v->s.loop_filter   = get_bits1(gb); //common
 322     if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
 323         av_log(avctx, AV_LOG_ERROR,
 324                "LOOPFILTER shall not be enabled in Simple Profile\n");
 325     }
 326     if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
 327         v->s.loop_filter = 0;
 328
 329     v->res_x8          = get_bits1(gb); //reserved
 330     v->multires        = get_bits1(gb);
 331     v->res_fasttx      = get_bits1(gb);
 332     if (!v->res_fasttx) {
 333         v->vc1dsp.vc1_inv_trans_8x8    = ff_simple_idct_8;
 334         v->vc1dsp.vc1_inv_trans_8x4    = ff_simple_idct84_add;
 335         v->vc1dsp.vc1_inv_trans_4x8    = ff_simple_idct48_add;
 336         v->vc1dsp.vc1_inv_trans_4x4    = ff_simple_idct44_add;
 337         v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
 338         v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
 339         v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
 340         v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
 341     }
 342
 343     v->fastuvmc        = get_bits1(gb); //common
 344     if (!v->profile && !v->fastuvmc) {
 345         av_log(avctx, AV_LOG_ERROR,
 346                "FASTUVMC unavailable in Simple Profile\n");
 347         return -1;
 348     }
 349     v->extended_mv     = get_bits1(gb); //common
 350     if (!v->profile && v->extended_mv)
 351     {
 352         av_log(avctx, AV_LOG_ERROR,
 353                "Extended MVs unavailable in Simple Profile\n");
 354         return -1;
 355     }
 356     v->dquant          = get_bits(gb, 2); //common
 357     v->vstransform     = get_bits1(gb); //common
 358
 359     v->res_transtab    = get_bits1(gb);
 360     if (v->res_transtab)
 361     {
 362         av_log(avctx, AV_LOG_ERROR,
 363                "1 for reserved RES_TRANSTAB is forbidden\n");
 364         return -1;
 365     }
 366
 367     v->overlap         = get_bits1(gb); //common
 368
 369     v->s.resync_marker = get_bits1(gb);
 370     v->rangered        = get_bits1(gb);
 371     if (v->rangered && v->profile == PROFILE_SIMPLE) {
 372         av_log(avctx, AV_LOG_INFO,
 373                "RANGERED should be set to 0 in Simple Profile\n");
 374     }
 375
 376     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
 377     v->quantizer_mode = get_bits(gb, 2); //common
 378
 379     v->finterpflag = get_bits1(gb); //common
 380
 381     if (v->res_sprite) {
 382         int w = get_bits(gb, 11);
 383         int h = get_bits(gb, 11);
 384         avcodec_set_dimensions(v->s.avctx, w, h);
 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");
 389             return -1;
 390         }
 391         skip_bits(gb, 3); //slice code
 392         v->res_rtm_flag = 0;
 393     } else {
 394         v->res_rtm_flag = get_bits1(gb); //reserved
 395     }
 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");
 399         //return -1;
 400     }
 401     //TODO: figure out what they mean (always 0x402F)
 402     if (!v->res_fasttx)
 403         skip_bits(gb, 16);
 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);
 413     return 0;
 414 }
 415
 416 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
 417 {
 418     v->res_rtm_flag = 1;
 419     v->level = get_bits(gb, 3);
 420     if (v->level >= 5) {
 421         av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
 422     }
 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");
 427         return -1;
 428     }
 429
 430     // (fps-2)/4 (->30)
 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
 435
 436     v->max_coded_width       = (get_bits(gb, 12) + 1) << 1;
 437     v->max_coded_height      = (get_bits(gb, 12) + 1) << 1;
 438     v->broadcast             = get_bits1(gb);
 439     v->interlace             = get_bits1(gb);
 440     v->tfcntrflag            = get_bits1(gb);
 441     v->finterpflag           = get_bits1(gb);
 442     skip_bits1(gb); // reserved
 443
 444     av_log(v->s.avctx, AV_LOG_DEBUG,
 445            "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
 446            "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
 447            "TFCTRflag=%i, FINTERPflag=%i\n",
 448            v->level, v->frmrtq_postproc, v->bitrtq_postproc,
 449            v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
 450            v->tfcntrflag, v->finterpflag);
 451
 452     v->psf = get_bits1(gb);
 453     if (v->psf) { //PsF, 6.1.13
 454         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
 455         return -1;
 456     }
 457     v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
 458     if (get_bits1(gb)) { //Display Info - decoding is not affected by it
 459         int w, h, ar = 0;
 460         av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
 461         w = get_bits(gb, 14) + 1;
 462         h = get_bits(gb, 14) + 1;
 463         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
 464         if (get_bits1(gb))
 465             ar = get_bits(gb, 4);
 466         if (ar && ar < 14) {
 467             v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
 468         } else if (ar == 15) {
 469             w = get_bits(gb, 8) + 1;
 470             h = get_bits(gb, 8) + 1;
 471             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
 472         } else {
 473             av_reduce(&v->s.avctx->sample_aspect_ratio.num,
 474                       &v->s.avctx->sample_aspect_ratio.den,
 475                       v->s.avctx->height * w,
 476                       v->s.avctx->width * h,
 477                       1 << 30);
 478         }
 479         av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
 480                v->s.avctx->sample_aspect_ratio.num,
 481                v->s.avctx->sample_aspect_ratio.den);
 482
 483         if (get_bits1(gb)) { //framerate stuff
 484             if (get_bits1(gb)) {
 485                 v->s.avctx->time_base.num = 32;
 486                 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
 487             } else {
 488                 int nr, dr;
 489                 nr = get_bits(gb, 8);
 490                 dr = get_bits(gb, 4);
 491                 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
 492                     v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
 493                     v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
 494                 }
 495             }
 496             if (v->broadcast) { // Pulldown may be present
 497                 v->s.avctx->time_base.den  *= 2;
 498                 v->s.avctx->ticks_per_frame = 2;
 499             }
 500         }
 501
 502         if (get_bits1(gb)) {
 503             v->s.avctx->color_primaries = get_bits(gb, 8);
 504             v->s.avctx->color_trc       = get_bits(gb, 8);
 505             v->s.avctx->colorspace      = get_bits(gb, 8);
 506             v->s.avctx->color_range     = AVCOL_RANGE_MPEG;
 507         }
 508     }
 509
 510     v->hrd_param_flag = get_bits1(gb);
 511     if (v->hrd_param_flag) {
 512         int i;
 513         v->hrd_num_leaky_buckets = get_bits(gb, 5);
 514         skip_bits(gb, 4); //bitrate exponent
 515         skip_bits(gb, 4); //buffer size exponent
 516         for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
 517             skip_bits(gb, 16); //hrd_rate[n]
 518             skip_bits(gb, 16); //hrd_buffer[n]
 519         }
 520     }
 521     return 0;
 522 }
 523
 524 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
 525 {
 526     int i;
 527     int w,h;
 528
 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     if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
 536         v->s.loop_filter = 0;
 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);
 543
 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]
 547         }
 548     }
 549
 550     if(get_bits1(gb)){
 551         w = (get_bits(gb, 12)+1)<<1;
 552         h = (get_bits(gb, 12)+1)<<1;
 553     } else {
 554         w = v->max_coded_width;
 555         h = v->max_coded_height;
 556     }
 557     avcodec_set_dimensions(avctx, w, h);
 558     if (v->extended_mv)
 559         v->extended_dmv = get_bits1(gb);
 560     if ((v->range_mapy_flag = get_bits1(gb))) {
 561         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
 562         v->range_mapy = get_bits(gb, 3);
 563     }
 564     if ((v->range_mapuv_flag = get_bits1(gb))) {
 565         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
 566         v->range_mapuv = get_bits(gb, 3);
 567     }
 568
 569     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
 570            "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
 571            "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
 572            "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
 573            v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
 574            v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
 575
 576     return 0;
 577 }
 578
 579 /* fill lookup tables for intensity compensation */
 580 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain)   do {\
 581     int scale, shift, i;                            \
 582     if (!lumscale) {                                \
 583         scale = -64;                                \
 584         shift = (255 - lumshift * 2) << 6;          \
 585         if (lumshift > 31)                          \
 586             shift += 128 << 6;                      \
 587     } else {                                        \
 588         scale = lumscale + 32;                      \
 589         if (lumshift > 31)                          \
 590             shift = (lumshift - 64) << 6;           \
 591         else                                        \
 592             shift = lumshift << 6;                  \
 593     }                                               \
 594     for (i = 0; i < 256; i++) {                     \
 595         int iy = chain ? luty[i] : i;               \
 596         int iu = chain ? lutuv[i] : i;              \
 597         luty[i]  = av_clip_uint8((scale * iy + shift + 32) >> 6);           \
 598         lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);  \
 599     } \
 600     }while(0)
 601
 602
 603 static void rotate_luts(VC1Context *v)
 604 {
 605 #define ROTATE(DEF, L, N, C, A) do {\
 606         if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) {\
 607             C = A;\
 608         } else {\
 609             DEF;\
 610             memcpy(&tmp, &L  , sizeof(tmp));\
 611             memcpy(&L  , &N  , sizeof(tmp));\
 612             memcpy(&N  , &tmp, sizeof(tmp));\
 613             C = N;\
 614         }\
 615     }while(0)
 616
 617         ROTATE(int tmp            , v->last_use_ic, v->next_use_ic, v->curr_use_ic, v->aux_use_ic);
 618         ROTATE(uint8_t tmp[2][256], v->last_luty , v->next_luty , v->curr_luty , v->aux_luty);
 619         ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
 620
 621     INIT_LUT(32, 0 , v->curr_luty[0] , v->curr_lutuv[0] , 0);
 622     INIT_LUT(32, 0 , v->curr_luty[1] , v->curr_lutuv[1] , 0);
 623     v->curr_use_ic = 0;
 624 }
 625
 626 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
 627 {
 628     int pqindex, lowquant, status;
 629
 630     if (v->finterpflag)
 631         v->interpfrm = get_bits1(gb);
 632     if (!v->s.avctx->codec)
 633         return -1;
 634     if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
 635         v->respic   =
 636         v->rangered =
 637         v->multires = get_bits(gb, 2) == 1;
 638     else
 639         skip_bits(gb, 2); //framecnt unused
 640     v->rangeredfrm = 0;
 641     if (v->rangered)
 642         v->rangeredfrm = get_bits1(gb);
 643     v->s.pict_type = get_bits1(gb);
 644     if (v->s.avctx->max_b_frames) {
 645         if (!v->s.pict_type) {
 646             if (get_bits1(gb))
 647                 v->s.pict_type = AV_PICTURE_TYPE_I;
 648             else
 649                 v->s.pict_type = AV_PICTURE_TYPE_B;
 650         } else
 651             v->s.pict_type = AV_PICTURE_TYPE_P;
 652     } else
 653         v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
 654
 655     v->bi_type = 0;
 656     if (v->s.pict_type == AV_PICTURE_TYPE_B) {
 657         v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
 658         v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
 659         if (v->bfraction == 0) {
 660             v->s.pict_type = AV_PICTURE_TYPE_BI;
 661         }
 662     }
 663     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
 664         skip_bits(gb, 7); // skip buffer fullness
 665
 666     if (v->parse_only)
 667         return 0;
 668
 669     /* calculate RND */
 670     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
 671         v->rnd = 1;
 672     if (v->s.pict_type == AV_PICTURE_TYPE_P)
 673         v->rnd ^= 1;
 674
 675     /* Quantizer stuff */
 676     pqindex = get_bits(gb, 5);
 677     if (!pqindex)
 678         return -1;
 679     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 680         v->pq = ff_vc1_pquant_table[0][pqindex];
 681     else
 682         v->pq = ff_vc1_pquant_table[1][pqindex];
 683
 684     v->pquantizer = 1;
 685     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 686         v->pquantizer = pqindex < 9;
 687     if (v->quantizer_mode == QUANT_NON_UNIFORM)
 688         v->pquantizer = 0;
 689     v->pqindex = pqindex;
 690     if (pqindex < 9)
 691         v->halfpq = get_bits1(gb);
 692     else
 693         v->halfpq = 0;
 694     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
 695         v->pquantizer = get_bits1(gb);
 696     v->dquantfrm = 0;
 697     if (v->extended_mv == 1)
 698         v->mvrange = get_unary(gb, 0, 3);
 699     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
 700     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
 701     v->range_x = 1 << (v->k_x - 1);
 702     v->range_y = 1 << (v->k_y - 1);
 703     if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
 704         v->respic = get_bits(gb, 2);
 705
 706     if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
 707         v->x8_type = get_bits1(gb);
 708     } else
 709         v->x8_type = 0;
 710     av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
 711             (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
 712             pqindex, v->pq, v->halfpq, v->rangeredfrm);
 713
 714     if(v->first_pic_header_flag) {
 715         rotate_luts(v);
 716     }
 717
 718     switch (v->s.pict_type) {
 719     case AV_PICTURE_TYPE_P:
 720         if (v->pq < 5)       v->tt_index = 0;
 721         else if (v->pq < 13) v->tt_index = 1;
 722         else                 v->tt_index = 2;
 723
 724         lowquant = (v->pq > 12) ? 0 : 1;
 725         v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
 726         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 727             v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
 728             v->lumscale = get_bits(gb, 6);
 729             v->lumshift = get_bits(gb, 6);
 730             v->last_use_ic   = 1;
 731             /* fill lookup tables for intensity compensation */
 732             INIT_LUT(v->lumscale, v->lumshift , v->last_luty[0] , v->last_lutuv[0] , 1);
 733             INIT_LUT(v->lumscale, v->lumshift , v->last_luty[1] , v->last_lutuv[1] , 1);
 734         }
 735         v->qs_last = v->s.quarter_sample;
 736         if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
 737             v->s.quarter_sample = 0;
 738         else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 739             if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
 740                 v->s.quarter_sample = 0;
 741             else
 742                 v->s.quarter_sample = 1;
 743         } else
 744             v->s.quarter_sample = 1;
 745         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));
 746
 747         if ((v->mv_mode  == MV_PMODE_INTENSITY_COMP &&
 748              v->mv_mode2 == MV_PMODE_MIXED_MV)      ||
 749             v->mv_mode   == MV_PMODE_MIXED_MV) {
 750             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
 751             if (status < 0)
 752                 return -1;
 753             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
 754                    "Imode: %i, Invert: %i\n", status>>1, status&1);
 755         } else {
 756             v->mv_type_is_raw = 0;
 757             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
 758         }
 759         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
 760         if (status < 0)
 761             return -1;
 762         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
 763                "Imode: %i, Invert: %i\n", status>>1, status&1);
 764
 765         /* Hopefully this is correct for P frames */
 766         v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
 767         v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
 768
 769         if (v->dquant) {
 770             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
 771             vop_dquant_decoding(v);
 772         }
 773
 774         v->ttfrm = 0; //FIXME Is that so ?
 775         if (v->vstransform) {
 776             v->ttmbf = get_bits1(gb);
 777             if (v->ttmbf) {
 778                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
 779             }
 780         } else {
 781             v->ttmbf = 1;
 782             v->ttfrm = TT_8X8;
 783         }
 784         break;
 785     case AV_PICTURE_TYPE_B:
 786         if (v->pq < 5)       v->tt_index = 0;
 787         else if (v->pq < 13) v->tt_index = 1;
 788         else                 v->tt_index = 2;
 789
 790         v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
 791         v->qs_last          = v->s.quarter_sample;
 792         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
 793         v->s.mspel          = v->s.quarter_sample;
 794
 795         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
 796         if (status < 0)
 797             return -1;
 798         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
 799                "Imode: %i, Invert: %i\n", status>>1, status&1);
 800         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
 801         if (status < 0)
 802             return -1;
 803         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
 804                "Imode: %i, Invert: %i\n", status>>1, status&1);
 805
 806         v->s.mv_table_index = get_bits(gb, 2);
 807         v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
 808
 809         if (v->dquant) {
 810             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
 811             vop_dquant_decoding(v);
 812         }
 813
 814         v->ttfrm = 0;
 815         if (v->vstransform) {
 816             v->ttmbf = get_bits1(gb);
 817             if (v->ttmbf) {
 818                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
 819             }
 820         } else {
 821             v->ttmbf = 1;
 822             v->ttfrm = TT_8X8;
 823         }
 824         break;
 825     }
 826
 827     if (!v->x8_type) {
 828         /* AC Syntax */
 829         v->c_ac_table_index = decode012(gb);
 830         if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
 831             v->y_ac_table_index = decode012(gb);
 832         }
 833         /* DC Syntax */
 834         v->s.dc_table_index = get_bits1(gb);
 835     }
 836
 837     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
 838         v->s.pict_type = AV_PICTURE_TYPE_B;
 839         v->bi_type     = 1;
 840     }
 841     return 0;
 842 }
 843
 844 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
 845 {
 846     int pqindex, lowquant;
 847     int status;
 848     int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
 849     int field_mode, fcm;
 850
 851     v->numref=0;
 852     v->p_frame_skipped = 0;
 853     if (v->second_field) {
 854         if(v->fcm!=2 || v->field_mode!=1)
 855             return -1;
 856         v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
 857         if (v->fptype & 4)
 858             v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
 859         v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
 860         if (!v->pic_header_flag)
 861             goto parse_common_info;
 862     }
 863
 864     field_mode = 0;
 865     if (v->interlace) {
 866         fcm = decode012(gb);
 867         if (fcm) {
 868             if (fcm == ILACE_FIELD)
 869                 field_mode = 1;
 870         }
 871     } else {
 872         fcm = PROGRESSIVE;
 873     }
 874     if (!v->first_pic_header_flag && v->field_mode != field_mode)
 875         return -1;
 876     v->field_mode = field_mode;
 877     v->fcm = fcm;
 878
 879     if (v->field_mode) {
 880         v->fptype = get_bits(gb, 3);
 881         v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
 882         if (v->fptype & 4) // B-picture
 883             v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
 884     } else {
 885         switch (get_unary(gb, 0, 4)) {
 886         case 0:
 887             v->s.pict_type = AV_PICTURE_TYPE_P;
 888             break;
 889         case 1:
 890             v->s.pict_type = AV_PICTURE_TYPE_B;
 891             break;
 892         case 2:
 893             v->s.pict_type = AV_PICTURE_TYPE_I;
 894             break;
 895         case 3:
 896             v->s.pict_type = AV_PICTURE_TYPE_BI;
 897             break;
 898         case 4:
 899             v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
 900             v->p_frame_skipped = 1;
 901             break;
 902         }
 903     }
 904     if (v->tfcntrflag)
 905         skip_bits(gb, 8);
 906     if (v->broadcast) {
 907         if (!v->interlace || v->psf) {
 908             v->rptfrm = get_bits(gb, 2);
 909         } else {
 910             v->tff = get_bits1(gb);
 911             v->rff = get_bits1(gb);
 912         }
 913     } else {
 914         v->tff = 1;
 915     }
 916     if (v->panscanflag) {
 917         avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
 918         //...
 919     }
 920     if (v->p_frame_skipped) {
 921         return 0;
 922     }
 923     v->rnd = get_bits1(gb);
 924     if (v->interlace)
 925         v->uvsamp = get_bits1(gb);
 926     if(!ff_vc1_bfraction_vlc.table)
 927         return 0; //parsing only, vlc tables havnt been allocated
 928     if (v->field_mode) {
 929         if (!v->refdist_flag)
 930             v->refdist = 0;
 931         else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
 932             v->refdist = get_bits(gb, 2);
 933             if (v->refdist == 3)
 934                 v->refdist += get_unary(gb, 0, 16);
 935         }
 936         if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
 937             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
 938             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
 939             v->frfd = (v->bfraction * v->refdist) >> 8;
 940             v->brfd = v->refdist - v->frfd - 1;
 941             if (v->brfd < 0)
 942                 v->brfd = 0;
 943         }
 944         goto parse_common_info;
 945     }
 946     if (v->fcm == PROGRESSIVE) {
 947         if (v->finterpflag)
 948             v->interpfrm = get_bits1(gb);
 949         if (v->s.pict_type == AV_PICTURE_TYPE_B) {
 950             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
 951             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
 952             if (v->bfraction == 0) {
 953                 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
 954             }
 955         }
 956     }
 957
 958     parse_common_info:
 959     if (v->field_mode)
 960         v->cur_field_type = !(v->tff ^ v->second_field);
 961     pqindex = get_bits(gb, 5);
 962     if (!pqindex)
 963         return -1;
 964     v->pqindex = pqindex;
 965     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 966         v->pq = ff_vc1_pquant_table[0][pqindex];
 967     else
 968         v->pq = ff_vc1_pquant_table[1][pqindex];
 969
 970     v->pquantizer = 1;
 971     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 972         v->pquantizer = pqindex < 9;
 973     if (v->quantizer_mode == QUANT_NON_UNIFORM)
 974         v->pquantizer = 0;
 975     v->pqindex = pqindex;
 976     if (pqindex < 9)
 977         v->halfpq = get_bits1(gb);
 978     else
 979         v->halfpq = 0;
 980     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
 981         v->pquantizer = get_bits1(gb);
 982     if (v->postprocflag)
 983         v->postproc = get_bits(gb, 2);
 984
 985     if (v->parse_only)
 986         return 0;
 987
 988     if(v->first_pic_header_flag) {
 989         rotate_luts(v);
 990     }
 991
 992     switch (v->s.pict_type) {
 993     case AV_PICTURE_TYPE_I:
 994     case AV_PICTURE_TYPE_BI:
 995         if (v->fcm == ILACE_FRAME) { //interlace frame picture
 996             status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
 997             if (status < 0)
 998                 return -1;
 999             av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1000                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1001         }
1002         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1003         if (status < 0)
1004             return -1;
1005         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1006                "Imode: %i, Invert: %i\n", status>>1, status&1);
1007         v->condover = CONDOVER_NONE;
1008         if (v->overlap && v->pq <= 8) {
1009             v->condover = decode012(gb);
1010             if (v->condover == CONDOVER_SELECT) {
1011                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1012                 if (status < 0)
1013                     return -1;
1014                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1015                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1016             }
1017         }
1018         break;
1019     case AV_PICTURE_TYPE_P:
1020         if (v->field_mode) {
1021             v->numref = get_bits1(gb);
1022             if (!v->numref) {
1023                 v->reffield          = get_bits1(gb);
1024                 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1025             }
1026         }
1027         if (v->extended_mv)
1028             v->mvrange = get_unary(gb, 0, 3);
1029         else
1030             v->mvrange = 0;
1031         if (v->interlace) {
1032             if (v->extended_dmv)
1033                 v->dmvrange = get_unary(gb, 0, 3);
1034             else
1035                 v->dmvrange = 0;
1036             if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1037                 v->fourmvswitch = get_bits1(gb);
1038                 v->intcomp      = get_bits1(gb);
1039                 if (v->intcomp) {
1040                     v->lumscale = get_bits(gb, 6);
1041                     v->lumshift = get_bits(gb, 6);
1042                     INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1043                     INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1044                     v->last_use_ic = 1;
1045                 }
1046                 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1047                 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1048                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1049                 mbmodetab = get_bits(gb, 2);
1050                 if (v->fourmvswitch)
1051                     v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1052                 else
1053                     v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1054                 imvtab         = get_bits(gb, 2);
1055                 v->imv_vlc     = &ff_vc1_1ref_mvdata_vlc[imvtab];
1056                 // interlaced p-picture cbpcy range is [1, 63]
1057                 icbptab        = get_bits(gb, 3);
1058                 v->cbpcy_vlc   = &ff_vc1_icbpcy_vlc[icbptab];
1059                 twomvbptab     = get_bits(gb, 2);
1060                 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1061                 if (v->fourmvswitch) {
1062                     fourmvbptab     = get_bits(gb, 2);
1063                     v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1064                 }
1065             }
1066         }
1067         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1068         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1069         v->range_x = 1 << (v->k_x - 1);
1070         v->range_y = 1 << (v->k_y - 1);
1071
1072         if (v->pq < 5)
1073             v->tt_index = 0;
1074         else if (v->pq < 13)
1075             v->tt_index = 1;
1076         else
1077             v->tt_index = 2;
1078         if (v->fcm != ILACE_FRAME) {
1079             int mvmode;
1080             mvmode     = get_unary(gb, 1, 4);
1081             lowquant   = (v->pq > 12) ? 0 : 1;
1082             v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1083             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1084                 int mvmode2;
1085                 mvmode2 = get_unary(gb, 1, 3);
1086                 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1087                 if (v->field_mode) {
1088                     v->intcompfield = decode210(gb)^3;
1089                 } else
1090                     v->intcompfield = 3;
1091
1092                 v->lumscale2 = v->lumscale = 32;
1093                 v->lumshift2 = v->lumshift =  0;
1094                 if (v->intcompfield & 1) {
1095                     v->lumscale = get_bits(gb, 6);
1096                     v->lumshift = get_bits(gb, 6);
1097                 }
1098                 if ((v->intcompfield & 2) && v->field_mode) {
1099                     v->lumscale2 = get_bits(gb, 6);
1100                     v->lumshift2 = get_bits(gb, 6);
1101                 } else if(!v->field_mode) {
1102                     v->lumscale2 = v->lumscale;
1103                     v->lumshift2 = v->lumshift;
1104                 }
1105                 if (v->field_mode && v->second_field) {
1106                     if (v->cur_field_type) {
1107                         INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1108                         INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type  ], v->last_lutuv[v->cur_field_type  ], 1);
1109                     } else {
1110                         INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1111                         INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type  ], v->last_lutuv[v->cur_field_type  ], 1);
1112                     }
1113                     v->next_use_ic = v->curr_use_ic = 1;
1114                 } else {
1115                     INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1116                     INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1117                 }
1118                 v->last_use_ic = 1;
1119             }
1120             v->qs_last = v->s.quarter_sample;
1121             if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1122                 v->s.quarter_sample = 0;
1123             else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1124                 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1125                     v->s.quarter_sample = 0;
1126                 else
1127                     v->s.quarter_sample = 1;
1128             } else
1129                 v->s.quarter_sample = 1;
1130             v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1131                            || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1132                                && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1133         }
1134         if (v->fcm == PROGRESSIVE) { // progressive
1135             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1136                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1137                 || v->mv_mode == MV_PMODE_MIXED_MV) {
1138                 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1139                 if (status < 0)
1140                     return -1;
1141                 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1142                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1143             } else {
1144                 v->mv_type_is_raw = 0;
1145                 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1146             }
1147             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1148             if (status < 0)
1149                 return -1;
1150             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1151                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1152
1153             /* Hopefully this is correct for P frames */
1154             v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1155             v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1156         } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1157             v->qs_last          = v->s.quarter_sample;
1158             v->s.quarter_sample = 1;
1159             v->s.mspel          = 1;
1160         } else {    // field interlaced
1161             mbmodetab = get_bits(gb, 3);
1162             imvtab = get_bits(gb, 2 + v->numref);
1163             if (!v->numref)
1164                 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1165             else
1166                 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1167             icbptab = get_bits(gb, 3);
1168             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1169             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1170                 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1171                 fourmvbptab     = get_bits(gb, 2);
1172                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1173                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1174             } else {
1175                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1176             }
1177         }
1178         if (v->dquant) {
1179             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1180             vop_dquant_decoding(v);
1181         }
1182
1183         v->ttfrm = 0; //FIXME Is that so ?
1184         if (v->vstransform) {
1185             v->ttmbf = get_bits1(gb);
1186             if (v->ttmbf) {
1187                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1188             }
1189         } else {
1190             v->ttmbf = 1;
1191             v->ttfrm = TT_8X8;
1192         }
1193         break;
1194     case AV_PICTURE_TYPE_B:
1195         if (v->fcm == ILACE_FRAME) {
1196             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1197             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1198             if (v->bfraction == 0) {
1199                 return -1;
1200             }
1201         }
1202         if (v->extended_mv)
1203             v->mvrange = get_unary(gb, 0, 3);
1204         else
1205             v->mvrange = 0;
1206         v->k_x     = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1207         v->k_y     = v->mvrange + 8; //k_y can be 8 9 10 11
1208         v->range_x = 1 << (v->k_x - 1);
1209         v->range_y = 1 << (v->k_y - 1);
1210
1211         if (v->pq < 5)
1212             v->tt_index = 0;
1213         else if (v->pq < 13)
1214             v->tt_index = 1;
1215         else
1216             v->tt_index = 2;
1217
1218         if (v->field_mode) {
1219             int mvmode;
1220             av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1221             if (v->extended_dmv)
1222                 v->dmvrange = get_unary(gb, 0, 3);
1223             mvmode = get_unary(gb, 1, 3);
1224             lowquant = (v->pq > 12) ? 0 : 1;
1225             v->mv_mode          = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1226             v->qs_last          = v->s.quarter_sample;
1227             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1228             v->s.mspel          = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1229             status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1230             if (status < 0)
1231                 return -1;
1232             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1233                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1234             mbmodetab = get_bits(gb, 3);
1235             if (v->mv_mode == MV_PMODE_MIXED_MV)
1236                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1237             else
1238                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1239             imvtab       = get_bits(gb, 3);
1240             v->imv_vlc   = &ff_vc1_2ref_mvdata_vlc[imvtab];
1241             icbptab      = get_bits(gb, 3);
1242             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1243             if (v->mv_mode == MV_PMODE_MIXED_MV) {
1244                 fourmvbptab     = get_bits(gb, 2);
1245                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1246             }
1247             v->numref = 1; // interlaced field B pictures are always 2-ref
1248         } else if (v->fcm == ILACE_FRAME) {
1249             if (v->extended_dmv)
1250                 v->dmvrange = get_unary(gb, 0, 3);
1251             get_bits1(gb); /* intcomp - present but shall always be 0 */
1252             v->intcomp          = 0;
1253             v->mv_mode          = MV_PMODE_1MV;
1254             v->fourmvswitch     = 0;
1255             v->qs_last          = v->s.quarter_sample;
1256             v->s.quarter_sample = 1;
1257             v->s.mspel          = 1;
1258             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1259             if (status < 0)
1260                 return -1;
1261             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1262                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1263             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1264             if (status < 0)
1265                 return -1;
1266             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1267                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1268             mbmodetab       = get_bits(gb, 2);
1269             v->mbmode_vlc   = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1270             imvtab          = get_bits(gb, 2);
1271             v->imv_vlc      = &ff_vc1_1ref_mvdata_vlc[imvtab];
1272             // interlaced p/b-picture cbpcy range is [1, 63]
1273             icbptab         = get_bits(gb, 3);
1274             v->cbpcy_vlc    = &ff_vc1_icbpcy_vlc[icbptab];
1275             twomvbptab      = get_bits(gb, 2);
1276             v->twomvbp_vlc  = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1277             fourmvbptab     = get_bits(gb, 2);
1278             v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1279         } else {
1280             v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1281             v->qs_last          = v->s.quarter_sample;
1282             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1283             v->s.mspel          = v->s.quarter_sample;
1284             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1285             if (status < 0)
1286                 return -1;
1287             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1288                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1289             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1290             if (status < 0)
1291                 return -1;
1292             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1293                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1294             v->s.mv_table_index = get_bits(gb, 2);
1295             v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1296         }
1297
1298         if (v->dquant) {
1299             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1300             vop_dquant_decoding(v);
1301         }
1302
1303         v->ttfrm = 0;
1304         if (v->vstransform) {
1305             v->ttmbf = get_bits1(gb);
1306             if (v->ttmbf) {
1307                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1308             }
1309         } else {
1310             v->ttmbf = 1;
1311             v->ttfrm = TT_8X8;
1312         }
1313         break;
1314     }
1315
1316     if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1317         v->range_x <<= 1;
1318         v->range_y <<= 1;
1319     }
1320
1321     /* AC Syntax */
1322     v->c_ac_table_index = decode012(gb);
1323     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1324         v->y_ac_table_index = decode012(gb);
1325     }
1326     /* DC Syntax */
1327     v->s.dc_table_index = get_bits1(gb);
1328     if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1329         && v->dquant) {
1330         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1331         vop_dquant_decoding(v);
1332     }
1333
1334     v->bi_type = 0;
1335     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1336         v->s.pict_type = AV_PICTURE_TYPE_B;
1337         v->bi_type = 1;
1338     }
1339     return 0;
1340 }
1341
1342 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1343 {
1344 { 0x0001,  2}, { 0x0005,  3}, { 0x000D,  4}, { 0x0012,  5}, { 0x000E,  6}, { 0x0015,  7},
1345 { 0x0013,  8}, { 0x003F,  8}, { 0x004B,  9}, { 0x011F,  9}, { 0x00B8, 10}, { 0x03E3, 10},
1346 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1347 { 0x3EAE, 14}, { 0x0000,  4}, { 0x0010,  5}, { 0x0008,  7}, { 0x0020,  8}, { 0x0029,  9},
1348 { 0x01F4,  9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1349 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003,  5}, { 0x0011,  7},
1350 { 0x00C4,  8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1351 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013,  5}, { 0x0078,  7},
1352 { 0x0069,  9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1353 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C,  6}, { 0x0024,  9}, { 0x0094, 11},
1354 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D,  6}, { 0x0053,  9}, { 0x01A0, 11},
1355 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013,  7}, { 0x007C,  9}, { 0x07C1, 11}, { 0x04AC, 14},
1356 { 0x001B,  7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079,  7}, { 0x03E1, 10},
1357 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021,  8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1358 { 0x0035,  8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5,  8}, { 0x0174, 11}, { 0x0785, 13},
1359 { 0x0048,  9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C,  9}, { 0x00FA, 10}, { 0x07D6, 11},
1360 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1361 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1362 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1363 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E,  4},
1364 { 0x0045,  7}, { 0x01F3,  9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019,  5},
1365 { 0x0028,  9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030,  6}, { 0x00A2, 10},
1366 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F,  6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1367 { 0x0044,  7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063,  7}, { 0x03C3, 12}, { 0x0015,  8},
1368 { 0x08F6, 12}, { 0x0017,  8}, { 0x0498, 13}, { 0x002C,  8}, { 0x07B2, 13}, { 0x002F,  8},
1369 { 0x1F54, 13}, { 0x008D,  8}, { 0x07BD, 13}, { 0x008E,  8}, { 0x1182, 13}, { 0x00FB,  8},
1370 { 0x050B, 13}, { 0x002D,  8}, { 0x07C0, 11}, { 0x0079,  9}, { 0x1F5F, 13}, { 0x007A,  9},
1371 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1372 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1373 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1374 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A,  9}
1375 },
1376 {
1377 { 0x0000,  3}, { 0x0003,  4}, { 0x000B,  5}, { 0x0014,  6}, { 0x003F,  6}, { 0x005D,  7},
1378 { 0x00A2,  8}, { 0x00AC,  9}, { 0x016E,  9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1379 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1380 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004,  4},
1381 { 0x001E,  5}, { 0x0042,  7}, { 0x00B6,  8}, { 0x0173,  9}, { 0x0395, 10}, { 0x072E, 11},
1382 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005,  5}, { 0x0040,  7},
1383 { 0x0049,  9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1384 { 0x0018,  5}, { 0x0025,  8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1385 { 0x139C, 15}, { 0x0029,  6}, { 0x004F,  9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1386 { 0x0038,  6}, { 0x010E,  9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058,  7},
1387 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023,  8}, { 0x02E3, 10}, { 0x04E5, 13},
1388 { 0x2E40, 14}, { 0x00A1,  8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083,  8}, { 0x013A, 11},
1389 { 0x1721, 13}, { 0x0044,  9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1390 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1391 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1392 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1393 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003,  3}, { 0x002A,  6}, { 0x00E4,  8},
1394 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1395 { 0x0009,  4}, { 0x0054,  8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D,  4},
1396 { 0x00AD,  9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011,  5}, { 0x016B,  9}, { 0x0B7F, 12},
1397 { 0x51A4, 15}, { 0x0019,  5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D,  5}, { 0x0394, 10},
1398 { 0x28D3, 14}, { 0x002B,  6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F,  6}, { 0x0247, 12},
1399 { 0x0010,  7}, { 0x0A35, 12}, { 0x003E,  6}, { 0x0B7A, 12}, { 0x0059,  7}, { 0x105E, 13},
1400 { 0x0026,  8}, { 0x09CF, 14}, { 0x0055,  8}, { 0x1CB5, 13}, { 0x0057,  8}, { 0x0E5B, 12},
1401 { 0x00A0,  8}, { 0x1468, 13}, { 0x0170,  9}, { 0x0090, 10}, { 0x01CE,  9}, { 0x021A, 10},
1402 { 0x0218, 10}, { 0x0168,  9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1403 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1404 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1405 { 0x0169,  9}
1406 },
1407 {
1408 { 0x0001,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x0016,  5}, { 0x0020,  6}, { 0x0018,  7},
1409 { 0x0008,  8}, { 0x009A,  8}, { 0x0056,  9}, { 0x013E,  9}, { 0x00F0, 10}, { 0x03A5, 10},
1410 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001,  4}, { 0x0011,  5},
1411 { 0x0002,  7}, { 0x000B,  8}, { 0x0012,  9}, { 0x01D6,  9}, { 0x027E, 10}, { 0x0191, 11},
1412 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004,  5}, { 0x0014,  7}, { 0x009E,  8},
1413 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017,  5},
1414 { 0x004E,  7}, { 0x005E,  9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1415 { 0x000E,  6}, { 0x00E1,  8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B,  6},
1416 { 0x001C,  9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006,  7}, { 0x007A,  9}, { 0x0190, 11},
1417 { 0x0137, 13}, { 0x001B,  7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071,  7}, { 0x00D7, 10},
1418 { 0x09BF, 12}, { 0x0007,  8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034,  8}, { 0x0265, 10},
1419 { 0x009F, 12}, { 0x00E0,  8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015,  9}, { 0x017D, 11},
1420 { 0x0EBB, 12}, { 0x0014,  9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1421 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1422 { 0x013A, 13}, { 0x000A,  4}, { 0x0042,  7}, { 0x01D3,  9}, { 0x04DD, 11}, { 0x0012,  5},
1423 { 0x00E8,  8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039,  6}, { 0x0264, 10}, { 0x0EBA, 12},
1424 { 0x0000,  7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F,  7}, { 0x04DE, 11}, { 0x0043,  7},
1425 { 0x04DC, 11}, { 0x0003,  8}, { 0x03CB, 12}, { 0x0006,  8}, { 0x099E, 12}, { 0x002A,  8},
1426 { 0x05F1, 13}, { 0x000F,  8}, { 0x09FE, 12}, { 0x0033,  8}, { 0x09FF, 12}, { 0x0098,  8},
1427 { 0x099F, 12}, { 0x00EA,  8}, { 0x013C, 13}, { 0x002E,  8}, { 0x0192, 11}, { 0x0136,  9},
1428 { 0x006A,  9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1429 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1430 { 0x0016,  7}
1431 },
1432 {
1433 { 0x0004,  3}, { 0x0014,  5}, { 0x0017,  7}, { 0x007F,  8}, { 0x0154,  9}, { 0x01F2, 10},
1434 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1435 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B,  4}, { 0x0037,  7}, { 0x0062,  9}, { 0x0007, 11},
1436 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007,  5},
1437 { 0x006D,  8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002,  6}, { 0x0061,  9},
1438 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A,  6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1439 { 0x001E,  6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006,  7}, { 0x0004, 11},
1440 { 0x02F8, 13}, { 0x0019,  7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057,  7}, { 0x0182, 11},
1441 { 0x2AA2, 14}, { 0x0004,  8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D,  8}, { 0x0164, 12},
1442 { 0x076D, 15}, { 0x0002,  9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD,  8}, { 0x0060, 12},
1443 { 0x0C67, 14}, { 0x001C,  9}, { 0x00EE, 13}, { 0x0003,  9}, { 0x02CF, 13}, { 0x00D9,  9},
1444 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1445 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1446 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003,  2}, { 0x0054,  7}, { 0x02AB, 10},
1447 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005,  4}, { 0x00F8,  9}, { 0x0AA9, 12}, { 0x005F, 15},
1448 { 0x0004,  4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004,  5}, { 0x0077, 11}, { 0x076C, 15},
1449 { 0x000E,  5}, { 0x000A, 12}, { 0x000C,  5}, { 0x0562, 11}, { 0x0004,  6}, { 0x031C, 12},
1450 { 0x0006,  6}, { 0x00C8, 13}, { 0x000D,  6}, { 0x01DA, 13}, { 0x0007,  6}, { 0x00C9, 13},
1451 { 0x0001,  7}, { 0x002E, 14}, { 0x0014,  7}, { 0x1596, 13}, { 0x000A,  7}, { 0x0AC2, 12},
1452 { 0x0016,  7}, { 0x015B, 14}, { 0x0015,  7}, { 0x015A, 14}, { 0x000F,  8}, { 0x005E, 15},
1453 { 0x007E,  8}, { 0x00AB,  8}, { 0x002D,  9}, { 0x00D8,  9}, { 0x000B,  9}, { 0x0014, 10},
1454 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E,  9},
1455 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1456 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1457 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D,  9}
1458 },
1459 {
1460 { 0x0002,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x000D,  5}, { 0x000C,  5}, { 0x0015,  6},
1461 { 0x0013,  6}, { 0x0012,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x001E,  8}, { 0x001D,  8},
1462 { 0x0025,  9}, { 0x0024,  9}, { 0x0023,  9}, { 0x0021,  9}, { 0x0021, 10}, { 0x0020, 10},
1463 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1464 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E,  4}, { 0x0014,  6}, { 0x0016,  7},
1465 { 0x001C,  8}, { 0x0020,  9}, { 0x001F,  9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1466 { 0x0055, 12}, { 0x000B,  5}, { 0x0015,  7}, { 0x001E,  9}, { 0x000C, 10}, { 0x0056, 12},
1467 { 0x0011,  6}, { 0x001B,  8}, { 0x001D,  9}, { 0x000B, 10}, { 0x0010,  6}, { 0x0022,  9},
1468 { 0x000A, 10}, { 0x000D,  6}, { 0x001C,  9}, { 0x0008, 10}, { 0x0012,  7}, { 0x001B,  9},
1469 { 0x0054, 12}, { 0x0014,  7}, { 0x001A,  9}, { 0x0057, 12}, { 0x0019,  8}, { 0x0009, 10},
1470 { 0x0018,  8}, { 0x0023, 11}, { 0x0017,  8}, { 0x0019,  9}, { 0x0018,  9}, { 0x0007, 10},
1471 { 0x0058, 12}, { 0x0007,  4}, { 0x000C,  6}, { 0x0016,  8}, { 0x0017,  9}, { 0x0006, 10},
1472 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F,  6}, { 0x0016,  9}, { 0x0005, 10},
1473 { 0x000E,  6}, { 0x0004, 10}, { 0x0011,  7}, { 0x0024, 11}, { 0x0010,  7}, { 0x0025, 11},
1474 { 0x0013,  7}, { 0x005A, 12}, { 0x0015,  8}, { 0x005B, 12}, { 0x0014,  8}, { 0x0013,  8},
1475 { 0x001A,  8}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9}, { 0x0012,  9}, { 0x0011,  9},
1476 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1477 { 0x0003,  7}
1478 },
1479 {
1480 { 0x0002,  2}, { 0x000F,  4}, { 0x0015,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x0025,  9},
1481 { 0x0024,  9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1482 { 0x0006,  3}, { 0x0014,  6}, { 0x001E,  8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1483 { 0x000E,  4}, { 0x001D,  8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D,  5}, { 0x0023,  9},
1484 { 0x000D, 10}, { 0x000C,  5}, { 0x0022,  9}, { 0x0052, 12}, { 0x000B,  5}, { 0x000C, 10},
1485 { 0x0053, 12}, { 0x0013,  6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012,  6}, { 0x000A, 10},
1486 { 0x0011,  6}, { 0x0009, 10}, { 0x0010,  6}, { 0x0008, 10}, { 0x0016,  7}, { 0x0055, 12},
1487 { 0x0015,  7}, { 0x0014,  7}, { 0x001C,  8}, { 0x001B,  8}, { 0x0021,  9}, { 0x0020,  9},
1488 { 0x001F,  9}, { 0x001E,  9}, { 0x001D,  9}, { 0x001C,  9}, { 0x001B,  9}, { 0x001A,  9},
1489 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007,  4}, { 0x0019,  9},
1490 { 0x0005, 11}, { 0x000F,  6}, { 0x0004, 11}, { 0x000E,  6}, { 0x000D,  6}, { 0x000C,  6},
1491 { 0x0013,  7}, { 0x0012,  7}, { 0x0011,  7}, { 0x0010,  7}, { 0x001A,  8}, { 0x0019,  8},
1492 { 0x0018,  8}, { 0x0017,  8}, { 0x0016,  8}, { 0x0015,  8}, { 0x0014,  8}, { 0x0013,  8},
1493 { 0x0018,  9}, { 0x0017,  9}, { 0x0016,  9}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9},
1494 { 0x0012,  9}, { 0x0011,  9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1495 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1496 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1497 { 0x0003,  7}
1498 },
1499 {
1500 { 0x0000,  2}, { 0x0003,  3}, { 0x000D,  4}, { 0x0005,  4}, { 0x001C,  5}, { 0x0016,  5},
1501 { 0x003F,  6}, { 0x003A,  6}, { 0x002E,  6}, { 0x0022,  6}, { 0x007B,  7}, { 0x0067,  7},
1502 { 0x005F,  7}, { 0x0047,  7}, { 0x0026,  7}, { 0x00EF,  8}, { 0x00CD,  8}, { 0x00C1,  8},
1503 { 0x00A9,  8}, { 0x004F,  8}, { 0x01F2,  9}, { 0x01DD,  9}, { 0x0199,  9}, { 0x0185,  9},
1504 { 0x015D,  9}, { 0x011B,  9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1505 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1506 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1507 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1508 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1509 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009,  4}, { 0x0010,  5}, { 0x0029,  6}, { 0x0062,  7},
1510 { 0x00F3,  8}, { 0x00AD,  8}, { 0x01E5,  9}, { 0x0179,  9}, { 0x009C,  9}, { 0x03B1, 10},
1511 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1512 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008,  5}, { 0x0063,  7},
1513 { 0x00AF,  8}, { 0x017B,  9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1514 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028,  6}, { 0x00C3,  8}, { 0x0151,  9}, { 0x02A1, 10},
1515 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065,  7}, { 0x01DA,  9}, { 0x02AF, 10},
1516 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025,  7}, { 0x0118,  9}, { 0x0646, 11},
1517 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9,  8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1518 { 0x0048,  8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180,  9}, { 0x0465, 11}, { 0x1905, 13},
1519 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1520 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1521 { 0x0078,  7}, { 0x0155,  9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA,  8}, { 0x07DC, 11},
1522 { 0x1907, 13}, { 0x00AC,  8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6,  9}, { 0x0AE2, 12},
1523 { 0x01DC,  9}, { 0x04ED, 12}, { 0x0184,  9}, { 0x1904, 13}, { 0x0156,  9}, { 0x09D9, 13},
1524 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1525 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1526 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1527 { 0x007A,  7}
1528 },
1529 {
1530 { 0x0002,  2}, { 0x0000,  3}, { 0x001E,  5}, { 0x0004,  5}, { 0x0012,  6}, { 0x0070,  7},
1531 { 0x001A,  7}, { 0x005F,  8}, { 0x0047,  8}, { 0x01D3,  9}, { 0x00B5,  9}, { 0x0057,  9},
1532 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1533 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1534 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1535 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003,  3}, { 0x000A,  5}, { 0x0077,  7}, { 0x00E5,  8},
1536 { 0x01D9,  9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1537 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C,  4}, { 0x007D,  7}, { 0x0044,  8},
1538 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B,  5},
1539 { 0x00E2,  8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007,  5},
1540 { 0x01D8,  9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035,  6}, { 0x03E1, 10},
1541 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C,  6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1542 { 0x0068,  7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020,  7}, { 0x0F90, 12}, { 0x7CF6, 15},
1543 { 0x00E8,  8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045,  8}, { 0x0B3A, 13}, { 0x01F1,  9},
1544 { 0x3B46, 14}, { 0x01A7,  9}, { 0x1676, 14}, { 0x0056,  9}, { 0x692A, 15}, { 0x038D, 10},
1545 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1546 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1547 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1548 { 0x055F, 13}, { 0x003F,  6}, { 0x006D,  9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013,  6},
1549 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B,  6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075,  7},
1550 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E,  7}, { 0x1F22, 13}, { 0x0021,  7}, { 0x054F, 13},
1551 { 0x0014,  7}, { 0x3A44, 14}, { 0x00E4,  8}, { 0x7CF7, 15}, { 0x005E,  8}, { 0x7185, 15},
1552 { 0x0037,  8}, { 0x2C73, 15}, { 0x01DB,  9}, { 0x59DD, 16}, { 0x01C7,  9}, { 0x692B, 15},
1553 { 0x01A6,  9}, { 0x58E5, 16}, { 0x00B4,  9}, { 0x1F3D0, 17}, { 0x00B0,  9}, { 0xB1C9, 17},
1554 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1555 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1556 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1557 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1558 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1559 { 0x0073,  7}
1560 }
1561 };
1562
1563 static const uint16_t vlc_offs[] = {
1564         0,   520,   552,   616,  1128,  1160,  1224,  1740,  1772,  1836,  1900,  2436,
1565      2986,  3050,  3610,  4154,  4218,  4746,  5326,  5390,  5902,  6554,  7658,  8342,
1566      9304,  9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1567     20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1568     27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1569     29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1570     31714, 31746, 31778, 32306, 32340, 32372
1571 };
1572
1573 /**
1574  * Init VC-1 specific tables and VC1Context members
1575  * @param v The VC1Context to initialize
1576  * @return Status
1577  */
1578 int ff_vc1_init_common(VC1Context *v)
1579 {
1580     static int done = 0;
1581     int i = 0;
1582     static VLC_TYPE vlc_table[32372][2];
1583
1584     v->hrd_rate = v->hrd_buffer = NULL;
1585
1586     /* VLC tables */
1587     if (!done) {
1588         INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1589                         ff_vc1_bfraction_bits, 1, 1,
1590                         ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1591         INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1592                         ff_vc1_norm2_bits, 1, 1,
1593                         ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1594         INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1595                         ff_vc1_norm6_bits, 1, 1,
1596                         ff_vc1_norm6_codes, 2, 2, 556);
1597         INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1598                         ff_vc1_imode_bits, 1, 1,
1599                         ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1600         for (i = 0; i < 3; i++) {
1601             ff_vc1_ttmb_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 0]];
1602             ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1603             init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1604                      ff_vc1_ttmb_bits[i], 1, 1,
1605                      ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1606             ff_vc1_ttblk_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 1]];
1607             ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1608             init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1609                      ff_vc1_ttblk_bits[i], 1, 1,
1610                      ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1611             ff_vc1_subblkpat_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 2]];
1612             ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1613             init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1614                      ff_vc1_subblkpat_bits[i], 1, 1,
1615                      ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1616         }
1617         for (i = 0; i < 4; i++) {
1618             ff_vc1_4mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 9]];
1619             ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1620             init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1621                      ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1622                      ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1623             ff_vc1_cbpcy_p_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 10]];
1624             ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1625             init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1626                      ff_vc1_cbpcy_p_bits[i], 1, 1,
1627                      ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1628             ff_vc1_mv_diff_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 11]];
1629             ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1630             init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1631                      ff_vc1_mv_diff_bits[i], 1, 1,
1632                      ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1633         }
1634         for (i = 0; i < 8; i++) {
1635             ff_vc1_ac_coeff_table[i].table           = &vlc_table[vlc_offs[i * 2 + 21]];
1636             ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1637             init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1638                      &vc1_ac_tables[i][0][1], 8, 4,
1639                      &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1640             /* initialize interlaced MVDATA tables (2-Ref) */
1641             ff_vc1_2ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 2 + 22]];
1642             ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1643             init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1644                      ff_vc1_2ref_mvdata_bits[i], 1, 1,
1645                      ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1646         }
1647         for (i = 0; i < 4; i++) {
1648             /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1649             ff_vc1_intfr_4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 37]];
1650             ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1651             init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1652                      ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1653                      ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1654             /* initialize NON-4MV MBMODE VLC tables for the same */
1655             ff_vc1_intfr_non4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 38]];
1656             ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1657             init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1658                      ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1659                      ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1660             /* initialize interlaced MVDATA tables (1-Ref) */
1661             ff_vc1_1ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 39]];
1662             ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1663             init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1664                      ff_vc1_1ref_mvdata_bits[i], 1, 1,
1665                      ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1666         }
1667         for (i = 0; i < 4; i++) {
1668             /* Initialize 2MV Block pattern VLC tables */
1669             ff_vc1_2mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i + 49]];
1670             ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1671             init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1672                      ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1673                      ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1674         }
1675         for (i = 0; i < 8; i++) {
1676             /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1677             ff_vc1_icbpcy_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 53]];
1678             ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1679             init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1680                      ff_vc1_icbpcy_p_bits[i], 1, 1,
1681                      ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1682             /* Initialize interlaced field picture MBMODE VLC tables */
1683             ff_vc1_if_mmv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 54]];
1684             ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1685             init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1686                      ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1687                      ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1688             ff_vc1_if_1mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 55]];
1689             ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1690             init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1691                      ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1692                      ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1693         }
1694         done = 1;
1695     }
1696
1697     /* Other defaults */
1698     v->pq      = -1;
1699     v->mvrange = 0; /* 7.1.1.18, p80 */
1700
1701     return 0;
1702 }