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