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)   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         luty[i]  = av_clip_uint8((scale * i + shift + 32) >> 6);           \
 596         lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);  \
 597     } \
 598     }while(0)
 599
 600 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
 601 {
 602     int pqindex, lowquant, status;
 603
 604     if (v->finterpflag)
 605         v->interpfrm = get_bits1(gb);
 606     if (!v->s.avctx->codec)
 607         return -1;
 608     if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
 609         v->respic   =
 610         v->rangered =
 611         v->multires = get_bits(gb, 2) == 1;
 612     else
 613         skip_bits(gb, 2); //framecnt unused
 614     v->rangeredfrm = 0;
 615     if (v->rangered)
 616         v->rangeredfrm = get_bits1(gb);
 617     v->s.pict_type = get_bits1(gb);
 618     if (v->s.avctx->max_b_frames) {
 619         if (!v->s.pict_type) {
 620             if (get_bits1(gb))
 621                 v->s.pict_type = AV_PICTURE_TYPE_I;
 622             else
 623                 v->s.pict_type = AV_PICTURE_TYPE_B;
 624         } else
 625             v->s.pict_type = AV_PICTURE_TYPE_P;
 626     } else
 627         v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
 628
 629     v->bi_type = 0;
 630     if (v->s.pict_type == AV_PICTURE_TYPE_B) {
 631         v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
 632         v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
 633         if (v->bfraction == 0) {
 634             v->s.pict_type = AV_PICTURE_TYPE_BI;
 635         }
 636     }
 637     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
 638         skip_bits(gb, 7); // skip buffer fullness
 639
 640     if (v->parse_only)
 641         return 0;
 642
 643     /* calculate RND */
 644     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
 645         v->rnd = 1;
 646     if (v->s.pict_type == AV_PICTURE_TYPE_P)
 647         v->rnd ^= 1;
 648
 649     /* Quantizer stuff */
 650     pqindex = get_bits(gb, 5);
 651     if (!pqindex)
 652         return -1;
 653     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 654         v->pq = ff_vc1_pquant_table[0][pqindex];
 655     else
 656         v->pq = ff_vc1_pquant_table[1][pqindex];
 657
 658     v->pquantizer = 1;
 659     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 660         v->pquantizer = pqindex < 9;
 661     if (v->quantizer_mode == QUANT_NON_UNIFORM)
 662         v->pquantizer = 0;
 663     v->pqindex = pqindex;
 664     if (pqindex < 9)
 665         v->halfpq = get_bits1(gb);
 666     else
 667         v->halfpq = 0;
 668     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
 669         v->pquantizer = get_bits1(gb);
 670     v->dquantfrm = 0;
 671     if (v->extended_mv == 1)
 672         v->mvrange = get_unary(gb, 0, 3);
 673     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
 674     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
 675     v->range_x = 1 << (v->k_x - 1);
 676     v->range_y = 1 << (v->k_y - 1);
 677     if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
 678         v->respic = get_bits(gb, 2);
 679
 680     if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
 681         v->x8_type = get_bits1(gb);
 682     } else
 683         v->x8_type = 0;
 684     av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
 685             (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
 686             pqindex, v->pq, v->halfpq, v->rangeredfrm);
 687
 688     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
 689         v->use_ic = 0;
 690
 691     switch (v->s.pict_type) {
 692     case AV_PICTURE_TYPE_P:
 693         if (v->pq < 5)       v->tt_index = 0;
 694         else if (v->pq < 13) v->tt_index = 1;
 695         else                 v->tt_index = 2;
 696
 697         lowquant = (v->pq > 12) ? 0 : 1;
 698         v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
 699         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 700             v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
 701             v->lumscale = get_bits(gb, 6);
 702             v->lumshift = get_bits(gb, 6);
 703             v->use_ic   = 1;
 704             /* fill lookup tables for intensity compensation */
 705             INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
 706         }
 707         v->qs_last = v->s.quarter_sample;
 708         if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
 709             v->s.quarter_sample = 0;
 710         else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 711             if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
 712                 v->s.quarter_sample = 0;
 713             else
 714                 v->s.quarter_sample = 1;
 715         } else
 716             v->s.quarter_sample = 1;
 717         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));
 718
 719         if ((v->mv_mode  == MV_PMODE_INTENSITY_COMP &&
 720              v->mv_mode2 == MV_PMODE_MIXED_MV)      ||
 721             v->mv_mode   == MV_PMODE_MIXED_MV) {
 722             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
 723             if (status < 0)
 724                 return -1;
 725             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
 726                    "Imode: %i, Invert: %i\n", status>>1, status&1);
 727         } else {
 728             v->mv_type_is_raw = 0;
 729             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
 730         }
 731         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
 732         if (status < 0)
 733             return -1;
 734         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
 735                "Imode: %i, Invert: %i\n", status>>1, status&1);
 736
 737         /* Hopefully this is correct for P frames */
 738         v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
 739         v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
 740
 741         if (v->dquant) {
 742             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
 743             vop_dquant_decoding(v);
 744         }
 745
 746         v->ttfrm = 0; //FIXME Is that so ?
 747         if (v->vstransform) {
 748             v->ttmbf = get_bits1(gb);
 749             if (v->ttmbf) {
 750                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
 751             }
 752         } else {
 753             v->ttmbf = 1;
 754             v->ttfrm = TT_8X8;
 755         }
 756         break;
 757     case AV_PICTURE_TYPE_B:
 758         if (v->pq < 5)       v->tt_index = 0;
 759         else if (v->pq < 13) v->tt_index = 1;
 760         else                 v->tt_index = 2;
 761
 762         v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
 763         v->qs_last          = v->s.quarter_sample;
 764         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
 765         v->s.mspel          = v->s.quarter_sample;
 766
 767         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
 768         if (status < 0)
 769             return -1;
 770         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
 771                "Imode: %i, Invert: %i\n", status>>1, status&1);
 772         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
 773         if (status < 0)
 774             return -1;
 775         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
 776                "Imode: %i, Invert: %i\n", status>>1, status&1);
 777
 778         v->s.mv_table_index = get_bits(gb, 2);
 779         v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
 780
 781         if (v->dquant) {
 782             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
 783             vop_dquant_decoding(v);
 784         }
 785
 786         v->ttfrm = 0;
 787         if (v->vstransform) {
 788             v->ttmbf = get_bits1(gb);
 789             if (v->ttmbf) {
 790                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
 791             }
 792         } else {
 793             v->ttmbf = 1;
 794             v->ttfrm = TT_8X8;
 795         }
 796         break;
 797     }
 798
 799     if (!v->x8_type) {
 800         /* AC Syntax */
 801         v->c_ac_table_index = decode012(gb);
 802         if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
 803             v->y_ac_table_index = decode012(gb);
 804         }
 805         /* DC Syntax */
 806         v->s.dc_table_index = get_bits1(gb);
 807     }
 808
 809     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
 810         v->s.pict_type = AV_PICTURE_TYPE_B;
 811         v->bi_type     = 1;
 812     }
 813     return 0;
 814 }
 815
 816 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
 817 {
 818     int pqindex, lowquant;
 819     int status;
 820     int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
 821     int field_mode, fcm;
 822
 823     v->numref=0;
 824     v->p_frame_skipped = 0;
 825     if (v->second_field) {
 826         if(v->fcm!=2 || v->field_mode!=1)
 827             return -1;
 828         v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
 829         if (v->fptype & 4)
 830             v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
 831         v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
 832         if (!v->pic_header_flag)
 833             goto parse_common_info;
 834     }
 835
 836     field_mode = 0;
 837     if (v->interlace) {
 838         fcm = decode012(gb);
 839         if (fcm) {
 840             if (fcm == ILACE_FIELD)
 841                 field_mode = 1;
 842             if (!v->warn_interlaced++)
 843                 av_log(v->s.avctx, AV_LOG_ERROR,
 844                        "Interlaced frames/fields support is incomplete\n");
 845         }
 846     } else {
 847         fcm = PROGRESSIVE;
 848     }
 849     if (!v->first_pic_header_flag && v->field_mode != field_mode)
 850         return -1;
 851     v->field_mode = field_mode;
 852     v->fcm = fcm;
 853
 854     if (v->field_mode) {
 855         v->fptype = get_bits(gb, 3);
 856         v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
 857         if (v->fptype & 4) // B-picture
 858             v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
 859     } else {
 860         switch (get_unary(gb, 0, 4)) {
 861         case 0:
 862             v->s.pict_type = AV_PICTURE_TYPE_P;
 863             break;
 864         case 1:
 865             v->s.pict_type = AV_PICTURE_TYPE_B;
 866             break;
 867         case 2:
 868             v->s.pict_type = AV_PICTURE_TYPE_I;
 869             break;
 870         case 3:
 871             v->s.pict_type = AV_PICTURE_TYPE_BI;
 872             break;
 873         case 4:
 874             v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
 875             v->p_frame_skipped = 1;
 876             break;
 877         }
 878     }
 879     if (v->tfcntrflag)
 880         skip_bits(gb, 8);
 881     if (v->broadcast) {
 882         if (!v->interlace || v->psf) {
 883             v->rptfrm = get_bits(gb, 2);
 884         } else {
 885             v->tff = get_bits1(gb);
 886             v->rff = get_bits1(gb);
 887         }
 888     } else {
 889         v->tff = 1;
 890     }
 891     if (v->panscanflag) {
 892         avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
 893         //...
 894     }
 895     if (v->p_frame_skipped) {
 896         return 0;
 897     }
 898     v->rnd = get_bits1(gb);
 899     if (v->interlace)
 900         v->uvsamp = get_bits1(gb);
 901     if(!ff_vc1_bfraction_vlc.table)
 902         return 0; //parsing only, vlc tables havnt been allocated
 903     if (v->field_mode) {
 904         if (!v->refdist_flag)
 905             v->refdist = 0;
 906         else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
 907             v->refdist = get_bits(gb, 2);
 908             if (v->refdist == 3)
 909                 v->refdist += get_unary(gb, 0, 16);
 910         }
 911         if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
 912             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
 913             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
 914             v->frfd = (v->bfraction * v->refdist) >> 8;
 915             v->brfd = v->refdist - v->frfd - 1;
 916             if (v->brfd < 0)
 917                 v->brfd = 0;
 918         }
 919         goto parse_common_info;
 920     }
 921     if (v->fcm == PROGRESSIVE) {
 922         if (v->finterpflag)
 923             v->interpfrm = get_bits1(gb);
 924         if (v->s.pict_type == AV_PICTURE_TYPE_B) {
 925             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
 926             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
 927             if (v->bfraction == 0) {
 928                 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
 929             }
 930         }
 931     }
 932
 933     parse_common_info:
 934     if (v->field_mode)
 935         v->cur_field_type = !(v->tff ^ v->second_field);
 936     pqindex = get_bits(gb, 5);
 937     if (!pqindex)
 938         return -1;
 939     v->pqindex = pqindex;
 940     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 941         v->pq = ff_vc1_pquant_table[0][pqindex];
 942     else
 943         v->pq = ff_vc1_pquant_table[1][pqindex];
 944
 945     v->pquantizer = 1;
 946     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 947         v->pquantizer = pqindex < 9;
 948     if (v->quantizer_mode == QUANT_NON_UNIFORM)
 949         v->pquantizer = 0;
 950     v->pqindex = pqindex;
 951     if (pqindex < 9)
 952         v->halfpq = get_bits1(gb);
 953     else
 954         v->halfpq = 0;
 955     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
 956         v->pquantizer = get_bits1(gb);
 957     if (v->postprocflag)
 958         v->postproc = get_bits(gb, 2);
 959
 960     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
 961         v->use_ic = 0;
 962
 963     if (v->parse_only)
 964         return 0;
 965
 966     switch (v->s.pict_type) {
 967     case AV_PICTURE_TYPE_I:
 968     case AV_PICTURE_TYPE_BI:
 969         if (v->fcm == ILACE_FRAME) { //interlace frame picture
 970             status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
 971             if (status < 0)
 972                 return -1;
 973             av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
 974                    "Imode: %i, Invert: %i\n", status>>1, status&1);
 975         }
 976         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
 977         if (status < 0)
 978             return -1;
 979         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
 980                "Imode: %i, Invert: %i\n", status>>1, status&1);
 981         v->condover = CONDOVER_NONE;
 982         if (v->overlap && v->pq <= 8) {
 983             v->condover = decode012(gb);
 984             if (v->condover == CONDOVER_SELECT) {
 985                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
 986                 if (status < 0)
 987                     return -1;
 988                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
 989                        "Imode: %i, Invert: %i\n", status>>1, status&1);
 990             }
 991         }
 992         break;
 993     case AV_PICTURE_TYPE_P:
 994         if (v->field_mode) {
 995             v->numref = get_bits1(gb);
 996             if (!v->numref) {
 997                 v->reffield          = get_bits1(gb);
 998                 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
 999             }
1000         }
1001         if (v->extended_mv)
1002             v->mvrange = get_unary(gb, 0, 3);
1003         else
1004             v->mvrange = 0;
1005         if (v->interlace) {
1006             if (v->extended_dmv)
1007                 v->dmvrange = get_unary(gb, 0, 3);
1008             else
1009                 v->dmvrange = 0;
1010             if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1011                 v->fourmvswitch = get_bits1(gb);
1012                 v->intcomp      = get_bits1(gb);
1013                 if (v->intcomp) {
1014                     v->lumscale = get_bits(gb, 6);
1015                     v->lumshift = get_bits(gb, 6);
1016                     INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1017                 }
1018                 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1019                 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1020                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1021                 mbmodetab = get_bits(gb, 2);
1022                 if (v->fourmvswitch)
1023                     v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1024                 else
1025                     v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1026                 imvtab         = get_bits(gb, 2);
1027                 v->imv_vlc     = &ff_vc1_1ref_mvdata_vlc[imvtab];
1028                 // interlaced p-picture cbpcy range is [1, 63]
1029                 icbptab        = get_bits(gb, 3);
1030                 v->cbpcy_vlc   = &ff_vc1_icbpcy_vlc[icbptab];
1031                 twomvbptab     = get_bits(gb, 2);
1032                 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1033                 if (v->fourmvswitch) {
1034                     fourmvbptab     = get_bits(gb, 2);
1035                     v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1036                 }
1037             }
1038         }
1039         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1040         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1041         v->range_x = 1 << (v->k_x - 1);
1042         v->range_y = 1 << (v->k_y - 1);
1043
1044         if (v->pq < 5)
1045             v->tt_index = 0;
1046         else if (v->pq < 13)
1047             v->tt_index = 1;
1048         else
1049             v->tt_index = 2;
1050         if (v->fcm != ILACE_FRAME) {
1051             int mvmode;
1052             mvmode     = get_unary(gb, 1, 4);
1053             lowquant   = (v->pq > 12) ? 0 : 1;
1054             v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1055             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1056                 int mvmode2;
1057                 mvmode2 = get_unary(gb, 1, 3);
1058                 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1059                 if (v->field_mode)
1060                     v->intcompfield = decode210(gb);
1061                 v->lumscale = get_bits(gb, 6);
1062                 v->lumshift = get_bits(gb, 6);
1063                 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1064                 if ((v->field_mode) && !v->intcompfield) {
1065                     v->lumscale2 = get_bits(gb, 6);
1066                     v->lumshift2 = get_bits(gb, 6);
1067                     INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1068                 }
1069                 v->use_ic = 1;
1070             }
1071             v->qs_last = v->s.quarter_sample;
1072             if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1073                 v->s.quarter_sample = 0;
1074             else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1075                 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1076                     v->s.quarter_sample = 0;
1077                 else
1078                     v->s.quarter_sample = 1;
1079             } else
1080                 v->s.quarter_sample = 1;
1081             v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1082                            || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1083                                && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1084         }
1085         if (v->fcm == PROGRESSIVE) { // progressive
1086             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1087                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1088                 || v->mv_mode == MV_PMODE_MIXED_MV) {
1089                 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1090                 if (status < 0)
1091                     return -1;
1092                 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1093                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1094             } else {
1095                 v->mv_type_is_raw = 0;
1096                 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1097             }
1098             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1099             if (status < 0)
1100                 return -1;
1101             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1102                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1103
1104             /* Hopefully this is correct for P frames */
1105             v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1106             v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1107         } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1108             v->qs_last          = v->s.quarter_sample;
1109             v->s.quarter_sample = 1;
1110             v->s.mspel          = 1;
1111         } else {    // field interlaced
1112             mbmodetab = get_bits(gb, 3);
1113             imvtab = get_bits(gb, 2 + v->numref);
1114             if (!v->numref)
1115                 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1116             else
1117                 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1118             icbptab = get_bits(gb, 3);
1119             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1120             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1121                 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1122                 fourmvbptab     = get_bits(gb, 2);
1123                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1124                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1125             } else {
1126                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1127             }
1128         }
1129         if (v->dquant) {
1130             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1131             vop_dquant_decoding(v);
1132         }
1133
1134         v->ttfrm = 0; //FIXME Is that so ?
1135         if (v->vstransform) {
1136             v->ttmbf = get_bits1(gb);
1137             if (v->ttmbf) {
1138                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1139             }
1140         } else {
1141             v->ttmbf = 1;
1142             v->ttfrm = TT_8X8;
1143         }
1144         break;
1145     case AV_PICTURE_TYPE_B:
1146         if (v->fcm == ILACE_FRAME) {
1147             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1148             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1149             if (v->bfraction == 0) {
1150                 return -1;
1151             }
1152         }
1153         if (v->extended_mv)
1154             v->mvrange = get_unary(gb, 0, 3);
1155         else
1156             v->mvrange = 0;
1157         v->k_x     = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1158         v->k_y     = v->mvrange + 8; //k_y can be 8 9 10 11
1159         v->range_x = 1 << (v->k_x - 1);
1160         v->range_y = 1 << (v->k_y - 1);
1161
1162         if (v->pq < 5)
1163             v->tt_index = 0;
1164         else if (v->pq < 13)
1165             v->tt_index = 1;
1166         else
1167             v->tt_index = 2;
1168
1169         if (v->field_mode) {
1170             int mvmode;
1171             av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1172             if (v->extended_dmv)
1173                 v->dmvrange = get_unary(gb, 0, 3);
1174             mvmode = get_unary(gb, 1, 3);
1175             lowquant = (v->pq > 12) ? 0 : 1;
1176             v->mv_mode          = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1177             v->qs_last          = v->s.quarter_sample;
1178             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1179             v->s.mspel          = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1180             status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1181             if (status < 0)
1182                 return -1;
1183             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1184                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1185             mbmodetab = get_bits(gb, 3);
1186             if (v->mv_mode == MV_PMODE_MIXED_MV)
1187                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1188             else
1189                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1190             imvtab       = get_bits(gb, 3);
1191             v->imv_vlc   = &ff_vc1_2ref_mvdata_vlc[imvtab];
1192             icbptab      = get_bits(gb, 3);
1193             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1194             if (v->mv_mode == MV_PMODE_MIXED_MV) {
1195                 fourmvbptab     = get_bits(gb, 2);
1196                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1197             }
1198             v->numref = 1; // interlaced field B pictures are always 2-ref
1199         } else if (v->fcm == ILACE_FRAME) {
1200             if (v->extended_dmv)
1201                 v->dmvrange = get_unary(gb, 0, 3);
1202             get_bits1(gb); /* intcomp - present but shall always be 0 */
1203             v->intcomp          = 0;
1204             v->mv_mode          = MV_PMODE_1MV;
1205             v->fourmvswitch     = 0;
1206             v->qs_last          = v->s.quarter_sample;
1207             v->s.quarter_sample = 1;
1208             v->s.mspel          = 1;
1209             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1210             if (status < 0)
1211                 return -1;
1212             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1213                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1214             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1215             if (status < 0)
1216                 return -1;
1217             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1218                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1219             mbmodetab       = get_bits(gb, 2);
1220             v->mbmode_vlc   = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1221             imvtab          = get_bits(gb, 2);
1222             v->imv_vlc      = &ff_vc1_1ref_mvdata_vlc[imvtab];
1223             // interlaced p/b-picture cbpcy range is [1, 63]
1224             icbptab         = get_bits(gb, 3);
1225             v->cbpcy_vlc    = &ff_vc1_icbpcy_vlc[icbptab];
1226             twomvbptab      = get_bits(gb, 2);
1227             v->twomvbp_vlc  = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1228             fourmvbptab     = get_bits(gb, 2);
1229             v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1230         } else {
1231             v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1232             v->qs_last          = v->s.quarter_sample;
1233             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1234             v->s.mspel          = v->s.quarter_sample;
1235             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1236             if (status < 0)
1237                 return -1;
1238             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1239                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1240             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1241             if (status < 0)
1242                 return -1;
1243             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1244                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1245             v->s.mv_table_index = get_bits(gb, 2);
1246             v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1247         }
1248
1249         if (v->dquant) {
1250             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1251             vop_dquant_decoding(v);
1252         }
1253
1254         v->ttfrm = 0;
1255         if (v->vstransform) {
1256             v->ttmbf = get_bits1(gb);
1257             if (v->ttmbf) {
1258                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1259             }
1260         } else {
1261             v->ttmbf = 1;
1262             v->ttfrm = TT_8X8;
1263         }
1264         break;
1265     }
1266
1267     if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1268         v->range_x <<= 1;
1269         v->range_y <<= 1;
1270     }
1271
1272     /* AC Syntax */
1273     v->c_ac_table_index = decode012(gb);
1274     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1275         v->y_ac_table_index = decode012(gb);
1276     }
1277     /* DC Syntax */
1278     v->s.dc_table_index = get_bits1(gb);
1279     if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1280         && v->dquant) {
1281         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1282         vop_dquant_decoding(v);
1283     }
1284
1285     v->bi_type = 0;
1286     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1287         v->s.pict_type = AV_PICTURE_TYPE_B;
1288         v->bi_type = 1;
1289     }
1290     return 0;
1291 }
1292
1293 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1294 {
1295 { 0x0001,  2}, { 0x0005,  3}, { 0x000D,  4}, { 0x0012,  5}, { 0x000E,  6}, { 0x0015,  7},
1296 { 0x0013,  8}, { 0x003F,  8}, { 0x004B,  9}, { 0x011F,  9}, { 0x00B8, 10}, { 0x03E3, 10},
1297 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1298 { 0x3EAE, 14}, { 0x0000,  4}, { 0x0010,  5}, { 0x0008,  7}, { 0x0020,  8}, { 0x0029,  9},
1299 { 0x01F4,  9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1300 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003,  5}, { 0x0011,  7},
1301 { 0x00C4,  8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1302 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013,  5}, { 0x0078,  7},
1303 { 0x0069,  9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1304 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C,  6}, { 0x0024,  9}, { 0x0094, 11},
1305 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D,  6}, { 0x0053,  9}, { 0x01A0, 11},
1306 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013,  7}, { 0x007C,  9}, { 0x07C1, 11}, { 0x04AC, 14},
1307 { 0x001B,  7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079,  7}, { 0x03E1, 10},
1308 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021,  8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1309 { 0x0035,  8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5,  8}, { 0x0174, 11}, { 0x0785, 13},
1310 { 0x0048,  9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C,  9}, { 0x00FA, 10}, { 0x07D6, 11},
1311 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1312 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1313 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1314 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E,  4},
1315 { 0x0045,  7}, { 0x01F3,  9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019,  5},
1316 { 0x0028,  9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030,  6}, { 0x00A2, 10},
1317 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F,  6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1318 { 0x0044,  7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063,  7}, { 0x03C3, 12}, { 0x0015,  8},
1319 { 0x08F6, 12}, { 0x0017,  8}, { 0x0498, 13}, { 0x002C,  8}, { 0x07B2, 13}, { 0x002F,  8},
1320 { 0x1F54, 13}, { 0x008D,  8}, { 0x07BD, 13}, { 0x008E,  8}, { 0x1182, 13}, { 0x00FB,  8},
1321 { 0x050B, 13}, { 0x002D,  8}, { 0x07C0, 11}, { 0x0079,  9}, { 0x1F5F, 13}, { 0x007A,  9},
1322 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1323 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1324 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1325 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A,  9}
1326 },
1327 {
1328 { 0x0000,  3}, { 0x0003,  4}, { 0x000B,  5}, { 0x0014,  6}, { 0x003F,  6}, { 0x005D,  7},
1329 { 0x00A2,  8}, { 0x00AC,  9}, { 0x016E,  9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1330 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1331 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004,  4},
1332 { 0x001E,  5}, { 0x0042,  7}, { 0x00B6,  8}, { 0x0173,  9}, { 0x0395, 10}, { 0x072E, 11},
1333 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005,  5}, { 0x0040,  7},
1334 { 0x0049,  9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1335 { 0x0018,  5}, { 0x0025,  8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1336 { 0x139C, 15}, { 0x0029,  6}, { 0x004F,  9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1337 { 0x0038,  6}, { 0x010E,  9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058,  7},
1338 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023,  8}, { 0x02E3, 10}, { 0x04E5, 13},
1339 { 0x2E40, 14}, { 0x00A1,  8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083,  8}, { 0x013A, 11},
1340 { 0x1721, 13}, { 0x0044,  9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1341 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1342 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1343 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1344 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003,  3}, { 0x002A,  6}, { 0x00E4,  8},
1345 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1346 { 0x0009,  4}, { 0x0054,  8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D,  4},
1347 { 0x00AD,  9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011,  5}, { 0x016B,  9}, { 0x0B7F, 12},
1348 { 0x51A4, 15}, { 0x0019,  5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D,  5}, { 0x0394, 10},
1349 { 0x28D3, 14}, { 0x002B,  6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F,  6}, { 0x0247, 12},
1350 { 0x0010,  7}, { 0x0A35, 12}, { 0x003E,  6}, { 0x0B7A, 12}, { 0x0059,  7}, { 0x105E, 13},
1351 { 0x0026,  8}, { 0x09CF, 14}, { 0x0055,  8}, { 0x1CB5, 13}, { 0x0057,  8}, { 0x0E5B, 12},
1352 { 0x00A0,  8}, { 0x1468, 13}, { 0x0170,  9}, { 0x0090, 10}, { 0x01CE,  9}, { 0x021A, 10},
1353 { 0x0218, 10}, { 0x0168,  9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1354 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1355 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1356 { 0x0169,  9}
1357 },
1358 {
1359 { 0x0001,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x0016,  5}, { 0x0020,  6}, { 0x0018,  7},
1360 { 0x0008,  8}, { 0x009A,  8}, { 0x0056,  9}, { 0x013E,  9}, { 0x00F0, 10}, { 0x03A5, 10},
1361 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001,  4}, { 0x0011,  5},
1362 { 0x0002,  7}, { 0x000B,  8}, { 0x0012,  9}, { 0x01D6,  9}, { 0x027E, 10}, { 0x0191, 11},
1363 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004,  5}, { 0x0014,  7}, { 0x009E,  8},
1364 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017,  5},
1365 { 0x004E,  7}, { 0x005E,  9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1366 { 0x000E,  6}, { 0x00E1,  8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B,  6},
1367 { 0x001C,  9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006,  7}, { 0x007A,  9}, { 0x0190, 11},
1368 { 0x0137, 13}, { 0x001B,  7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071,  7}, { 0x00D7, 10},
1369 { 0x09BF, 12}, { 0x0007,  8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034,  8}, { 0x0265, 10},
1370 { 0x009F, 12}, { 0x00E0,  8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015,  9}, { 0x017D, 11},
1371 { 0x0EBB, 12}, { 0x0014,  9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1372 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1373 { 0x013A, 13}, { 0x000A,  4}, { 0x0042,  7}, { 0x01D3,  9}, { 0x04DD, 11}, { 0x0012,  5},
1374 { 0x00E8,  8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039,  6}, { 0x0264, 10}, { 0x0EBA, 12},
1375 { 0x0000,  7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F,  7}, { 0x04DE, 11}, { 0x0043,  7},
1376 { 0x04DC, 11}, { 0x0003,  8}, { 0x03CB, 12}, { 0x0006,  8}, { 0x099E, 12}, { 0x002A,  8},
1377 { 0x05F1, 13}, { 0x000F,  8}, { 0x09FE, 12}, { 0x0033,  8}, { 0x09FF, 12}, { 0x0098,  8},
1378 { 0x099F, 12}, { 0x00EA,  8}, { 0x013C, 13}, { 0x002E,  8}, { 0x0192, 11}, { 0x0136,  9},
1379 { 0x006A,  9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1380 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1381 { 0x0016,  7}
1382 },
1383 {
1384 { 0x0004,  3}, { 0x0014,  5}, { 0x0017,  7}, { 0x007F,  8}, { 0x0154,  9}, { 0x01F2, 10},
1385 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1386 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B,  4}, { 0x0037,  7}, { 0x0062,  9}, { 0x0007, 11},
1387 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007,  5},
1388 { 0x006D,  8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002,  6}, { 0x0061,  9},
1389 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A,  6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1390 { 0x001E,  6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006,  7}, { 0x0004, 11},
1391 { 0x02F8, 13}, { 0x0019,  7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057,  7}, { 0x0182, 11},
1392 { 0x2AA2, 14}, { 0x0004,  8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D,  8}, { 0x0164, 12},
1393 { 0x076D, 15}, { 0x0002,  9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD,  8}, { 0x0060, 12},
1394 { 0x0C67, 14}, { 0x001C,  9}, { 0x00EE, 13}, { 0x0003,  9}, { 0x02CF, 13}, { 0x00D9,  9},
1395 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1396 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1397 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003,  2}, { 0x0054,  7}, { 0x02AB, 10},
1398 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005,  4}, { 0x00F8,  9}, { 0x0AA9, 12}, { 0x005F, 15},
1399 { 0x0004,  4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004,  5}, { 0x0077, 11}, { 0x076C, 15},
1400 { 0x000E,  5}, { 0x000A, 12}, { 0x000C,  5}, { 0x0562, 11}, { 0x0004,  6}, { 0x031C, 12},
1401 { 0x0006,  6}, { 0x00C8, 13}, { 0x000D,  6}, { 0x01DA, 13}, { 0x0007,  6}, { 0x00C9, 13},
1402 { 0x0001,  7}, { 0x002E, 14}, { 0x0014,  7}, { 0x1596, 13}, { 0x000A,  7}, { 0x0AC2, 12},
1403 { 0x0016,  7}, { 0x015B, 14}, { 0x0015,  7}, { 0x015A, 14}, { 0x000F,  8}, { 0x005E, 15},
1404 { 0x007E,  8}, { 0x00AB,  8}, { 0x002D,  9}, { 0x00D8,  9}, { 0x000B,  9}, { 0x0014, 10},
1405 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E,  9},
1406 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1407 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1408 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D,  9}
1409 },
1410 {
1411 { 0x0002,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x000D,  5}, { 0x000C,  5}, { 0x0015,  6},
1412 { 0x0013,  6}, { 0x0012,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x001E,  8}, { 0x001D,  8},
1413 { 0x0025,  9}, { 0x0024,  9}, { 0x0023,  9}, { 0x0021,  9}, { 0x0021, 10}, { 0x0020, 10},
1414 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1415 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E,  4}, { 0x0014,  6}, { 0x0016,  7},
1416 { 0x001C,  8}, { 0x0020,  9}, { 0x001F,  9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1417 { 0x0055, 12}, { 0x000B,  5}, { 0x0015,  7}, { 0x001E,  9}, { 0x000C, 10}, { 0x0056, 12},
1418 { 0x0011,  6}, { 0x001B,  8}, { 0x001D,  9}, { 0x000B, 10}, { 0x0010,  6}, { 0x0022,  9},
1419 { 0x000A, 10}, { 0x000D,  6}, { 0x001C,  9}, { 0x0008, 10}, { 0x0012,  7}, { 0x001B,  9},
1420 { 0x0054, 12}, { 0x0014,  7}, { 0x001A,  9}, { 0x0057, 12}, { 0x0019,  8}, { 0x0009, 10},
1421 { 0x0018,  8}, { 0x0023, 11}, { 0x0017,  8}, { 0x0019,  9}, { 0x0018,  9}, { 0x0007, 10},
1422 { 0x0058, 12}, { 0x0007,  4}, { 0x000C,  6}, { 0x0016,  8}, { 0x0017,  9}, { 0x0006, 10},
1423 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F,  6}, { 0x0016,  9}, { 0x0005, 10},
1424 { 0x000E,  6}, { 0x0004, 10}, { 0x0011,  7}, { 0x0024, 11}, { 0x0010,  7}, { 0x0025, 11},
1425 { 0x0013,  7}, { 0x005A, 12}, { 0x0015,  8}, { 0x005B, 12}, { 0x0014,  8}, { 0x0013,  8},
1426 { 0x001A,  8}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9}, { 0x0012,  9}, { 0x0011,  9},
1427 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1428 { 0x0003,  7}
1429 },
1430 {
1431 { 0x0002,  2}, { 0x000F,  4}, { 0x0015,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x0025,  9},
1432 { 0x0024,  9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1433 { 0x0006,  3}, { 0x0014,  6}, { 0x001E,  8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1434 { 0x000E,  4}, { 0x001D,  8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D,  5}, { 0x0023,  9},
1435 { 0x000D, 10}, { 0x000C,  5}, { 0x0022,  9}, { 0x0052, 12}, { 0x000B,  5}, { 0x000C, 10},
1436 { 0x0053, 12}, { 0x0013,  6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012,  6}, { 0x000A, 10},
1437 { 0x0011,  6}, { 0x0009, 10}, { 0x0010,  6}, { 0x0008, 10}, { 0x0016,  7}, { 0x0055, 12},
1438 { 0x0015,  7}, { 0x0014,  7}, { 0x001C,  8}, { 0x001B,  8}, { 0x0021,  9}, { 0x0020,  9},
1439 { 0x001F,  9}, { 0x001E,  9}, { 0x001D,  9}, { 0x001C,  9}, { 0x001B,  9}, { 0x001A,  9},
1440 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007,  4}, { 0x0019,  9},
1441 { 0x0005, 11}, { 0x000F,  6}, { 0x0004, 11}, { 0x000E,  6}, { 0x000D,  6}, { 0x000C,  6},
1442 { 0x0013,  7}, { 0x0012,  7}, { 0x0011,  7}, { 0x0010,  7}, { 0x001A,  8}, { 0x0019,  8},
1443 { 0x0018,  8}, { 0x0017,  8}, { 0x0016,  8}, { 0x0015,  8}, { 0x0014,  8}, { 0x0013,  8},
1444 { 0x0018,  9}, { 0x0017,  9}, { 0x0016,  9}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9},
1445 { 0x0012,  9}, { 0x0011,  9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1446 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1447 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1448 { 0x0003,  7}
1449 },
1450 {
1451 { 0x0000,  2}, { 0x0003,  3}, { 0x000D,  4}, { 0x0005,  4}, { 0x001C,  5}, { 0x0016,  5},
1452 { 0x003F,  6}, { 0x003A,  6}, { 0x002E,  6}, { 0x0022,  6}, { 0x007B,  7}, { 0x0067,  7},
1453 { 0x005F,  7}, { 0x0047,  7}, { 0x0026,  7}, { 0x00EF,  8}, { 0x00CD,  8}, { 0x00C1,  8},
1454 { 0x00A9,  8}, { 0x004F,  8}, { 0x01F2,  9}, { 0x01DD,  9}, { 0x0199,  9}, { 0x0185,  9},
1455 { 0x015D,  9}, { 0x011B,  9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1456 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1457 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1458 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1459 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1460 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009,  4}, { 0x0010,  5}, { 0x0029,  6}, { 0x0062,  7},
1461 { 0x00F3,  8}, { 0x00AD,  8}, { 0x01E5,  9}, { 0x0179,  9}, { 0x009C,  9}, { 0x03B1, 10},
1462 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1463 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008,  5}, { 0x0063,  7},
1464 { 0x00AF,  8}, { 0x017B,  9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1465 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028,  6}, { 0x00C3,  8}, { 0x0151,  9}, { 0x02A1, 10},
1466 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065,  7}, { 0x01DA,  9}, { 0x02AF, 10},
1467 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025,  7}, { 0x0118,  9}, { 0x0646, 11},
1468 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9,  8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1469 { 0x0048,  8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180,  9}, { 0x0465, 11}, { 0x1905, 13},
1470 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1471 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1472 { 0x0078,  7}, { 0x0155,  9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA,  8}, { 0x07DC, 11},
1473 { 0x1907, 13}, { 0x00AC,  8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6,  9}, { 0x0AE2, 12},
1474 { 0x01DC,  9}, { 0x04ED, 12}, { 0x0184,  9}, { 0x1904, 13}, { 0x0156,  9}, { 0x09D9, 13},
1475 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1476 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1477 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1478 { 0x007A,  7}
1479 },
1480 {
1481 { 0x0002,  2}, { 0x0000,  3}, { 0x001E,  5}, { 0x0004,  5}, { 0x0012,  6}, { 0x0070,  7},
1482 { 0x001A,  7}, { 0x005F,  8}, { 0x0047,  8}, { 0x01D3,  9}, { 0x00B5,  9}, { 0x0057,  9},
1483 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1484 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1485 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1486 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003,  3}, { 0x000A,  5}, { 0x0077,  7}, { 0x00E5,  8},
1487 { 0x01D9,  9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1488 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C,  4}, { 0x007D,  7}, { 0x0044,  8},
1489 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B,  5},
1490 { 0x00E2,  8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007,  5},
1491 { 0x01D8,  9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035,  6}, { 0x03E1, 10},
1492 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C,  6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1493 { 0x0068,  7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020,  7}, { 0x0F90, 12}, { 0x7CF6, 15},
1494 { 0x00E8,  8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045,  8}, { 0x0B3A, 13}, { 0x01F1,  9},
1495 { 0x3B46, 14}, { 0x01A7,  9}, { 0x1676, 14}, { 0x0056,  9}, { 0x692A, 15}, { 0x038D, 10},
1496 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1497 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1498 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1499 { 0x055F, 13}, { 0x003F,  6}, { 0x006D,  9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013,  6},
1500 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B,  6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075,  7},
1501 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E,  7}, { 0x1F22, 13}, { 0x0021,  7}, { 0x054F, 13},
1502 { 0x0014,  7}, { 0x3A44, 14}, { 0x00E4,  8}, { 0x7CF7, 15}, { 0x005E,  8}, { 0x7185, 15},
1503 { 0x0037,  8}, { 0x2C73, 15}, { 0x01DB,  9}, { 0x59DD, 16}, { 0x01C7,  9}, { 0x692B, 15},
1504 { 0x01A6,  9}, { 0x58E5, 16}, { 0x00B4,  9}, { 0x1F3D0, 17}, { 0x00B0,  9}, { 0xB1C9, 17},
1505 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1506 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1507 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1508 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1509 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1510 { 0x0073,  7}
1511 }
1512 };
1513
1514 static const uint16_t vlc_offs[] = {
1515         0,   520,   552,   616,  1128,  1160,  1224,  1740,  1772,  1836,  1900,  2436,
1516      2986,  3050,  3610,  4154,  4218,  4746,  5326,  5390,  5902,  6554,  7658,  8342,
1517      9304,  9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1518     20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1519     27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1520     29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1521     31714, 31746, 31778, 32306, 32340, 32372
1522 };
1523
1524 /**
1525  * Init VC-1 specific tables and VC1Context members
1526  * @param v The VC1Context to initialize
1527  * @return Status
1528  */
1529 int ff_vc1_init_common(VC1Context *v)
1530 {
1531     static int done = 0;
1532     int i = 0;
1533     static VLC_TYPE vlc_table[32372][2];
1534
1535     v->hrd_rate = v->hrd_buffer = NULL;
1536
1537     /* VLC tables */
1538     if (!done) {
1539         INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1540                         ff_vc1_bfraction_bits, 1, 1,
1541                         ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1542         INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1543                         ff_vc1_norm2_bits, 1, 1,
1544                         ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1545         INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1546                         ff_vc1_norm6_bits, 1, 1,
1547                         ff_vc1_norm6_codes, 2, 2, 556);
1548         INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1549                         ff_vc1_imode_bits, 1, 1,
1550                         ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1551         for (i = 0; i < 3; i++) {
1552             ff_vc1_ttmb_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 0]];
1553             ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1554             init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1555                      ff_vc1_ttmb_bits[i], 1, 1,
1556                      ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1557             ff_vc1_ttblk_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 1]];
1558             ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1559             init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1560                      ff_vc1_ttblk_bits[i], 1, 1,
1561                      ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1562             ff_vc1_subblkpat_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 2]];
1563             ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1564             init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1565                      ff_vc1_subblkpat_bits[i], 1, 1,
1566                      ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1567         }
1568         for (i = 0; i < 4; i++) {
1569             ff_vc1_4mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 9]];
1570             ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1571             init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1572                      ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1573                      ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1574             ff_vc1_cbpcy_p_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 10]];
1575             ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1576             init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1577                      ff_vc1_cbpcy_p_bits[i], 1, 1,
1578                      ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1579             ff_vc1_mv_diff_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 11]];
1580             ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1581             init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1582                      ff_vc1_mv_diff_bits[i], 1, 1,
1583                      ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1584         }
1585         for (i = 0; i < 8; i++) {
1586             ff_vc1_ac_coeff_table[i].table           = &vlc_table[vlc_offs[i * 2 + 21]];
1587             ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1588             init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1589                      &vc1_ac_tables[i][0][1], 8, 4,
1590                      &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1591             /* initialize interlaced MVDATA tables (2-Ref) */
1592             ff_vc1_2ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 2 + 22]];
1593             ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1594             init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1595                      ff_vc1_2ref_mvdata_bits[i], 1, 1,
1596                      ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1597         }
1598         for (i = 0; i < 4; i++) {
1599             /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1600             ff_vc1_intfr_4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 37]];
1601             ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1602             init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1603                      ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1604                      ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1605             /* initialize NON-4MV MBMODE VLC tables for the same */
1606             ff_vc1_intfr_non4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 38]];
1607             ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1608             init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1609                      ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1610                      ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1611             /* initialize interlaced MVDATA tables (1-Ref) */
1612             ff_vc1_1ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 39]];
1613             ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1614             init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1615                      ff_vc1_1ref_mvdata_bits[i], 1, 1,
1616                      ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1617         }
1618         for (i = 0; i < 4; i++) {
1619             /* Initialize 2MV Block pattern VLC tables */
1620             ff_vc1_2mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i + 49]];
1621             ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1622             init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1623                      ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1624                      ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1625         }
1626         for (i = 0; i < 8; i++) {
1627             /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1628             ff_vc1_icbpcy_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 53]];
1629             ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1630             init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1631                      ff_vc1_icbpcy_p_bits[i], 1, 1,
1632                      ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1633             /* Initialize interlaced field picture MBMODE VLC tables */
1634             ff_vc1_if_mmv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 54]];
1635             ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1636             init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1637                      ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1638                      ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1639             ff_vc1_if_1mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 55]];
1640             ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1641             init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1642                      ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1643                      ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1644         }
1645         done = 1;
1646     }
1647
1648     /* Other defaults */
1649     v->pq      = -1;
1650     v->mvrange = 0; /* 7.1.1.18, p80 */
1651
1652     return 0;
1653 }