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