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