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