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