libavcodec/vc1.c
Go to the documentation of this file.
00001 /*
00002  * VC-1 and WMV3 decoder common code
00003  * Copyright (c) 2011 Mashiat Sarker Shakkhar
00004  * Copyright (c) 2006-2007 Konstantin Shishkov
00005  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
00006  *
00007  * This file is part of Libav.
00008  *
00009  * Libav is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public
00011  * License as published by the Free Software Foundation; either
00012  * version 2.1 of the License, or (at your option) any later version.
00013  *
00014  * Libav is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017  * Lesser General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU Lesser General Public
00020  * License along with Libav; if not, write to the Free Software
00021  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00022  */
00023 
00030 #include "internal.h"
00031 #include "dsputil.h"
00032 #include "avcodec.h"
00033 #include "mpegvideo.h"
00034 #include "vc1.h"
00035 #include "vc1data.h"
00036 #include "msmpeg4data.h"
00037 #include "unary.h"
00038 #include "simple_idct.h"
00039 
00040 #undef NDEBUG
00041 #include <assert.h>
00042 
00043 /***********************************************************************/
00054 enum Imode {
00055     IMODE_RAW,
00056     IMODE_NORM2,
00057     IMODE_DIFF2,
00058     IMODE_NORM6,
00059     IMODE_DIFF6,
00060     IMODE_ROWSKIP,
00061     IMODE_COLSKIP
00062 }; //imode defines
00064 
00071 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
00072                            GetBitContext *gb)
00073 {
00074     int x, y;
00075 
00076     for (y = 0; y < height; y++) {
00077         if (!get_bits1(gb)) //rowskip
00078             memset(plane, 0, width);
00079         else
00080             for (x = 0; x < width; x++)
00081                 plane[x] = get_bits1(gb);
00082         plane += stride;
00083     }
00084 }
00085 
00093 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
00094                            GetBitContext *gb)
00095 {
00096     int x, y;
00097 
00098     for (x = 0; x < width; x++) {
00099         if (!get_bits1(gb)) //colskip
00100             for (y = 0; y < height; y++)
00101                 plane[y*stride] = 0;
00102         else
00103             for (y = 0; y < height; y++)
00104                 plane[y*stride] = get_bits1(gb);
00105         plane ++;
00106     }
00107 }
00108 
00116 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
00117 {
00118     GetBitContext *gb = &v->s.gb;
00119 
00120     int imode, x, y, code, offset;
00121     uint8_t invert, *planep = data;
00122     int width, height, stride;
00123 
00124     width  = v->s.mb_width;
00125     height = v->s.mb_height >> v->field_mode;
00126     stride = v->s.mb_stride;
00127     invert = get_bits1(gb);
00128     imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
00129 
00130     *raw_flag = 0;
00131     switch (imode) {
00132     case IMODE_RAW:
00133         //Data is actually read in the MB layer (same for all tests == "raw")
00134         *raw_flag = 1; //invert ignored
00135         return invert;
00136     case IMODE_DIFF2:
00137     case IMODE_NORM2:
00138         if ((height * width) & 1) {
00139             *planep++ = get_bits1(gb);
00140             offset    = 1;
00141         }
00142         else
00143             offset = 0;
00144         // decode bitplane as one long line
00145         for (y = offset; y < height * width; y += 2) {
00146             code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
00147             *planep++ = code & 1;
00148             offset++;
00149             if (offset == width) {
00150                 offset  = 0;
00151                 planep += stride - width;
00152             }
00153             *planep++ = code >> 1;
00154             offset++;
00155             if (offset == width) {
00156                 offset  = 0;
00157                 planep += stride - width;
00158             }
00159         }
00160         break;
00161     case IMODE_DIFF6:
00162     case IMODE_NORM6:
00163         if (!(height % 3) && (width % 3)) { // use 2x3 decoding
00164             for (y = 0; y < height; y += 3) {
00165                 for (x = width & 1; x < width; x += 2) {
00166                     code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
00167                     if (code < 0) {
00168                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
00169                         return -1;
00170                     }
00171                     planep[x + 0]              = (code >> 0) & 1;
00172                     planep[x + 1]              = (code >> 1) & 1;
00173                     planep[x + 0 + stride]     = (code >> 2) & 1;
00174                     planep[x + 1 + stride]     = (code >> 3) & 1;
00175                     planep[x + 0 + stride * 2] = (code >> 4) & 1;
00176                     planep[x + 1 + stride * 2] = (code >> 5) & 1;
00177                 }
00178                 planep += stride * 3;
00179             }
00180             if (width & 1)
00181                 decode_colskip(data, 1, height, stride, &v->s.gb);
00182         } else { // 3x2
00183             planep += (height & 1) * stride;
00184             for (y = height & 1; y < height; y += 2) {
00185                 for (x = width % 3; x < width; x += 3) {
00186                     code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
00187                     if (code < 0) {
00188                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
00189                         return -1;
00190                     }
00191                     planep[x + 0]          = (code >> 0) & 1;
00192                     planep[x + 1]          = (code >> 1) & 1;
00193                     planep[x + 2]          = (code >> 2) & 1;
00194                     planep[x + 0 + stride] = (code >> 3) & 1;
00195                     planep[x + 1 + stride] = (code >> 4) & 1;
00196                     planep[x + 2 + stride] = (code >> 5) & 1;
00197                 }
00198                 planep += stride * 2;
00199             }
00200             x = width % 3;
00201             if (x)
00202                 decode_colskip(data,             x, height, stride, &v->s.gb);
00203             if (height & 1)
00204                 decode_rowskip(data + x, width - x,      1, stride, &v->s.gb);
00205         }
00206         break;
00207     case IMODE_ROWSKIP:
00208         decode_rowskip(data, width, height, stride, &v->s.gb);
00209         break;
00210     case IMODE_COLSKIP:
00211         decode_colskip(data, width, height, stride, &v->s.gb);
00212         break;
00213     default:
00214         break;
00215     }
00216 
00217     /* Applying diff operator */
00218     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
00219         planep = data;
00220         planep[0] ^= invert;
00221         for (x = 1; x < width; x++)
00222             planep[x] ^= planep[x-1];
00223         for (y = 1; y < height; y++) {
00224             planep += stride;
00225             planep[0] ^= planep[-stride];
00226             for (x = 1; x < width; x++) {
00227                 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
00228                 else                                 planep[x] ^= planep[x-1];
00229             }
00230         }
00231     } else if (invert) {
00232         planep = data;
00233         for (x = 0; x < stride * height; x++)
00234             planep[x] = !planep[x]; //FIXME stride
00235     }
00236     return (imode << 1) + invert;
00237 }
00238  //Bitplane group
00240 
00241 /***********************************************************************/
00245 static int vop_dquant_decoding(VC1Context *v)
00246 {
00247     GetBitContext *gb = &v->s.gb;
00248     int pqdiff;
00249 
00250     //variable size
00251     if (v->dquant == 2) {
00252         pqdiff = get_bits(gb, 3);
00253         if (pqdiff == 7)
00254             v->altpq = get_bits(gb, 5);
00255         else
00256             v->altpq = v->pq + pqdiff + 1;
00257     } else {
00258         v->dquantfrm = get_bits1(gb);
00259         if (v->dquantfrm) {
00260             v->dqprofile = get_bits(gb, 2);
00261             switch (v->dqprofile) {
00262             case DQPROFILE_SINGLE_EDGE:
00263             case DQPROFILE_DOUBLE_EDGES:
00264                 v->dqsbedge = get_bits(gb, 2);
00265                 break;
00266             case DQPROFILE_ALL_MBS:
00267                 v->dqbilevel = get_bits1(gb);
00268                 if (!v->dqbilevel)
00269                     v->halfpq = 0;
00270             default:
00271                 break; //Forbidden ?
00272             }
00273             if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
00274                 pqdiff = get_bits(gb, 3);
00275                 if (pqdiff == 7)
00276                     v->altpq = get_bits(gb, 5);
00277                 else
00278                     v->altpq = v->pq + pqdiff + 1;
00279             }
00280         }
00281     }
00282     return 0;
00283 }
00284 
00285 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
00286 
00294 int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
00295 {
00296     av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
00297     v->profile = get_bits(gb, 2);
00298     if (v->profile == PROFILE_COMPLEX) {
00299         av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
00300     }
00301 
00302     if (v->profile == PROFILE_ADVANCED) {
00303         v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
00304         v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
00305         return decode_sequence_header_adv(v, gb);
00306     } else {
00307         v->zz_8x4 = wmv2_scantableA;
00308         v->zz_4x8 = wmv2_scantableB;
00309         v->res_y411   = get_bits1(gb);
00310         v->res_sprite = get_bits1(gb);
00311         if (v->res_y411) {
00312             av_log(avctx, AV_LOG_ERROR,
00313                    "Old interlaced mode is not supported\n");
00314             return -1;
00315         }
00316     }
00317 
00318     // (fps-2)/4 (->30)
00319     v->frmrtq_postproc = get_bits(gb, 3); //common
00320     // (bitrate-32kbps)/64kbps
00321     v->bitrtq_postproc = get_bits(gb, 5); //common
00322     v->s.loop_filter   = get_bits1(gb); //common
00323     if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
00324         av_log(avctx, AV_LOG_ERROR,
00325                "LOOPFILTER shall not be enabled in Simple Profile\n");
00326     }
00327     if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
00328         v->s.loop_filter = 0;
00329 
00330     v->res_x8          = get_bits1(gb); //reserved
00331     v->multires        = get_bits1(gb);
00332     v->res_fasttx      = get_bits1(gb);
00333     if (!v->res_fasttx) {
00334         v->vc1dsp.vc1_inv_trans_8x8    = ff_simple_idct_8;
00335         v->vc1dsp.vc1_inv_trans_8x4    = ff_simple_idct84_add;
00336         v->vc1dsp.vc1_inv_trans_4x8    = ff_simple_idct48_add;
00337         v->vc1dsp.vc1_inv_trans_4x4    = ff_simple_idct44_add;
00338         v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
00339         v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
00340         v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
00341         v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
00342     }
00343 
00344     v->fastuvmc        = get_bits1(gb); //common
00345     if (!v->profile && !v->fastuvmc) {
00346         av_log(avctx, AV_LOG_ERROR,
00347                "FASTUVMC unavailable in Simple Profile\n");
00348         return -1;
00349     }
00350     v->extended_mv     = get_bits1(gb); //common
00351     if (!v->profile && v->extended_mv)
00352     {
00353         av_log(avctx, AV_LOG_ERROR,
00354                "Extended MVs unavailable in Simple Profile\n");
00355         return -1;
00356     }
00357     v->dquant          = get_bits(gb, 2); //common
00358     v->vstransform     = get_bits1(gb); //common
00359 
00360     v->res_transtab    = get_bits1(gb);
00361     if (v->res_transtab)
00362     {
00363         av_log(avctx, AV_LOG_ERROR,
00364                "1 for reserved RES_TRANSTAB is forbidden\n");
00365         return -1;
00366     }
00367 
00368     v->overlap         = get_bits1(gb); //common
00369 
00370     v->s.resync_marker = get_bits1(gb);
00371     v->rangered        = get_bits1(gb);
00372     if (v->rangered && v->profile == PROFILE_SIMPLE) {
00373         av_log(avctx, AV_LOG_INFO,
00374                "RANGERED should be set to 0 in Simple Profile\n");
00375     }
00376 
00377     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
00378     v->quantizer_mode = get_bits(gb, 2); //common
00379 
00380     v->finterpflag = get_bits1(gb); //common
00381 
00382     if (v->res_sprite) {
00383         v->s.avctx->width  = v->s.avctx->coded_width  = get_bits(gb, 11);
00384         v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11);
00385         skip_bits(gb, 5); //frame rate
00386         v->res_x8 = get_bits1(gb);
00387         if (get_bits1(gb)) { // something to do with DC VLC selection
00388             av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
00389             return -1;
00390         }
00391         skip_bits(gb, 3); //slice code
00392         v->res_rtm_flag = 0;
00393     } else {
00394         v->res_rtm_flag = get_bits1(gb); //reserved
00395     }
00396     if (!v->res_rtm_flag) {
00397 //            av_log(avctx, AV_LOG_ERROR,
00398 //                   "0 for reserved RES_RTM_FLAG is forbidden\n");
00399         av_log(avctx, AV_LOG_ERROR,
00400                "Old WMV3 version detected, some frames may be decoded incorrectly\n");
00401         //return -1;
00402     }
00403     //TODO: figure out what they mean (always 0x402F)
00404     if (!v->res_fasttx)
00405         skip_bits(gb, 16);
00406     av_log(avctx, AV_LOG_DEBUG,
00407            "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
00408            "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
00409            "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
00410            "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
00411            v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
00412            v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
00413            v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
00414            v->dquant, v->quantizer_mode, avctx->max_b_frames);
00415     return 0;
00416 }
00417 
00418 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
00419 {
00420     v->res_rtm_flag = 1;
00421     v->level = get_bits(gb, 3);
00422     if (v->level >= 5) {
00423         av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
00424     }
00425     v->chromaformat = get_bits(gb, 2);
00426     if (v->chromaformat != 1) {
00427         av_log(v->s.avctx, AV_LOG_ERROR,
00428                "Only 4:2:0 chroma format supported\n");
00429         return -1;
00430     }
00431 
00432     // (fps-2)/4 (->30)
00433     v->frmrtq_postproc       = get_bits(gb, 3); //common
00434     // (bitrate-32kbps)/64kbps
00435     v->bitrtq_postproc       = get_bits(gb, 5); //common
00436     v->postprocflag          = get_bits1(gb);   //common
00437 
00438     v->s.avctx->coded_width  = (get_bits(gb, 12) + 1) << 1;
00439     v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
00440     v->s.avctx->width        = v->s.avctx->coded_width;
00441     v->s.avctx->height       = v->s.avctx->coded_height;
00442     v->broadcast             = get_bits1(gb);
00443     v->interlace             = get_bits1(gb);
00444     v->tfcntrflag            = get_bits1(gb);
00445     v->finterpflag           = get_bits1(gb);
00446     skip_bits1(gb); // reserved
00447 
00448     av_log(v->s.avctx, AV_LOG_DEBUG,
00449            "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
00450            "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
00451            "TFCTRflag=%i, FINTERPflag=%i\n",
00452            v->level, v->frmrtq_postproc, v->bitrtq_postproc,
00453            v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
00454            v->tfcntrflag, v->finterpflag);
00455 
00456     v->psf = get_bits1(gb);
00457     if (v->psf) { //PsF, 6.1.13
00458         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
00459         return -1;
00460     }
00461     v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
00462     if (get_bits1(gb)) { //Display Info - decoding is not affected by it
00463         int w, h, ar = 0;
00464         av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
00465         w = get_bits(gb, 14) + 1;
00466         h = get_bits(gb, 14) + 1;
00467         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
00468         if (get_bits1(gb))
00469             ar = get_bits(gb, 4);
00470         if (ar && ar < 14) {
00471             v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
00472         } else if (ar == 15) {
00473             w = get_bits(gb, 8) + 1;
00474             h = get_bits(gb, 8) + 1;
00475             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
00476         } else {
00477             av_reduce(&v->s.avctx->sample_aspect_ratio.num,
00478                       &v->s.avctx->sample_aspect_ratio.den,
00479                       v->s.avctx->height * w,
00480                       v->s.avctx->width * h,
00481                       1 << 30);
00482         }
00483         av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
00484                v->s.avctx->sample_aspect_ratio.num,
00485                v->s.avctx->sample_aspect_ratio.den);
00486 
00487         if (get_bits1(gb)) { //framerate stuff
00488             if (get_bits1(gb)) {
00489                 v->s.avctx->time_base.num = 32;
00490                 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
00491             } else {
00492                 int nr, dr;
00493                 nr = get_bits(gb, 8);
00494                 dr = get_bits(gb, 4);
00495                 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
00496                     v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
00497                     v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
00498                 }
00499             }
00500             if (v->broadcast) { // Pulldown may be present
00501                 v->s.avctx->time_base.den  *= 2;
00502                 v->s.avctx->ticks_per_frame = 2;
00503             }
00504         }
00505 
00506         if (get_bits1(gb)) {
00507             v->color_prim    = get_bits(gb, 8);
00508             v->transfer_char = get_bits(gb, 8);
00509             v->matrix_coef   = get_bits(gb, 8);
00510         }
00511     }
00512 
00513     v->hrd_param_flag = get_bits1(gb);
00514     if (v->hrd_param_flag) {
00515         int i;
00516         v->hrd_num_leaky_buckets = get_bits(gb, 5);
00517         skip_bits(gb, 4); //bitrate exponent
00518         skip_bits(gb, 4); //buffer size exponent
00519         for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
00520             skip_bits(gb, 16); //hrd_rate[n]
00521             skip_bits(gb, 16); //hrd_buffer[n]
00522         }
00523     }
00524     return 0;
00525 }
00526 
00527 int vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
00528 {
00529     int i;
00530 
00531     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
00532     v->broken_link    = get_bits1(gb);
00533     v->closed_entry   = get_bits1(gb);
00534     v->panscanflag    = get_bits1(gb);
00535     v->refdist_flag   = get_bits1(gb);
00536     v->s.loop_filter  = get_bits1(gb);
00537     v->fastuvmc       = get_bits1(gb);
00538     v->extended_mv    = get_bits1(gb);
00539     v->dquant         = get_bits(gb, 2);
00540     v->vstransform    = get_bits1(gb);
00541     v->overlap        = get_bits1(gb);
00542     v->quantizer_mode = get_bits(gb, 2);
00543 
00544     if (v->hrd_param_flag) {
00545         for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
00546             skip_bits(gb, 8); //hrd_full[n]
00547         }
00548     }
00549 
00550     if (get_bits1(gb)) {
00551         avctx->width  = avctx->coded_width  = (get_bits(gb, 12) + 1) << 1;
00552         avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
00553     }
00554     if (v->extended_mv)
00555         v->extended_dmv = get_bits1(gb);
00556     if ((v->range_mapy_flag = get_bits1(gb))) {
00557         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
00558         v->range_mapy = get_bits(gb, 3);
00559     }
00560     if ((v->range_mapuv_flag = get_bits1(gb))) {
00561         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
00562         v->range_mapuv = get_bits(gb, 3);
00563     }
00564 
00565     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
00566            "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
00567            "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
00568            "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
00569            v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
00570            v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
00571 
00572     return 0;
00573 }
00574 
00575 int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
00576 {
00577     int pqindex, lowquant, status;
00578 
00579     if (v->finterpflag)
00580         v->interpfrm = get_bits1(gb);
00581     skip_bits(gb, 2); //framecnt unused
00582     v->rangeredfrm = 0;
00583     if (v->rangered)
00584         v->rangeredfrm = get_bits1(gb);
00585     v->s.pict_type = get_bits1(gb);
00586     if (v->s.avctx->max_b_frames) {
00587         if (!v->s.pict_type) {
00588             if (get_bits1(gb))
00589                 v->s.pict_type = AV_PICTURE_TYPE_I;
00590             else
00591                 v->s.pict_type = AV_PICTURE_TYPE_B;
00592         } else
00593             v->s.pict_type = AV_PICTURE_TYPE_P;
00594     } else
00595         v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00596 
00597     v->bi_type = 0;
00598     if (v->s.pict_type == AV_PICTURE_TYPE_B) {
00599         v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00600         v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00601         if (v->bfraction == 0) {
00602             v->s.pict_type = AV_PICTURE_TYPE_BI;
00603         }
00604     }
00605     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
00606         skip_bits(gb, 7); // skip buffer fullness
00607 
00608     if (v->parse_only)
00609         return 0;
00610 
00611     /* calculate RND */
00612     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
00613         v->rnd = 1;
00614     if (v->s.pict_type == AV_PICTURE_TYPE_P)
00615         v->rnd ^= 1;
00616 
00617     /* Quantizer stuff */
00618     pqindex = get_bits(gb, 5);
00619     if (!pqindex)
00620         return -1;
00621     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00622         v->pq = ff_vc1_pquant_table[0][pqindex];
00623     else
00624         v->pq = ff_vc1_pquant_table[1][pqindex];
00625 
00626     v->pquantizer = 1;
00627     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00628         v->pquantizer = pqindex < 9;
00629     if (v->quantizer_mode == QUANT_NON_UNIFORM)
00630         v->pquantizer = 0;
00631     v->pqindex = pqindex;
00632     if (pqindex < 9)
00633         v->halfpq = get_bits1(gb);
00634     else
00635         v->halfpq = 0;
00636     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00637         v->pquantizer = get_bits1(gb);
00638     v->dquantfrm = 0;
00639     if (v->extended_mv == 1)
00640         v->mvrange = get_unary(gb, 0, 3);
00641     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
00642     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
00643     v->range_x = 1 << (v->k_x - 1);
00644     v->range_y = 1 << (v->k_y - 1);
00645     if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
00646         v->respic = get_bits(gb, 2);
00647 
00648     if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
00649         v->x8_type = get_bits1(gb);
00650     } else
00651         v->x8_type = 0;
00652 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
00653 //        (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
00654 
00655     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
00656         v->use_ic = 0;
00657 
00658     switch (v->s.pict_type) {
00659     case AV_PICTURE_TYPE_P:
00660         if (v->pq < 5)       v->tt_index = 0;
00661         else if (v->pq < 13) v->tt_index = 1;
00662         else                 v->tt_index = 2;
00663 
00664         lowquant = (v->pq > 12) ? 0 : 1;
00665         v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
00666         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00667             int scale, shift, i;
00668             v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
00669             v->lumscale = get_bits(gb, 6);
00670             v->lumshift = get_bits(gb, 6);
00671             v->use_ic   = 1;
00672             /* fill lookup tables for intensity compensation */
00673             if (!v->lumscale) {
00674                 scale = -64;
00675                 shift = (255 - v->lumshift * 2) << 6;
00676                 if (v->lumshift > 31)
00677                     shift += 128 << 6;
00678             } else {
00679                 scale = v->lumscale + 32;
00680                 if (v->lumshift > 31)
00681                     shift = (v->lumshift - 64) << 6;
00682                 else
00683                     shift = v->lumshift << 6;
00684             }
00685             for (i = 0; i < 256; i++) {
00686                 v->luty[i]  = av_clip_uint8((scale * i + shift + 32) >> 6);
00687                 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
00688             }
00689         }
00690         v->qs_last = v->s.quarter_sample;
00691         if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
00692             v->s.quarter_sample = 0;
00693         else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00694             if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
00695                 v->s.quarter_sample = 0;
00696             else
00697                 v->s.quarter_sample = 1;
00698         } else
00699             v->s.quarter_sample = 1;
00700         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));
00701 
00702         if ((v->mv_mode  == MV_PMODE_INTENSITY_COMP &&
00703              v->mv_mode2 == MV_PMODE_MIXED_MV)      ||
00704             v->mv_mode   == MV_PMODE_MIXED_MV) {
00705             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
00706             if (status < 0)
00707                 return -1;
00708             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
00709                    "Imode: %i, Invert: %i\n", status>>1, status&1);
00710         } else {
00711             v->mv_type_is_raw = 0;
00712             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
00713         }
00714         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00715         if (status < 0)
00716             return -1;
00717         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00718                "Imode: %i, Invert: %i\n", status>>1, status&1);
00719 
00720         /* Hopefully this is correct for P frames */
00721         v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
00722         v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00723 
00724         if (v->dquant) {
00725             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00726             vop_dquant_decoding(v);
00727         }
00728 
00729         v->ttfrm = 0; //FIXME Is that so ?
00730         if (v->vstransform) {
00731             v->ttmbf = get_bits1(gb);
00732             if (v->ttmbf) {
00733                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
00734             }
00735         } else {
00736             v->ttmbf = 1;
00737             v->ttfrm = TT_8X8;
00738         }
00739         break;
00740     case AV_PICTURE_TYPE_B:
00741         if (v->pq < 5)       v->tt_index = 0;
00742         else if (v->pq < 13) v->tt_index = 1;
00743         else                 v->tt_index = 2;
00744 
00745         v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
00746         v->qs_last          = v->s.quarter_sample;
00747         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
00748         v->s.mspel          = v->s.quarter_sample;
00749 
00750         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
00751         if (status < 0)
00752             return -1;
00753         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
00754                "Imode: %i, Invert: %i\n", status>>1, status&1);
00755         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00756         if (status < 0)
00757             return -1;
00758         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00759                "Imode: %i, Invert: %i\n", status>>1, status&1);
00760 
00761         v->s.mv_table_index = get_bits(gb, 2);
00762         v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00763 
00764         if (v->dquant) {
00765             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00766             vop_dquant_decoding(v);
00767         }
00768 
00769         v->ttfrm = 0;
00770         if (v->vstransform) {
00771             v->ttmbf = get_bits1(gb);
00772             if (v->ttmbf) {
00773                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
00774             }
00775         } else {
00776             v->ttmbf = 1;
00777             v->ttfrm = TT_8X8;
00778         }
00779         break;
00780     }
00781 
00782     if (!v->x8_type) {
00783         /* AC Syntax */
00784         v->c_ac_table_index = decode012(gb);
00785         if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
00786             v->y_ac_table_index = decode012(gb);
00787         }
00788         /* DC Syntax */
00789         v->s.dc_table_index = get_bits1(gb);
00790     }
00791 
00792     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
00793         v->s.pict_type = AV_PICTURE_TYPE_B;
00794         v->bi_type     = 1;
00795     }
00796     return 0;
00797 }
00798 
00799 /* fill lookup tables for intensity compensation */
00800 #define INIT_LUT(lumscale, lumshift, luty, lutuv)   \
00801     if (!lumscale) {                                \
00802         scale = -64;                                \
00803         shift = (255 - lumshift * 2) << 6;          \
00804         if (lumshift > 31)                          \
00805             shift += 128 << 6;                      \
00806     } else {                                        \
00807         scale = lumscale + 32;                      \
00808         if (lumshift > 31)                          \
00809             shift = (lumshift - 64) << 6;           \
00810         else                                        \
00811             shift = lumshift << 6;                  \
00812     }                                               \
00813     for (i = 0; i < 256; i++) {                     \
00814         luty[i]  = av_clip_uint8((scale * i + shift + 32) >> 6);           \
00815         lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);  \
00816     }
00817 
00818 int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
00819 {
00820     int pqindex, lowquant;
00821     int status;
00822     int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
00823     int scale, shift, i; /* for initializing LUT for intensity compensation */
00824 
00825     v->p_frame_skipped = 0;
00826     if (v->second_field) {
00827         v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00828         if (v->fptype & 4)
00829             v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00830         v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
00831         if (!v->pic_header_flag)
00832             goto parse_common_info;
00833     }
00834 
00835     v->field_mode = 0;
00836     if (v->interlace) {
00837         v->fcm = decode012(gb);
00838         if (v->fcm) {
00839             if (v->fcm == ILACE_FIELD)
00840                 v->field_mode = 1;
00841             if (!v->warn_interlaced++)
00842                 av_log(v->s.avctx, AV_LOG_ERROR,
00843                        "Interlaced frames/fields support is incomplete\n");
00844         }
00845     } else {
00846         v->fcm = PROGRESSIVE;
00847     }
00848 
00849     if (v->field_mode) {
00850         v->fptype = get_bits(gb, 3);
00851         v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00852         if (v->fptype & 4) // B-picture
00853             v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00854     } else {
00855         switch (get_unary(gb, 0, 4)) {
00856         case 0:
00857             v->s.pict_type = AV_PICTURE_TYPE_P;
00858             break;
00859         case 1:
00860             v->s.pict_type = AV_PICTURE_TYPE_B;
00861             break;
00862         case 2:
00863             v->s.pict_type = AV_PICTURE_TYPE_I;
00864             break;
00865         case 3:
00866             v->s.pict_type = AV_PICTURE_TYPE_BI;
00867             break;
00868         case 4:
00869             v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
00870             v->p_frame_skipped = 1;
00871             break;
00872         }
00873     }
00874     if (v->tfcntrflag)
00875         skip_bits(gb, 8);
00876     if (v->broadcast) {
00877         if (!v->interlace || v->psf) {
00878             v->rptfrm = get_bits(gb, 2);
00879         } else {
00880             v->tff = get_bits1(gb);
00881             v->rff = get_bits1(gb);
00882         }
00883     }
00884     if (v->panscanflag) {
00885         av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
00886         //...
00887     }
00888     if (v->p_frame_skipped) {
00889         return 0;
00890     }
00891     v->rnd = get_bits1(gb);
00892     if (v->interlace)
00893         v->uvsamp = get_bits1(gb);
00894     if (v->field_mode) {
00895         if (!v->refdist_flag)
00896             v->refdist = 0;
00897         else {
00898             if ((v->s.pict_type != AV_PICTURE_TYPE_B)
00899                 && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
00900                 v->refdist = get_bits(gb, 2);
00901                 if (v->refdist == 3)
00902                     v->refdist += get_unary(gb, 0, 16);
00903             } else {
00904                 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00905                 v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00906                 v->frfd = (v->bfraction * v->refdist) >> 8;
00907                 v->brfd = v->refdist - v->frfd - 1;
00908                 if (v->brfd < 0)
00909                     v->brfd = 0;
00910             }
00911         }
00912         goto parse_common_info;
00913     }
00914     if (v->finterpflag)
00915         v->interpfrm = get_bits1(gb);
00916     if (v->s.pict_type == AV_PICTURE_TYPE_B) {
00917         v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00918         v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00919         if (v->bfraction == 0) {
00920             v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
00921         }
00922     }
00923 
00924     parse_common_info:
00925     if (v->field_mode)
00926         v->cur_field_type = !(v->tff ^ v->second_field);
00927     pqindex = get_bits(gb, 5);
00928     if (!pqindex)
00929         return -1;
00930     v->pqindex = pqindex;
00931     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00932         v->pq = ff_vc1_pquant_table[0][pqindex];
00933     else
00934         v->pq = ff_vc1_pquant_table[1][pqindex];
00935 
00936     v->pquantizer = 1;
00937     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00938         v->pquantizer = pqindex < 9;
00939     if (v->quantizer_mode == QUANT_NON_UNIFORM)
00940         v->pquantizer = 0;
00941     v->pqindex = pqindex;
00942     if (pqindex < 9)
00943         v->halfpq = get_bits1(gb);
00944     else
00945         v->halfpq = 0;
00946     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00947         v->pquantizer = get_bits1(gb);
00948     if (v->postprocflag)
00949         v->postproc = get_bits(gb, 2);
00950 
00951     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
00952         v->use_ic = 0;
00953 
00954     if (v->parse_only)
00955         return 0;
00956 
00957     switch (v->s.pict_type) {
00958     case AV_PICTURE_TYPE_I:
00959     case AV_PICTURE_TYPE_BI:
00960         if (v->fcm == ILACE_FRAME) { //interlace frame picture
00961             status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
00962             if (status < 0)
00963                 return -1;
00964             av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
00965                    "Imode: %i, Invert: %i\n", status>>1, status&1);
00966         }
00967         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
00968         if (status < 0)
00969             return -1;
00970         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
00971                "Imode: %i, Invert: %i\n", status>>1, status&1);
00972         v->condover = CONDOVER_NONE;
00973         if (v->overlap && v->pq <= 8) {
00974             v->condover = decode012(gb);
00975             if (v->condover == CONDOVER_SELECT) {
00976                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
00977                 if (status < 0)
00978                     return -1;
00979                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
00980                        "Imode: %i, Invert: %i\n", status>>1, status&1);
00981             }
00982         }
00983         break;
00984     case AV_PICTURE_TYPE_P:
00985         if (v->field_mode) {
00986             v->numref = get_bits1(gb);
00987             if (!v->numref) {
00988                 v->reffield          = get_bits1(gb);
00989                 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
00990             }
00991         }
00992         if (v->extended_mv)
00993             v->mvrange = get_unary(gb, 0, 3);
00994         else
00995             v->mvrange = 0;
00996         if (v->interlace) {
00997             if (v->extended_dmv)
00998                 v->dmvrange = get_unary(gb, 0, 3);
00999             else
01000                 v->dmvrange = 0;
01001             if (v->fcm == ILACE_FRAME) { // interlaced frame picture
01002                 v->fourmvswitch = get_bits1(gb);
01003                 v->intcomp      = get_bits1(gb);
01004                 if (v->intcomp) {
01005                     v->lumscale = get_bits(gb, 6);
01006                     v->lumshift = get_bits(gb, 6);
01007                     INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01008                 }
01009                 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01010                 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
01011                        "Imode: %i, Invert: %i\n", status>>1, status&1);
01012                 mbmodetab = get_bits(gb, 2);
01013                 if (v->fourmvswitch)
01014                     v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
01015                 else
01016                     v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
01017                 imvtab         = get_bits(gb, 2);
01018                 v->imv_vlc     = &ff_vc1_1ref_mvdata_vlc[imvtab];
01019                 // interlaced p-picture cbpcy range is [1, 63]
01020                 icbptab        = get_bits(gb, 3);
01021                 v->cbpcy_vlc   = &ff_vc1_icbpcy_vlc[icbptab];
01022                 twomvbptab     = get_bits(gb, 2);
01023                 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
01024                 if (v->fourmvswitch) {
01025                     fourmvbptab     = get_bits(gb, 2);
01026                     v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01027                 }
01028             }
01029         }
01030         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
01031         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
01032         v->range_x = 1 << (v->k_x - 1);
01033         v->range_y = 1 << (v->k_y - 1);
01034 
01035         if (v->pq < 5)
01036             v->tt_index = 0;
01037         else if (v->pq < 13)
01038             v->tt_index = 1;
01039         else
01040             v->tt_index = 2;
01041         if (v->fcm != ILACE_FRAME) {
01042             int mvmode;
01043             mvmode     = get_unary(gb, 1, 4);
01044             lowquant   = (v->pq > 12) ? 0 : 1;
01045             v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
01046             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01047                 int mvmode2;
01048                 mvmode2 = get_unary(gb, 1, 3);
01049                 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
01050                 if (v->field_mode)
01051                     v->intcompfield = decode210(gb);
01052                 v->lumscale = get_bits(gb, 6);
01053                 v->lumshift = get_bits(gb, 6);
01054                 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01055                 if ((v->field_mode) && !v->intcompfield) {
01056                     v->lumscale2 = get_bits(gb, 6);
01057                     v->lumshift2 = get_bits(gb, 6);
01058                     INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
01059                 }
01060                 v->use_ic = 1;
01061             }
01062             v->qs_last = v->s.quarter_sample;
01063             if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
01064                 v->s.quarter_sample = 0;
01065             else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01066                 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
01067                     v->s.quarter_sample = 0;
01068                 else
01069                     v->s.quarter_sample = 1;
01070             } else
01071                 v->s.quarter_sample = 1;
01072             v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
01073                            || (v->mv_mode == MV_PMODE_INTENSITY_COMP
01074                                && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
01075         }
01076         if (v->fcm == PROGRESSIVE) { // progressive
01077             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01078                  v->mv_mode2 == MV_PMODE_MIXED_MV)
01079                 || v->mv_mode == MV_PMODE_MIXED_MV) {
01080                 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
01081                 if (status < 0)
01082                     return -1;
01083                 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
01084                        "Imode: %i, Invert: %i\n", status>>1, status&1);
01085             } else {
01086                 v->mv_type_is_raw = 0;
01087                 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
01088             }
01089             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01090             if (status < 0)
01091                 return -1;
01092             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01093                    "Imode: %i, Invert: %i\n", status>>1, status&1);
01094 
01095             /* Hopefully this is correct for P frames */
01096             v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
01097             v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01098         } else if (v->fcm == ILACE_FRAME) { // frame interlaced
01099             v->qs_last          = v->s.quarter_sample;
01100             v->s.quarter_sample = 1;
01101             v->s.mspel          = 1;
01102         } else {    // field interlaced
01103             mbmodetab = get_bits(gb, 3);
01104             imvtab = get_bits(gb, 2 + v->numref);
01105             if (!v->numref)
01106                 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
01107             else
01108                 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
01109             icbptab = get_bits(gb, 3);
01110             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01111             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01112                 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
01113                 fourmvbptab     = get_bits(gb, 2);
01114                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01115                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01116             } else {
01117                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01118             }
01119         }
01120         if (v->dquant) {
01121             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01122             vop_dquant_decoding(v);
01123         }
01124 
01125         v->ttfrm = 0; //FIXME Is that so ?
01126         if (v->vstransform) {
01127             v->ttmbf = get_bits1(gb);
01128             if (v->ttmbf) {
01129                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01130             }
01131         } else {
01132             v->ttmbf = 1;
01133             v->ttfrm = TT_8X8;
01134         }
01135         break;
01136     case AV_PICTURE_TYPE_B:
01137         // TODO: implement interlaced frame B picture decoding
01138         if (v->fcm == ILACE_FRAME)
01139             return -1;
01140         if (v->extended_mv)
01141             v->mvrange = get_unary(gb, 0, 3);
01142         else
01143             v->mvrange = 0;
01144         v->k_x     = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
01145         v->k_y     = v->mvrange + 8; //k_y can be 8 9 10 11
01146         v->range_x = 1 << (v->k_x - 1);
01147         v->range_y = 1 << (v->k_y - 1);
01148 
01149         if (v->pq < 5)
01150             v->tt_index = 0;
01151         else if (v->pq < 13)
01152             v->tt_index = 1;
01153         else
01154             v->tt_index = 2;
01155 
01156         if (v->field_mode) {
01157             int mvmode;
01158             if (v->extended_dmv)
01159                 v->dmvrange = get_unary(gb, 0, 3);
01160             mvmode = get_unary(gb, 1, 3);
01161             lowquant = (v->pq > 12) ? 0 : 1;
01162             v->mv_mode          = ff_vc1_mv_pmode_table2[lowquant][mvmode];
01163             v->qs_last          = v->s.quarter_sample;
01164             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
01165             v->s.mspel          = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
01166             status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
01167             if (status < 0)
01168                 return -1;
01169             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
01170                    "Imode: %i, Invert: %i\n", status>>1, status&1);
01171             mbmodetab = get_bits(gb, 3);
01172             if (v->mv_mode == MV_PMODE_MIXED_MV)
01173                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01174             else
01175                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01176             imvtab       = get_bits(gb, 3);
01177             v->imv_vlc   = &ff_vc1_2ref_mvdata_vlc[imvtab];
01178             icbptab      = get_bits(gb, 3);
01179             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01180             if (v->mv_mode == MV_PMODE_MIXED_MV) {
01181                 fourmvbptab     = get_bits(gb, 2);
01182                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01183             }
01184             v->numref = 1; // interlaced field B pictures are always 2-ref
01185         } else {
01186             v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
01187             v->qs_last          = v->s.quarter_sample;
01188             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
01189             v->s.mspel          = v->s.quarter_sample;
01190             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
01191             if (status < 0)
01192                 return -1;
01193             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
01194                    "Imode: %i, Invert: %i\n", status>>1, status&1);
01195             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01196             if (status < 0)
01197                 return -1;
01198             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01199                    "Imode: %i, Invert: %i\n", status>>1, status&1);
01200             v->s.mv_table_index = get_bits(gb, 2);
01201             v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01202         }
01203 
01204         if (v->dquant) {
01205             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01206             vop_dquant_decoding(v);
01207         }
01208 
01209         v->ttfrm = 0;
01210         if (v->vstransform) {
01211             v->ttmbf = get_bits1(gb);
01212             if (v->ttmbf) {
01213                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01214             }
01215         } else {
01216             v->ttmbf = 1;
01217             v->ttfrm = TT_8X8;
01218         }
01219         break;
01220     }
01221 
01222     /* AC Syntax */
01223     v->c_ac_table_index = decode012(gb);
01224     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
01225         v->y_ac_table_index = decode012(gb);
01226     }
01227     /* DC Syntax */
01228     v->s.dc_table_index = get_bits1(gb);
01229     if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
01230         && v->dquant) {
01231         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01232         vop_dquant_decoding(v);
01233     }
01234 
01235     v->bi_type = 0;
01236     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
01237         v->s.pict_type = AV_PICTURE_TYPE_B;
01238         v->bi_type = 1;
01239     }
01240     return 0;
01241 }
01242 
01243 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
01244 {
01245 { 0x0001,  2}, { 0x0005,  3}, { 0x000D,  4}, { 0x0012,  5}, { 0x000E,  6}, { 0x0015,  7},
01246 { 0x0013,  8}, { 0x003F,  8}, { 0x004B,  9}, { 0x011F,  9}, { 0x00B8, 10}, { 0x03E3, 10},
01247 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
01248 { 0x3EAE, 14}, { 0x0000,  4}, { 0x0010,  5}, { 0x0008,  7}, { 0x0020,  8}, { 0x0029,  9},
01249 { 0x01F4,  9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
01250 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003,  5}, { 0x0011,  7},
01251 { 0x00C4,  8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
01252 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013,  5}, { 0x0078,  7},
01253 { 0x0069,  9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
01254 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C,  6}, { 0x0024,  9}, { 0x0094, 11},
01255 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D,  6}, { 0x0053,  9}, { 0x01A0, 11},
01256 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013,  7}, { 0x007C,  9}, { 0x07C1, 11}, { 0x04AC, 14},
01257 { 0x001B,  7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079,  7}, { 0x03E1, 10},
01258 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021,  8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
01259 { 0x0035,  8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5,  8}, { 0x0174, 11}, { 0x0785, 13},
01260 { 0x0048,  9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C,  9}, { 0x00FA, 10}, { 0x07D6, 11},
01261 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
01262 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
01263 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
01264 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E,  4},
01265 { 0x0045,  7}, { 0x01F3,  9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019,  5},
01266 { 0x0028,  9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030,  6}, { 0x00A2, 10},
01267 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F,  6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
01268 { 0x0044,  7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063,  7}, { 0x03C3, 12}, { 0x0015,  8},
01269 { 0x08F6, 12}, { 0x0017,  8}, { 0x0498, 13}, { 0x002C,  8}, { 0x07B2, 13}, { 0x002F,  8},
01270 { 0x1F54, 13}, { 0x008D,  8}, { 0x07BD, 13}, { 0x008E,  8}, { 0x1182, 13}, { 0x00FB,  8},
01271 { 0x050B, 13}, { 0x002D,  8}, { 0x07C0, 11}, { 0x0079,  9}, { 0x1F5F, 13}, { 0x007A,  9},
01272 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
01273 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
01274 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
01275 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A,  9}
01276 },
01277 {
01278 { 0x0000,  3}, { 0x0003,  4}, { 0x000B,  5}, { 0x0014,  6}, { 0x003F,  6}, { 0x005D,  7},
01279 { 0x00A2,  8}, { 0x00AC,  9}, { 0x016E,  9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
01280 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
01281 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004,  4},
01282 { 0x001E,  5}, { 0x0042,  7}, { 0x00B6,  8}, { 0x0173,  9}, { 0x0395, 10}, { 0x072E, 11},
01283 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005,  5}, { 0x0040,  7},
01284 { 0x0049,  9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
01285 { 0x0018,  5}, { 0x0025,  8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
01286 { 0x139C, 15}, { 0x0029,  6}, { 0x004F,  9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
01287 { 0x0038,  6}, { 0x010E,  9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058,  7},
01288 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023,  8}, { 0x02E3, 10}, { 0x04E5, 13},
01289 { 0x2E40, 14}, { 0x00A1,  8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083,  8}, { 0x013A, 11},
01290 { 0x1721, 13}, { 0x0044,  9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
01291 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
01292 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
01293 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
01294 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003,  3}, { 0x002A,  6}, { 0x00E4,  8},
01295 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
01296 { 0x0009,  4}, { 0x0054,  8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D,  4},
01297 { 0x00AD,  9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011,  5}, { 0x016B,  9}, { 0x0B7F, 12},
01298 { 0x51A4, 15}, { 0x0019,  5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D,  5}, { 0x0394, 10},
01299 { 0x28D3, 14}, { 0x002B,  6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F,  6}, { 0x0247, 12},
01300 { 0x0010,  7}, { 0x0A35, 12}, { 0x003E,  6}, { 0x0B7A, 12}, { 0x0059,  7}, { 0x105E, 13},
01301 { 0x0026,  8}, { 0x09CF, 14}, { 0x0055,  8}, { 0x1CB5, 13}, { 0x0057,  8}, { 0x0E5B, 12},
01302 { 0x00A0,  8}, { 0x1468, 13}, { 0x0170,  9}, { 0x0090, 10}, { 0x01CE,  9}, { 0x021A, 10},
01303 { 0x0218, 10}, { 0x0168,  9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
01304 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
01305 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
01306 { 0x0169,  9}
01307 },
01308 {
01309 { 0x0001,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x0016,  5}, { 0x0020,  6}, { 0x0018,  7},
01310 { 0x0008,  8}, { 0x009A,  8}, { 0x0056,  9}, { 0x013E,  9}, { 0x00F0, 10}, { 0x03A5, 10},
01311 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001,  4}, { 0x0011,  5},
01312 { 0x0002,  7}, { 0x000B,  8}, { 0x0012,  9}, { 0x01D6,  9}, { 0x027E, 10}, { 0x0191, 11},
01313 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004,  5}, { 0x0014,  7}, { 0x009E,  8},
01314 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017,  5},
01315 { 0x004E,  7}, { 0x005E,  9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
01316 { 0x000E,  6}, { 0x00E1,  8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B,  6},
01317 { 0x001C,  9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006,  7}, { 0x007A,  9}, { 0x0190, 11},
01318 { 0x0137, 13}, { 0x001B,  7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071,  7}, { 0x00D7, 10},
01319 { 0x09BF, 12}, { 0x0007,  8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034,  8}, { 0x0265, 10},
01320 { 0x009F, 12}, { 0x00E0,  8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015,  9}, { 0x017D, 11},
01321 { 0x0EBB, 12}, { 0x0014,  9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
01322 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
01323 { 0x013A, 13}, { 0x000A,  4}, { 0x0042,  7}, { 0x01D3,  9}, { 0x04DD, 11}, { 0x0012,  5},
01324 { 0x00E8,  8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039,  6}, { 0x0264, 10}, { 0x0EBA, 12},
01325 { 0x0000,  7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F,  7}, { 0x04DE, 11}, { 0x0043,  7},
01326 { 0x04DC, 11}, { 0x0003,  8}, { 0x03CB, 12}, { 0x0006,  8}, { 0x099E, 12}, { 0x002A,  8},
01327 { 0x05F1, 13}, { 0x000F,  8}, { 0x09FE, 12}, { 0x0033,  8}, { 0x09FF, 12}, { 0x0098,  8},
01328 { 0x099F, 12}, { 0x00EA,  8}, { 0x013C, 13}, { 0x002E,  8}, { 0x0192, 11}, { 0x0136,  9},
01329 { 0x006A,  9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
01330 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
01331 { 0x0016,  7}
01332 },
01333 {
01334 { 0x0004,  3}, { 0x0014,  5}, { 0x0017,  7}, { 0x007F,  8}, { 0x0154,  9}, { 0x01F2, 10},
01335 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
01336 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B,  4}, { 0x0037,  7}, { 0x0062,  9}, { 0x0007, 11},
01337 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007,  5},
01338 { 0x006D,  8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002,  6}, { 0x0061,  9},
01339 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A,  6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
01340 { 0x001E,  6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006,  7}, { 0x0004, 11},
01341 { 0x02F8, 13}, { 0x0019,  7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057,  7}, { 0x0182, 11},
01342 { 0x2AA2, 14}, { 0x0004,  8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D,  8}, { 0x0164, 12},
01343 { 0x076D, 15}, { 0x0002,  9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD,  8}, { 0x0060, 12},
01344 { 0x0C67, 14}, { 0x001C,  9}, { 0x00EE, 13}, { 0x0003,  9}, { 0x02CF, 13}, { 0x00D9,  9},
01345 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
01346 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
01347 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003,  2}, { 0x0054,  7}, { 0x02AB, 10},
01348 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005,  4}, { 0x00F8,  9}, { 0x0AA9, 12}, { 0x005F, 15},
01349 { 0x0004,  4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004,  5}, { 0x0077, 11}, { 0x076C, 15},
01350 { 0x000E,  5}, { 0x000A, 12}, { 0x000C,  5}, { 0x0562, 11}, { 0x0004,  6}, { 0x031C, 12},
01351 { 0x0006,  6}, { 0x00C8, 13}, { 0x000D,  6}, { 0x01DA, 13}, { 0x0007,  6}, { 0x00C9, 13},
01352 { 0x0001,  7}, { 0x002E, 14}, { 0x0014,  7}, { 0x1596, 13}, { 0x000A,  7}, { 0x0AC2, 12},
01353 { 0x0016,  7}, { 0x015B, 14}, { 0x0015,  7}, { 0x015A, 14}, { 0x000F,  8}, { 0x005E, 15},
01354 { 0x007E,  8}, { 0x00AB,  8}, { 0x002D,  9}, { 0x00D8,  9}, { 0x000B,  9}, { 0x0014, 10},
01355 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E,  9},
01356 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
01357 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
01358 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D,  9}
01359 },
01360 {
01361 { 0x0002,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x000D,  5}, { 0x000C,  5}, { 0x0015,  6},
01362 { 0x0013,  6}, { 0x0012,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x001E,  8}, { 0x001D,  8},
01363 { 0x0025,  9}, { 0x0024,  9}, { 0x0023,  9}, { 0x0021,  9}, { 0x0021, 10}, { 0x0020, 10},
01364 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
01365 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E,  4}, { 0x0014,  6}, { 0x0016,  7},
01366 { 0x001C,  8}, { 0x0020,  9}, { 0x001F,  9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
01367 { 0x0055, 12}, { 0x000B,  5}, { 0x0015,  7}, { 0x001E,  9}, { 0x000C, 10}, { 0x0056, 12},
01368 { 0x0011,  6}, { 0x001B,  8}, { 0x001D,  9}, { 0x000B, 10}, { 0x0010,  6}, { 0x0022,  9},
01369 { 0x000A, 10}, { 0x000D,  6}, { 0x001C,  9}, { 0x0008, 10}, { 0x0012,  7}, { 0x001B,  9},
01370 { 0x0054, 12}, { 0x0014,  7}, { 0x001A,  9}, { 0x0057, 12}, { 0x0019,  8}, { 0x0009, 10},
01371 { 0x0018,  8}, { 0x0023, 11}, { 0x0017,  8}, { 0x0019,  9}, { 0x0018,  9}, { 0x0007, 10},
01372 { 0x0058, 12}, { 0x0007,  4}, { 0x000C,  6}, { 0x0016,  8}, { 0x0017,  9}, { 0x0006, 10},
01373 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F,  6}, { 0x0016,  9}, { 0x0005, 10},
01374 { 0x000E,  6}, { 0x0004, 10}, { 0x0011,  7}, { 0x0024, 11}, { 0x0010,  7}, { 0x0025, 11},
01375 { 0x0013,  7}, { 0x005A, 12}, { 0x0015,  8}, { 0x005B, 12}, { 0x0014,  8}, { 0x0013,  8},
01376 { 0x001A,  8}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9}, { 0x0012,  9}, { 0x0011,  9},
01377 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
01378 { 0x0003,  7}
01379 },
01380 {
01381 { 0x0002,  2}, { 0x000F,  4}, { 0x0015,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x0025,  9},
01382 { 0x0024,  9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
01383 { 0x0006,  3}, { 0x0014,  6}, { 0x001E,  8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
01384 { 0x000E,  4}, { 0x001D,  8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D,  5}, { 0x0023,  9},
01385 { 0x000D, 10}, { 0x000C,  5}, { 0x0022,  9}, { 0x0052, 12}, { 0x000B,  5}, { 0x000C, 10},
01386 { 0x0053, 12}, { 0x0013,  6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012,  6}, { 0x000A, 10},
01387 { 0x0011,  6}, { 0x0009, 10}, { 0x0010,  6}, { 0x0008, 10}, { 0x0016,  7}, { 0x0055, 12},
01388 { 0x0015,  7}, { 0x0014,  7}, { 0x001C,  8}, { 0x001B,  8}, { 0x0021,  9}, { 0x0020,  9},
01389 { 0x001F,  9}, { 0x001E,  9}, { 0x001D,  9}, { 0x001C,  9}, { 0x001B,  9}, { 0x001A,  9},
01390 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007,  4}, { 0x0019,  9},
01391 { 0x0005, 11}, { 0x000F,  6}, { 0x0004, 11}, { 0x000E,  6}, { 0x000D,  6}, { 0x000C,  6},
01392 { 0x0013,  7}, { 0x0012,  7}, { 0x0011,  7}, { 0x0010,  7}, { 0x001A,  8}, { 0x0019,  8},
01393 { 0x0018,  8}, { 0x0017,  8}, { 0x0016,  8}, { 0x0015,  8}, { 0x0014,  8}, { 0x0013,  8},
01394 { 0x0018,  9}, { 0x0017,  9}, { 0x0016,  9}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9},
01395 { 0x0012,  9}, { 0x0011,  9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
01396 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
01397 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
01398 { 0x0003,  7}
01399 },
01400 {
01401 { 0x0000,  2}, { 0x0003,  3}, { 0x000D,  4}, { 0x0005,  4}, { 0x001C,  5}, { 0x0016,  5},
01402 { 0x003F,  6}, { 0x003A,  6}, { 0x002E,  6}, { 0x0022,  6}, { 0x007B,  7}, { 0x0067,  7},
01403 { 0x005F,  7}, { 0x0047,  7}, { 0x0026,  7}, { 0x00EF,  8}, { 0x00CD,  8}, { 0x00C1,  8},
01404 { 0x00A9,  8}, { 0x004F,  8}, { 0x01F2,  9}, { 0x01DD,  9}, { 0x0199,  9}, { 0x0185,  9},
01405 { 0x015D,  9}, { 0x011B,  9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
01406 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
01407 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
01408 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
01409 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
01410 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009,  4}, { 0x0010,  5}, { 0x0029,  6}, { 0x0062,  7},
01411 { 0x00F3,  8}, { 0x00AD,  8}, { 0x01E5,  9}, { 0x0179,  9}, { 0x009C,  9}, { 0x03B1, 10},
01412 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
01413 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008,  5}, { 0x0063,  7},
01414 { 0x00AF,  8}, { 0x017B,  9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
01415 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028,  6}, { 0x00C3,  8}, { 0x0151,  9}, { 0x02A1, 10},
01416 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065,  7}, { 0x01DA,  9}, { 0x02AF, 10},
01417 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025,  7}, { 0x0118,  9}, { 0x0646, 11},
01418 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9,  8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
01419 { 0x0048,  8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180,  9}, { 0x0465, 11}, { 0x1905, 13},
01420 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
01421 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
01422 { 0x0078,  7}, { 0x0155,  9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA,  8}, { 0x07DC, 11},
01423 { 0x1907, 13}, { 0x00AC,  8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6,  9}, { 0x0AE2, 12},
01424 { 0x01DC,  9}, { 0x04ED, 12}, { 0x0184,  9}, { 0x1904, 13}, { 0x0156,  9}, { 0x09D9, 13},
01425 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
01426 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
01427 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
01428 { 0x007A,  7}
01429 },
01430 {
01431 { 0x0002,  2}, { 0x0000,  3}, { 0x001E,  5}, { 0x0004,  5}, { 0x0012,  6}, { 0x0070,  7},
01432 { 0x001A,  7}, { 0x005F,  8}, { 0x0047,  8}, { 0x01D3,  9}, { 0x00B5,  9}, { 0x0057,  9},
01433 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
01434 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
01435 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
01436 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003,  3}, { 0x000A,  5}, { 0x0077,  7}, { 0x00E5,  8},
01437 { 0x01D9,  9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
01438 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C,  4}, { 0x007D,  7}, { 0x0044,  8},
01439 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B,  5},
01440 { 0x00E2,  8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007,  5},
01441 { 0x01D8,  9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035,  6}, { 0x03E1, 10},
01442 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C,  6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
01443 { 0x0068,  7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020,  7}, { 0x0F90, 12}, { 0x7CF6, 15},
01444 { 0x00E8,  8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045,  8}, { 0x0B3A, 13}, { 0x01F1,  9},
01445 { 0x3B46, 14}, { 0x01A7,  9}, { 0x1676, 14}, { 0x0056,  9}, { 0x692A, 15}, { 0x038D, 10},
01446 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
01447 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
01448 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
01449 { 0x055F, 13}, { 0x003F,  6}, { 0x006D,  9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013,  6},
01450 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B,  6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075,  7},
01451 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E,  7}, { 0x1F22, 13}, { 0x0021,  7}, { 0x054F, 13},
01452 { 0x0014,  7}, { 0x3A44, 14}, { 0x00E4,  8}, { 0x7CF7, 15}, { 0x005E,  8}, { 0x7185, 15},
01453 { 0x0037,  8}, { 0x2C73, 15}, { 0x01DB,  9}, { 0x59DD, 16}, { 0x01C7,  9}, { 0x692B, 15},
01454 { 0x01A6,  9}, { 0x58E5, 16}, { 0x00B4,  9}, { 0x1F3D0, 17}, { 0x00B0,  9}, { 0xB1C9, 17},
01455 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
01456 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
01457 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
01458 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
01459 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
01460 { 0x0073,  7}
01461 }
01462 };
01463 
01464 static const uint16_t vlc_offs[] = {
01465         0,   520,   552,   616,  1128,  1160,  1224,  1740,  1772,  1836,  1900,  2436,
01466      2986,  3050,  3610,  4154,  4218,  4746,  5326,  5390,  5902,  6554,  7658,  8342,
01467      9304,  9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
01468     20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
01469     27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
01470     29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
01471     31714, 31746, 31778, 32306, 32340, 32372
01472 };
01473 
01479 int ff_vc1_init_common(VC1Context *v)
01480 {
01481     static int done = 0;
01482     int i = 0;
01483     static VLC_TYPE vlc_table[32372][2];
01484 
01485     v->hrd_rate = v->hrd_buffer = NULL;
01486 
01487     /* VLC tables */
01488     if (!done) {
01489         INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
01490                         ff_vc1_bfraction_bits, 1, 1,
01491                         ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
01492         INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
01493                         ff_vc1_norm2_bits, 1, 1,
01494                         ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
01495         INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
01496                         ff_vc1_norm6_bits, 1, 1,
01497                         ff_vc1_norm6_codes, 2, 2, 556);
01498         INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
01499                         ff_vc1_imode_bits, 1, 1,
01500                         ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
01501         for (i = 0; i < 3; i++) {
01502             ff_vc1_ttmb_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 0]];
01503             ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
01504             init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
01505                      ff_vc1_ttmb_bits[i], 1, 1,
01506                      ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01507             ff_vc1_ttblk_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 1]];
01508             ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
01509             init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
01510                      ff_vc1_ttblk_bits[i], 1, 1,
01511                      ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01512             ff_vc1_subblkpat_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 2]];
01513             ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
01514             init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
01515                      ff_vc1_subblkpat_bits[i], 1, 1,
01516                      ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01517         }
01518         for (i = 0; i < 4; i++) {
01519             ff_vc1_4mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 9]];
01520             ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
01521             init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
01522                      ff_vc1_4mv_block_pattern_bits[i], 1, 1,
01523                      ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01524             ff_vc1_cbpcy_p_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 10]];
01525             ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
01526             init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
01527                      ff_vc1_cbpcy_p_bits[i], 1, 1,
01528                      ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01529             ff_vc1_mv_diff_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 11]];
01530             ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
01531             init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
01532                      ff_vc1_mv_diff_bits[i], 1, 1,
01533                      ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01534         }
01535         for (i = 0; i < 8; i++) {
01536             ff_vc1_ac_coeff_table[i].table           = &vlc_table[vlc_offs[i * 2 + 21]];
01537             ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
01538             init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
01539                      &vc1_ac_tables[i][0][1], 8, 4,
01540                      &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
01541             /* initialize interlaced MVDATA tables (2-Ref) */
01542             ff_vc1_2ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 2 + 22]];
01543             ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
01544             init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
01545                      ff_vc1_2ref_mvdata_bits[i], 1, 1,
01546                      ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
01547         }
01548         for (i = 0; i < 4; i++) {
01549             /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
01550             ff_vc1_intfr_4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 37]];
01551             ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
01552             init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
01553                      ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
01554                      ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01555             /* initialize NON-4MV MBMODE VLC tables for the same */
01556             ff_vc1_intfr_non4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 38]];
01557             ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
01558             init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
01559                      ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
01560                      ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01561             /* initialize interlaced MVDATA tables (1-Ref) */
01562             ff_vc1_1ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 39]];
01563             ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
01564             init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
01565                      ff_vc1_1ref_mvdata_bits[i], 1, 1,
01566                      ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
01567         }
01568         for (i = 0; i < 4; i++) {
01569             /* Initialize 2MV Block pattern VLC tables */
01570             ff_vc1_2mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i + 49]];
01571             ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
01572             init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
01573                      ff_vc1_2mv_block_pattern_bits[i], 1, 1,
01574                      ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01575         }
01576         for (i = 0; i < 8; i++) {
01577             /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
01578             ff_vc1_icbpcy_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 53]];
01579             ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
01580             init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
01581                      ff_vc1_icbpcy_p_bits[i], 1, 1,
01582                      ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01583             /* Initialize interlaced field picture MBMODE VLC tables */
01584             ff_vc1_if_mmv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 54]];
01585             ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
01586             init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
01587                      ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
01588                      ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01589             ff_vc1_if_1mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 55]];
01590             ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
01591             init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
01592                      ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
01593                      ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01594         }
01595         done = 1;
01596     }
01597 
01598     /* Other defaults */
01599     v->pq      = -1;
01600     v->mvrange = 0; /* 7.1.1.18, p80 */
01601 
01602     return 0;
01603 }