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

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