git.sesse.net Git - ffmpeg/blob - libavcodec/vc1.c

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