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