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

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