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