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