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