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