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