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