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

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