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