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

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