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