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         }
1020         if (v->extended_mv)
1021             v->mvrange = get_unary(gb, 0, 3);
1022         else
1023             v->mvrange = 0;
1024         if (v->interlace) {
1025             if (v->extended_dmv)
1026                 v->dmvrange = get_unary(gb, 0, 3);
1027             else
1028                 v->dmvrange = 0;
1029             if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1030                 v->fourmvswitch = get_bits1(gb);
1031                 v->intcomp      = get_bits1(gb);
1032                 if (v->intcomp) {
1033                     v->lumscale = get_bits(gb, 6);
1034                     v->lumshift = get_bits(gb, 6);
1035                     INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1036                     INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1037                     v->last_use_ic = 1;
1038                 }
1039                 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1040                 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1041                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1042                 mbmodetab = get_bits(gb, 2);
1043                 if (v->fourmvswitch)
1044                     v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1045                 else
1046                     v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1047                 imvtab         = get_bits(gb, 2);
1048                 v->imv_vlc     = &ff_vc1_1ref_mvdata_vlc[imvtab];
1049                 // interlaced p-picture cbpcy range is [1, 63]
1050                 icbptab        = get_bits(gb, 3);
1051                 v->cbpcy_vlc   = &ff_vc1_icbpcy_vlc[icbptab];
1052                 twomvbptab     = get_bits(gb, 2);
1053                 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1054                 if (v->fourmvswitch) {
1055                     fourmvbptab     = get_bits(gb, 2);
1056                     v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1057                 }
1058             }
1059         }
1060         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1061         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1062         v->range_x = 1 << (v->k_x - 1);
1063         v->range_y = 1 << (v->k_y - 1);
1064
1065         if (v->pq < 5)
1066             v->tt_index = 0;
1067         else if (v->pq < 13)
1068             v->tt_index = 1;
1069         else
1070             v->tt_index = 2;
1071         if (v->fcm != ILACE_FRAME) {
1072             int mvmode;
1073             mvmode     = get_unary(gb, 1, 4);
1074             lowquant   = (v->pq > 12) ? 0 : 1;
1075             v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1076             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1077                 int mvmode2;
1078                 mvmode2 = get_unary(gb, 1, 3);
1079                 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1080                 if (v->field_mode) {
1081                     v->intcompfield = decode210(gb) ^ 3;
1082                 } else
1083                     v->intcompfield = 3;
1084
1085                 v->lumscale2 = v->lumscale = 32;
1086                 v->lumshift2 = v->lumshift =  0;
1087                 if (v->intcompfield & 1) {
1088                     v->lumscale = get_bits(gb, 6);
1089                     v->lumshift = get_bits(gb, 6);
1090                 }
1091                 if ((v->intcompfield & 2) && v->field_mode) {
1092                     v->lumscale2 = get_bits(gb, 6);
1093                     v->lumshift2 = get_bits(gb, 6);
1094                 } else if(!v->field_mode) {
1095                     v->lumscale2 = v->lumscale;
1096                     v->lumshift2 = v->lumshift;
1097                 }
1098                 if (v->field_mode && v->second_field) {
1099                     if (v->cur_field_type) {
1100                         INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1101                         INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type  ], v->last_lutuv[v->cur_field_type  ], 1);
1102                     } else {
1103                         INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1104                         INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type  ], v->last_lutuv[v->cur_field_type  ], 1);
1105                     }
1106                     v->next_use_ic = *v->curr_use_ic = 1;
1107                 } else {
1108                     INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1109                     INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1110                 }
1111                 v->last_use_ic = 1;
1112             }
1113             v->qs_last = v->s.quarter_sample;
1114             if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1115                 v->s.quarter_sample = 0;
1116             else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1117                 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1118                     v->s.quarter_sample = 0;
1119                 else
1120                     v->s.quarter_sample = 1;
1121             } else
1122                 v->s.quarter_sample = 1;
1123             v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1124                            || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1125                                && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1126         }
1127         if (v->fcm == PROGRESSIVE) { // progressive
1128             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1129                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1130                 || v->mv_mode == MV_PMODE_MIXED_MV) {
1131                 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1132                 if (status < 0)
1133                     return -1;
1134                 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1135                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1136             } else {
1137                 v->mv_type_is_raw = 0;
1138                 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1139             }
1140             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1141             if (status < 0)
1142                 return -1;
1143             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1144                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1145
1146             /* Hopefully this is correct for P frames */
1147             v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1148             v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1149         } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1150             v->qs_last          = v->s.quarter_sample;
1151             v->s.quarter_sample = 1;
1152             v->s.mspel          = 1;
1153         } else {    // field interlaced
1154             mbmodetab = get_bits(gb, 3);
1155             imvtab = get_bits(gb, 2 + v->numref);
1156             if (!v->numref)
1157                 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1158             else
1159                 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1160             icbptab = get_bits(gb, 3);
1161             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1162             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1163                 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1164                 fourmvbptab     = get_bits(gb, 2);
1165                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1166                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1167             } else {
1168                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1169             }
1170         }
1171         if (v->dquant) {
1172             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1173             vop_dquant_decoding(v);
1174         }
1175
1176         v->ttfrm = 0; //FIXME Is that so ?
1177         if (v->vstransform) {
1178             v->ttmbf = get_bits1(gb);
1179             if (v->ttmbf) {
1180                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1181             }
1182         } else {
1183             v->ttmbf = 1;
1184             v->ttfrm = TT_8X8;
1185         }
1186         break;
1187     case AV_PICTURE_TYPE_B:
1188         if (v->fcm == ILACE_FRAME) {
1189             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1190             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1191             if (v->bfraction == 0) {
1192                 return -1;
1193             }
1194         }
1195         if (v->extended_mv)
1196             v->mvrange = get_unary(gb, 0, 3);
1197         else
1198             v->mvrange = 0;
1199         v->k_x     = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1200         v->k_y     = v->mvrange + 8; //k_y can be 8 9 10 11
1201         v->range_x = 1 << (v->k_x - 1);
1202         v->range_y = 1 << (v->k_y - 1);
1203
1204         if (v->pq < 5)
1205             v->tt_index = 0;
1206         else if (v->pq < 13)
1207             v->tt_index = 1;
1208         else
1209             v->tt_index = 2;
1210
1211         if (v->field_mode) {
1212             int mvmode;
1213             av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1214             if (v->extended_dmv)
1215                 v->dmvrange = get_unary(gb, 0, 3);
1216             mvmode = get_unary(gb, 1, 3);
1217             lowquant = (v->pq > 12) ? 0 : 1;
1218             v->mv_mode          = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1219             v->qs_last          = v->s.quarter_sample;
1220             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1221             v->s.mspel          = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1222             status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1223             if (status < 0)
1224                 return -1;
1225             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1226                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1227             mbmodetab = get_bits(gb, 3);
1228             if (v->mv_mode == MV_PMODE_MIXED_MV)
1229                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1230             else
1231                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1232             imvtab       = get_bits(gb, 3);
1233             v->imv_vlc   = &ff_vc1_2ref_mvdata_vlc[imvtab];
1234             icbptab      = get_bits(gb, 3);
1235             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1236             if (v->mv_mode == MV_PMODE_MIXED_MV) {
1237                 fourmvbptab     = get_bits(gb, 2);
1238                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1239             }
1240             v->numref = 1; // interlaced field B pictures are always 2-ref
1241         } else if (v->fcm == ILACE_FRAME) {
1242             if (v->extended_dmv)
1243                 v->dmvrange = get_unary(gb, 0, 3);
1244             if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1245                 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1246             v->intcomp          = 0;
1247             v->mv_mode          = MV_PMODE_1MV;
1248             v->fourmvswitch     = 0;
1249             v->qs_last          = v->s.quarter_sample;
1250             v->s.quarter_sample = 1;
1251             v->s.mspel          = 1;
1252             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1253             if (status < 0)
1254                 return -1;
1255             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1256                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1257             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1258             if (status < 0)
1259                 return -1;
1260             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1261                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1262             mbmodetab       = get_bits(gb, 2);
1263             v->mbmode_vlc   = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1264             imvtab          = get_bits(gb, 2);
1265             v->imv_vlc      = &ff_vc1_1ref_mvdata_vlc[imvtab];
1266             // interlaced p/b-picture cbpcy range is [1, 63]
1267             icbptab         = get_bits(gb, 3);
1268             v->cbpcy_vlc    = &ff_vc1_icbpcy_vlc[icbptab];
1269             twomvbptab      = get_bits(gb, 2);
1270             v->twomvbp_vlc  = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1271             fourmvbptab     = get_bits(gb, 2);
1272             v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1273         } else {
1274             v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1275             v->qs_last          = v->s.quarter_sample;
1276             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1277             v->s.mspel          = v->s.quarter_sample;
1278             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1279             if (status < 0)
1280                 return -1;
1281             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1282                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1283             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1284             if (status < 0)
1285                 return -1;
1286             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1287                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1288             v->s.mv_table_index = get_bits(gb, 2);
1289             v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1290         }
1291
1292         if (v->dquant) {
1293             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1294             vop_dquant_decoding(v);
1295         }
1296
1297         v->ttfrm = 0;
1298         if (v->vstransform) {
1299             v->ttmbf = get_bits1(gb);
1300             if (v->ttmbf) {
1301                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1302             }
1303         } else {
1304             v->ttmbf = 1;
1305             v->ttfrm = TT_8X8;
1306         }
1307         break;
1308     }
1309
1310     if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1311         v->range_x <<= 1;
1312         v->range_y <<= 1;
1313     }
1314
1315     /* AC Syntax */
1316     v->c_ac_table_index = decode012(gb);
1317     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1318         v->y_ac_table_index = decode012(gb);
1319     }
1320     /* DC Syntax */
1321     v->s.dc_table_index = get_bits1(gb);
1322     if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1323         && v->dquant) {
1324         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1325         vop_dquant_decoding(v);
1326     }
1327
1328     v->bi_type = 0;
1329     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1330         v->s.pict_type = AV_PICTURE_TYPE_B;
1331         v->bi_type = 1;
1332     }
1333     return 0;
1334 }
1335
1336 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1337 {
1338 { 0x0001,  2}, { 0x0005,  3}, { 0x000D,  4}, { 0x0012,  5}, { 0x000E,  6}, { 0x0015,  7},
1339 { 0x0013,  8}, { 0x003F,  8}, { 0x004B,  9}, { 0x011F,  9}, { 0x00B8, 10}, { 0x03E3, 10},
1340 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1341 { 0x3EAE, 14}, { 0x0000,  4}, { 0x0010,  5}, { 0x0008,  7}, { 0x0020,  8}, { 0x0029,  9},
1342 { 0x01F4,  9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1343 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003,  5}, { 0x0011,  7},
1344 { 0x00C4,  8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1345 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013,  5}, { 0x0078,  7},
1346 { 0x0069,  9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1347 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C,  6}, { 0x0024,  9}, { 0x0094, 11},
1348 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D,  6}, { 0x0053,  9}, { 0x01A0, 11},
1349 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013,  7}, { 0x007C,  9}, { 0x07C1, 11}, { 0x04AC, 14},
1350 { 0x001B,  7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079,  7}, { 0x03E1, 10},
1351 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021,  8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1352 { 0x0035,  8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5,  8}, { 0x0174, 11}, { 0x0785, 13},
1353 { 0x0048,  9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C,  9}, { 0x00FA, 10}, { 0x07D6, 11},
1354 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1355 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1356 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1357 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E,  4},
1358 { 0x0045,  7}, { 0x01F3,  9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019,  5},
1359 { 0x0028,  9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030,  6}, { 0x00A2, 10},
1360 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F,  6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1361 { 0x0044,  7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063,  7}, { 0x03C3, 12}, { 0x0015,  8},
1362 { 0x08F6, 12}, { 0x0017,  8}, { 0x0498, 13}, { 0x002C,  8}, { 0x07B2, 13}, { 0x002F,  8},
1363 { 0x1F54, 13}, { 0x008D,  8}, { 0x07BD, 13}, { 0x008E,  8}, { 0x1182, 13}, { 0x00FB,  8},
1364 { 0x050B, 13}, { 0x002D,  8}, { 0x07C0, 11}, { 0x0079,  9}, { 0x1F5F, 13}, { 0x007A,  9},
1365 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1366 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1367 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1368 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A,  9}
1369 },
1370 {
1371 { 0x0000,  3}, { 0x0003,  4}, { 0x000B,  5}, { 0x0014,  6}, { 0x003F,  6}, { 0x005D,  7},
1372 { 0x00A2,  8}, { 0x00AC,  9}, { 0x016E,  9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1373 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1374 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004,  4},
1375 { 0x001E,  5}, { 0x0042,  7}, { 0x00B6,  8}, { 0x0173,  9}, { 0x0395, 10}, { 0x072E, 11},
1376 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005,  5}, { 0x0040,  7},
1377 { 0x0049,  9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1378 { 0x0018,  5}, { 0x0025,  8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1379 { 0x139C, 15}, { 0x0029,  6}, { 0x004F,  9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1380 { 0x0038,  6}, { 0x010E,  9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058,  7},
1381 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023,  8}, { 0x02E3, 10}, { 0x04E5, 13},
1382 { 0x2E40, 14}, { 0x00A1,  8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083,  8}, { 0x013A, 11},
1383 { 0x1721, 13}, { 0x0044,  9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1384 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1385 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1386 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1387 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003,  3}, { 0x002A,  6}, { 0x00E4,  8},
1388 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1389 { 0x0009,  4}, { 0x0054,  8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D,  4},
1390 { 0x00AD,  9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011,  5}, { 0x016B,  9}, { 0x0B7F, 12},
1391 { 0x51A4, 15}, { 0x0019,  5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D,  5}, { 0x0394, 10},
1392 { 0x28D3, 14}, { 0x002B,  6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F,  6}, { 0x0247, 12},
1393 { 0x0010,  7}, { 0x0A35, 12}, { 0x003E,  6}, { 0x0B7A, 12}, { 0x0059,  7}, { 0x105E, 13},
1394 { 0x0026,  8}, { 0x09CF, 14}, { 0x0055,  8}, { 0x1CB5, 13}, { 0x0057,  8}, { 0x0E5B, 12},
1395 { 0x00A0,  8}, { 0x1468, 13}, { 0x0170,  9}, { 0x0090, 10}, { 0x01CE,  9}, { 0x021A, 10},
1396 { 0x0218, 10}, { 0x0168,  9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1397 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1398 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1399 { 0x0169,  9}
1400 },
1401 {
1402 { 0x0001,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x0016,  5}, { 0x0020,  6}, { 0x0018,  7},
1403 { 0x0008,  8}, { 0x009A,  8}, { 0x0056,  9}, { 0x013E,  9}, { 0x00F0, 10}, { 0x03A5, 10},
1404 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001,  4}, { 0x0011,  5},
1405 { 0x0002,  7}, { 0x000B,  8}, { 0x0012,  9}, { 0x01D6,  9}, { 0x027E, 10}, { 0x0191, 11},
1406 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004,  5}, { 0x0014,  7}, { 0x009E,  8},
1407 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017,  5},
1408 { 0x004E,  7}, { 0x005E,  9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1409 { 0x000E,  6}, { 0x00E1,  8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B,  6},
1410 { 0x001C,  9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006,  7}, { 0x007A,  9}, { 0x0190, 11},
1411 { 0x0137, 13}, { 0x001B,  7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071,  7}, { 0x00D7, 10},
1412 { 0x09BF, 12}, { 0x0007,  8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034,  8}, { 0x0265, 10},
1413 { 0x009F, 12}, { 0x00E0,  8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015,  9}, { 0x017D, 11},
1414 { 0x0EBB, 12}, { 0x0014,  9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1415 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1416 { 0x013A, 13}, { 0x000A,  4}, { 0x0042,  7}, { 0x01D3,  9}, { 0x04DD, 11}, { 0x0012,  5},
1417 { 0x00E8,  8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039,  6}, { 0x0264, 10}, { 0x0EBA, 12},
1418 { 0x0000,  7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F,  7}, { 0x04DE, 11}, { 0x0043,  7},
1419 { 0x04DC, 11}, { 0x0003,  8}, { 0x03CB, 12}, { 0x0006,  8}, { 0x099E, 12}, { 0x002A,  8},
1420 { 0x05F1, 13}, { 0x000F,  8}, { 0x09FE, 12}, { 0x0033,  8}, { 0x09FF, 12}, { 0x0098,  8},
1421 { 0x099F, 12}, { 0x00EA,  8}, { 0x013C, 13}, { 0x002E,  8}, { 0x0192, 11}, { 0x0136,  9},
1422 { 0x006A,  9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1423 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1424 { 0x0016,  7}
1425 },
1426 {
1427 { 0x0004,  3}, { 0x0014,  5}, { 0x0017,  7}, { 0x007F,  8}, { 0x0154,  9}, { 0x01F2, 10},
1428 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1429 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B,  4}, { 0x0037,  7}, { 0x0062,  9}, { 0x0007, 11},
1430 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007,  5},
1431 { 0x006D,  8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002,  6}, { 0x0061,  9},
1432 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A,  6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1433 { 0x001E,  6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006,  7}, { 0x0004, 11},
1434 { 0x02F8, 13}, { 0x0019,  7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057,  7}, { 0x0182, 11},
1435 { 0x2AA2, 14}, { 0x0004,  8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D,  8}, { 0x0164, 12},
1436 { 0x076D, 15}, { 0x0002,  9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD,  8}, { 0x0060, 12},
1437 { 0x0C67, 14}, { 0x001C,  9}, { 0x00EE, 13}, { 0x0003,  9}, { 0x02CF, 13}, { 0x00D9,  9},
1438 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1439 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1440 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003,  2}, { 0x0054,  7}, { 0x02AB, 10},
1441 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005,  4}, { 0x00F8,  9}, { 0x0AA9, 12}, { 0x005F, 15},
1442 { 0x0004,  4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004,  5}, { 0x0077, 11}, { 0x076C, 15},
1443 { 0x000E,  5}, { 0x000A, 12}, { 0x000C,  5}, { 0x0562, 11}, { 0x0004,  6}, { 0x031C, 12},
1444 { 0x0006,  6}, { 0x00C8, 13}, { 0x000D,  6}, { 0x01DA, 13}, { 0x0007,  6}, { 0x00C9, 13},
1445 { 0x0001,  7}, { 0x002E, 14}, { 0x0014,  7}, { 0x1596, 13}, { 0x000A,  7}, { 0x0AC2, 12},
1446 { 0x0016,  7}, { 0x015B, 14}, { 0x0015,  7}, { 0x015A, 14}, { 0x000F,  8}, { 0x005E, 15},
1447 { 0x007E,  8}, { 0x00AB,  8}, { 0x002D,  9}, { 0x00D8,  9}, { 0x000B,  9}, { 0x0014, 10},
1448 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E,  9},
1449 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1450 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1451 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D,  9}
1452 },
1453 {
1454 { 0x0002,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x000D,  5}, { 0x000C,  5}, { 0x0015,  6},
1455 { 0x0013,  6}, { 0x0012,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x001E,  8}, { 0x001D,  8},
1456 { 0x0025,  9}, { 0x0024,  9}, { 0x0023,  9}, { 0x0021,  9}, { 0x0021, 10}, { 0x0020, 10},
1457 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1458 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E,  4}, { 0x0014,  6}, { 0x0016,  7},
1459 { 0x001C,  8}, { 0x0020,  9}, { 0x001F,  9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1460 { 0x0055, 12}, { 0x000B,  5}, { 0x0015,  7}, { 0x001E,  9}, { 0x000C, 10}, { 0x0056, 12},
1461 { 0x0011,  6}, { 0x001B,  8}, { 0x001D,  9}, { 0x000B, 10}, { 0x0010,  6}, { 0x0022,  9},
1462 { 0x000A, 10}, { 0x000D,  6}, { 0x001C,  9}, { 0x0008, 10}, { 0x0012,  7}, { 0x001B,  9},
1463 { 0x0054, 12}, { 0x0014,  7}, { 0x001A,  9}, { 0x0057, 12}, { 0x0019,  8}, { 0x0009, 10},
1464 { 0x0018,  8}, { 0x0023, 11}, { 0x0017,  8}, { 0x0019,  9}, { 0x0018,  9}, { 0x0007, 10},
1465 { 0x0058, 12}, { 0x0007,  4}, { 0x000C,  6}, { 0x0016,  8}, { 0x0017,  9}, { 0x0006, 10},
1466 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F,  6}, { 0x0016,  9}, { 0x0005, 10},
1467 { 0x000E,  6}, { 0x0004, 10}, { 0x0011,  7}, { 0x0024, 11}, { 0x0010,  7}, { 0x0025, 11},
1468 { 0x0013,  7}, { 0x005A, 12}, { 0x0015,  8}, { 0x005B, 12}, { 0x0014,  8}, { 0x0013,  8},
1469 { 0x001A,  8}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9}, { 0x0012,  9}, { 0x0011,  9},
1470 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1471 { 0x0003,  7}
1472 },
1473 {
1474 { 0x0002,  2}, { 0x000F,  4}, { 0x0015,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x0025,  9},
1475 { 0x0024,  9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1476 { 0x0006,  3}, { 0x0014,  6}, { 0x001E,  8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1477 { 0x000E,  4}, { 0x001D,  8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D,  5}, { 0x0023,  9},
1478 { 0x000D, 10}, { 0x000C,  5}, { 0x0022,  9}, { 0x0052, 12}, { 0x000B,  5}, { 0x000C, 10},
1479 { 0x0053, 12}, { 0x0013,  6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012,  6}, { 0x000A, 10},
1480 { 0x0011,  6}, { 0x0009, 10}, { 0x0010,  6}, { 0x0008, 10}, { 0x0016,  7}, { 0x0055, 12},
1481 { 0x0015,  7}, { 0x0014,  7}, { 0x001C,  8}, { 0x001B,  8}, { 0x0021,  9}, { 0x0020,  9},
1482 { 0x001F,  9}, { 0x001E,  9}, { 0x001D,  9}, { 0x001C,  9}, { 0x001B,  9}, { 0x001A,  9},
1483 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007,  4}, { 0x0019,  9},
1484 { 0x0005, 11}, { 0x000F,  6}, { 0x0004, 11}, { 0x000E,  6}, { 0x000D,  6}, { 0x000C,  6},
1485 { 0x0013,  7}, { 0x0012,  7}, { 0x0011,  7}, { 0x0010,  7}, { 0x001A,  8}, { 0x0019,  8},
1486 { 0x0018,  8}, { 0x0017,  8}, { 0x0016,  8}, { 0x0015,  8}, { 0x0014,  8}, { 0x0013,  8},
1487 { 0x0018,  9}, { 0x0017,  9}, { 0x0016,  9}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9},
1488 { 0x0012,  9}, { 0x0011,  9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1489 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1490 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1491 { 0x0003,  7}
1492 },
1493 {
1494 { 0x0000,  2}, { 0x0003,  3}, { 0x000D,  4}, { 0x0005,  4}, { 0x001C,  5}, { 0x0016,  5},
1495 { 0x003F,  6}, { 0x003A,  6}, { 0x002E,  6}, { 0x0022,  6}, { 0x007B,  7}, { 0x0067,  7},
1496 { 0x005F,  7}, { 0x0047,  7}, { 0x0026,  7}, { 0x00EF,  8}, { 0x00CD,  8}, { 0x00C1,  8},
1497 { 0x00A9,  8}, { 0x004F,  8}, { 0x01F2,  9}, { 0x01DD,  9}, { 0x0199,  9}, { 0x0185,  9},
1498 { 0x015D,  9}, { 0x011B,  9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1499 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1500 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1501 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1502 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1503 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009,  4}, { 0x0010,  5}, { 0x0029,  6}, { 0x0062,  7},
1504 { 0x00F3,  8}, { 0x00AD,  8}, { 0x01E5,  9}, { 0x0179,  9}, { 0x009C,  9}, { 0x03B1, 10},
1505 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1506 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008,  5}, { 0x0063,  7},
1507 { 0x00AF,  8}, { 0x017B,  9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1508 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028,  6}, { 0x00C3,  8}, { 0x0151,  9}, { 0x02A1, 10},
1509 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065,  7}, { 0x01DA,  9}, { 0x02AF, 10},
1510 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025,  7}, { 0x0118,  9}, { 0x0646, 11},
1511 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9,  8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1512 { 0x0048,  8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180,  9}, { 0x0465, 11}, { 0x1905, 13},
1513 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1514 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1515 { 0x0078,  7}, { 0x0155,  9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA,  8}, { 0x07DC, 11},
1516 { 0x1907, 13}, { 0x00AC,  8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6,  9}, { 0x0AE2, 12},
1517 { 0x01DC,  9}, { 0x04ED, 12}, { 0x0184,  9}, { 0x1904, 13}, { 0x0156,  9}, { 0x09D9, 13},
1518 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1519 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1520 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1521 { 0x007A,  7}
1522 },
1523 {
1524 { 0x0002,  2}, { 0x0000,  3}, { 0x001E,  5}, { 0x0004,  5}, { 0x0012,  6}, { 0x0070,  7},
1525 { 0x001A,  7}, { 0x005F,  8}, { 0x0047,  8}, { 0x01D3,  9}, { 0x00B5,  9}, { 0x0057,  9},
1526 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1527 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1528 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1529 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003,  3}, { 0x000A,  5}, { 0x0077,  7}, { 0x00E5,  8},
1530 { 0x01D9,  9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1531 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C,  4}, { 0x007D,  7}, { 0x0044,  8},
1532 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B,  5},
1533 { 0x00E2,  8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007,  5},
1534 { 0x01D8,  9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035,  6}, { 0x03E1, 10},
1535 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C,  6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1536 { 0x0068,  7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020,  7}, { 0x0F90, 12}, { 0x7CF6, 15},
1537 { 0x00E8,  8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045,  8}, { 0x0B3A, 13}, { 0x01F1,  9},
1538 { 0x3B46, 14}, { 0x01A7,  9}, { 0x1676, 14}, { 0x0056,  9}, { 0x692A, 15}, { 0x038D, 10},
1539 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1540 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1541 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1542 { 0x055F, 13}, { 0x003F,  6}, { 0x006D,  9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013,  6},
1543 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B,  6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075,  7},
1544 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E,  7}, { 0x1F22, 13}, { 0x0021,  7}, { 0x054F, 13},
1545 { 0x0014,  7}, { 0x3A44, 14}, { 0x00E4,  8}, { 0x7CF7, 15}, { 0x005E,  8}, { 0x7185, 15},
1546 { 0x0037,  8}, { 0x2C73, 15}, { 0x01DB,  9}, { 0x59DD, 16}, { 0x01C7,  9}, { 0x692B, 15},
1547 { 0x01A6,  9}, { 0x58E5, 16}, { 0x00B4,  9}, { 0x1F3D0, 17}, { 0x00B0,  9}, { 0xB1C9, 17},
1548 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1549 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1550 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1551 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1552 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1553 { 0x0073,  7}
1554 }
1555 };
1556
1557 static const uint16_t vlc_offs[] = {
1558         0,   520,   552,   616,  1128,  1160,  1224,  1740,  1772,  1836,  1900,  2436,
1559      2986,  3050,  3610,  4154,  4218,  4746,  5326,  5390,  5902,  6554,  7658,  8342,
1560      9304,  9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1561     20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1562     27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1563     29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1564     31714, 31746, 31778, 32306, 32340, 32372
1565 };
1566
1567 /**
1568  * Init VC-1 specific tables and VC1Context members
1569  * @param v The VC1Context to initialize
1570  * @return Status
1571  */
1572 av_cold int ff_vc1_init_common(VC1Context *v)
1573 {
1574     static int done = 0;
1575     int i = 0;
1576     static VLC_TYPE vlc_table[32372][2];
1577
1578     v->hrd_rate = v->hrd_buffer = NULL;
1579
1580     /* VLC tables */
1581     if (!done) {
1582         INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1583                         ff_vc1_bfraction_bits, 1, 1,
1584                         ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1585         INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1586                         ff_vc1_norm2_bits, 1, 1,
1587                         ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1588         INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1589                         ff_vc1_norm6_bits, 1, 1,
1590                         ff_vc1_norm6_codes, 2, 2, 556);
1591         INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1592                         ff_vc1_imode_bits, 1, 1,
1593                         ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1594         for (i = 0; i < 3; i++) {
1595             ff_vc1_ttmb_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 0]];
1596             ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1597             init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1598                      ff_vc1_ttmb_bits[i], 1, 1,
1599                      ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1600             ff_vc1_ttblk_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 1]];
1601             ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1602             init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1603                      ff_vc1_ttblk_bits[i], 1, 1,
1604                      ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1605             ff_vc1_subblkpat_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 2]];
1606             ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1607             init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1608                      ff_vc1_subblkpat_bits[i], 1, 1,
1609                      ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1610         }
1611         for (i = 0; i < 4; i++) {
1612             ff_vc1_4mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 9]];
1613             ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1614             init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1615                      ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1616                      ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1617             ff_vc1_cbpcy_p_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 10]];
1618             ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1619             init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1620                      ff_vc1_cbpcy_p_bits[i], 1, 1,
1621                      ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1622             ff_vc1_mv_diff_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 11]];
1623             ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1624             init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1625                      ff_vc1_mv_diff_bits[i], 1, 1,
1626                      ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1627         }
1628         for (i = 0; i < 8; i++) {
1629             ff_vc1_ac_coeff_table[i].table           = &vlc_table[vlc_offs[i * 2 + 21]];
1630             ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1631             init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1632                      &vc1_ac_tables[i][0][1], 8, 4,
1633                      &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1634             /* initialize interlaced MVDATA tables (2-Ref) */
1635             ff_vc1_2ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 2 + 22]];
1636             ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1637             init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1638                      ff_vc1_2ref_mvdata_bits[i], 1, 1,
1639                      ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1640         }
1641         for (i = 0; i < 4; i++) {
1642             /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1643             ff_vc1_intfr_4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 37]];
1644             ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1645             init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1646                      ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1647                      ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1648             /* initialize NON-4MV MBMODE VLC tables for the same */
1649             ff_vc1_intfr_non4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 38]];
1650             ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1651             init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1652                      ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1653                      ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1654             /* initialize interlaced MVDATA tables (1-Ref) */
1655             ff_vc1_1ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 39]];
1656             ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1657             init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1658                      ff_vc1_1ref_mvdata_bits[i], 1, 1,
1659                      ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1660         }
1661         for (i = 0; i < 4; i++) {
1662             /* Initialize 2MV Block pattern VLC tables */
1663             ff_vc1_2mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i + 49]];
1664             ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1665             init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1666                      ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1667                      ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1668         }
1669         for (i = 0; i < 8; i++) {
1670             /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1671             ff_vc1_icbpcy_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 53]];
1672             ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1673             init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1674                      ff_vc1_icbpcy_p_bits[i], 1, 1,
1675                      ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1676             /* Initialize interlaced field picture MBMODE VLC tables */
1677             ff_vc1_if_mmv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 54]];
1678             ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1679             init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1680                      ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1681                      ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1682             ff_vc1_if_1mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 55]];
1683             ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1684             init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1685                      ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1686                      ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1687         }
1688         done = 1;
1689     }
1690
1691     /* Other defaults */
1692     v->pq      = -1;
1693     v->mvrange = 0; /* 7.1.1.18, p80 */
1694
1695     return 0;
1696 }