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