code.vuplus.com Git - vuplus_xbmc/blob - lib/ffmpeg/libavcodec/vc1.c

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