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

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