git.sesse.net Git - ffmpeg/blob - libavcodec/vc1.c

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