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