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