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->numref          = 0;
00826     v->p_frame_skipped = 0;
00827     if (v->second_field) {
00828         v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00829         if (v->fptype & 4)
00830             v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00831         v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
00832         if (!v->pic_header_flag)
00833             goto parse_common_info;
00834     }
00835 
00836     v->field_mode = 0;
00837     if (v->interlace) {
00838         v->fcm = decode012(gb);
00839         if (v->fcm) {
00840             if (v->fcm == ILACE_FIELD)
00841                 v->field_mode = 1;
00842             if (!v->warn_interlaced++)
00843                 av_log(v->s.avctx, AV_LOG_ERROR,
00844                        "Interlaced frames/fields support is incomplete\n");
00845         }
00846     } else {
00847         v->fcm = PROGRESSIVE;
00848     }
00849 
00850     if (v->field_mode) {
00851         v->fptype = get_bits(gb, 3);
00852         v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00853         if (v->fptype & 4) // B-picture
00854             v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00855     } else {
00856         switch (get_unary(gb, 0, 4)) {
00857         case 0:
00858             v->s.pict_type = AV_PICTURE_TYPE_P;
00859             break;
00860         case 1:
00861             v->s.pict_type = AV_PICTURE_TYPE_B;
00862             break;
00863         case 2:
00864             v->s.pict_type = AV_PICTURE_TYPE_I;
00865             break;
00866         case 3:
00867             v->s.pict_type = AV_PICTURE_TYPE_BI;
00868             break;
00869         case 4:
00870             v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
00871             v->p_frame_skipped = 1;
00872             break;
00873         }
00874     }
00875     if (v->tfcntrflag)
00876         skip_bits(gb, 8);
00877     if (v->broadcast) {
00878         if (!v->interlace || v->psf) {
00879             v->rptfrm = get_bits(gb, 2);
00880         } else {
00881             v->tff = get_bits1(gb);
00882             v->rff = get_bits1(gb);
00883         }
00884     }
00885     if (v->panscanflag) {
00886         av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
00887         //...
00888     }
00889     if (v->p_frame_skipped) {
00890         return 0;
00891     }
00892     v->rnd = get_bits1(gb);
00893     if (v->interlace)
00894         v->uvsamp = get_bits1(gb);
00895     if (v->field_mode) {
00896         if (!v->refdist_flag)
00897             v->refdist = 0;
00898         else {
00899             if ((v->s.pict_type != AV_PICTURE_TYPE_B)
00900                 && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
00901                 v->refdist = get_bits(gb, 2);
00902                 if (v->refdist == 3)
00903                     v->refdist += get_unary(gb, 0, 16);
00904             } else {
00905                 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00906                 v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00907                 v->frfd = (v->bfraction * v->refdist) >> 8;
00908                 v->brfd = v->refdist - v->frfd - 1;
00909                 if (v->brfd < 0)
00910                     v->brfd = 0;
00911             }
00912         }
00913         goto parse_common_info;
00914     }
00915     if (v->finterpflag)
00916         v->interpfrm = get_bits1(gb);
00917     if (v->s.pict_type == AV_PICTURE_TYPE_B) {
00918         v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00919         v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00920         if (v->bfraction == 0) {
00921             v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
00922         }
00923     }
00924 
00925     parse_common_info:
00926     if (v->field_mode)
00927         v->cur_field_type = !(v->tff ^ v->second_field);
00928     pqindex = get_bits(gb, 5);
00929     if (!pqindex)
00930         return -1;
00931     v->pqindex = pqindex;
00932     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00933         v->pq = ff_vc1_pquant_table[0][pqindex];
00934     else
00935         v->pq = ff_vc1_pquant_table[1][pqindex];
00936 
00937     v->pquantizer = 1;
00938     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00939         v->pquantizer = pqindex < 9;
00940     if (v->quantizer_mode == QUANT_NON_UNIFORM)
00941         v->pquantizer = 0;
00942     v->pqindex = pqindex;
00943     if (pqindex < 9)
00944         v->halfpq = get_bits1(gb);
00945     else
00946         v->halfpq = 0;
00947     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00948         v->pquantizer = get_bits1(gb);
00949     if (v->postprocflag)
00950         v->postproc = get_bits(gb, 2);
00951 
00952     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
00953         v->use_ic = 0;
00954 
00955     if (v->parse_only)
00956         return 0;
00957 
00958     switch (v->s.pict_type) {
00959     case AV_PICTURE_TYPE_I:
00960     case AV_PICTURE_TYPE_BI:
00961         if (v->fcm == ILACE_FRAME) { //interlace frame picture
00962             status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
00963             if (status < 0)
00964                 return -1;
00965             av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
00966                    "Imode: %i, Invert: %i\n", status>>1, status&1);
00967         }
00968         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
00969         if (status < 0)
00970             return -1;
00971         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
00972                "Imode: %i, Invert: %i\n", status>>1, status&1);
00973         v->condover = CONDOVER_NONE;
00974         if (v->overlap && v->pq <= 8) {
00975             v->condover = decode012(gb);
00976             if (v->condover == CONDOVER_SELECT) {
00977                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
00978                 if (status < 0)
00979                     return -1;
00980                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
00981                        "Imode: %i, Invert: %i\n", status>>1, status&1);
00982             }
00983         }
00984         break;
00985     case AV_PICTURE_TYPE_P:
00986         if (v->field_mode) {
00987             v->numref = get_bits1(gb);
00988             if (!v->numref) {
00989                 v->reffield          = get_bits1(gb);
00990                 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
00991             }
00992         }
00993         if (v->extended_mv)
00994             v->mvrange = get_unary(gb, 0, 3);
00995         else
00996             v->mvrange = 0;
00997         if (v->interlace) {
00998             if (v->extended_dmv)
00999                 v->dmvrange = get_unary(gb, 0, 3);
01000             else
01001                 v->dmvrange = 0;
01002             if (v->fcm == ILACE_FRAME) { // interlaced frame picture
01003                 v->fourmvswitch = get_bits1(gb);
01004                 v->intcomp      = get_bits1(gb);
01005                 if (v->intcomp) {
01006                     v->lumscale = get_bits(gb, 6);
01007                     v->lumshift = get_bits(gb, 6);
01008                     INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01009                 }
01010                 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01011                 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
01012                        "Imode: %i, Invert: %i\n", status>>1, status&1);
01013                 mbmodetab = get_bits(gb, 2);
01014                 if (v->fourmvswitch)
01015                     v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
01016                 else
01017                     v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
01018                 imvtab         = get_bits(gb, 2);
01019                 v->imv_vlc     = &ff_vc1_1ref_mvdata_vlc[imvtab];
01020                 // interlaced p-picture cbpcy range is [1, 63]
01021                 icbptab        = get_bits(gb, 3);
01022                 v->cbpcy_vlc   = &ff_vc1_icbpcy_vlc[icbptab];
01023                 twomvbptab     = get_bits(gb, 2);
01024                 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
01025                 if (v->fourmvswitch) {
01026                     fourmvbptab     = get_bits(gb, 2);
01027                     v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01028                 }
01029             }
01030         }
01031         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
01032         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
01033         v->range_x = 1 << (v->k_x - 1);
01034         v->range_y = 1 << (v->k_y - 1);
01035 
01036         if (v->pq < 5)
01037             v->tt_index = 0;
01038         else if (v->pq < 13)
01039             v->tt_index = 1;
01040         else
01041             v->tt_index = 2;
01042         if (v->fcm != ILACE_FRAME) {
01043             int mvmode;
01044             mvmode     = get_unary(gb, 1, 4);
01045             lowquant   = (v->pq > 12) ? 0 : 1;
01046             v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
01047             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01048                 int mvmode2;
01049                 mvmode2 = get_unary(gb, 1, 3);
01050                 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
01051                 if (v->field_mode)
01052                     v->intcompfield = decode210(gb);
01053                 v->lumscale = get_bits(gb, 6);
01054                 v->lumshift = get_bits(gb, 6);
01055                 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01056                 if ((v->field_mode) && !v->intcompfield) {
01057                     v->lumscale2 = get_bits(gb, 6);
01058                     v->lumshift2 = get_bits(gb, 6);
01059                     INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
01060                 }
01061                 v->use_ic = 1;
01062             }
01063             v->qs_last = v->s.quarter_sample;
01064             if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
01065                 v->s.quarter_sample = 0;
01066             else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01067                 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
01068                     v->s.quarter_sample = 0;
01069                 else
01070                     v->s.quarter_sample = 1;
01071             } else
01072                 v->s.quarter_sample = 1;
01073             v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
01074                            || (v->mv_mode == MV_PMODE_INTENSITY_COMP
01075                                && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
01076         }
01077         if (v->fcm == PROGRESSIVE) { // progressive
01078             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01079                  v->mv_mode2 == MV_PMODE_MIXED_MV)
01080                 || v->mv_mode == MV_PMODE_MIXED_MV) {
01081                 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
01082                 if (status < 0)
01083                     return -1;
01084                 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
01085                        "Imode: %i, Invert: %i\n", status>>1, status&1);
01086             } else {
01087                 v->mv_type_is_raw = 0;
01088                 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
01089             }
01090             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01091             if (status < 0)
01092                 return -1;
01093             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01094                    "Imode: %i, Invert: %i\n", status>>1, status&1);
01095 
01096             /* Hopefully this is correct for P frames */
01097             v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
01098             v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01099         } else if (v->fcm == ILACE_FRAME) { // frame interlaced
01100             v->qs_last          = v->s.quarter_sample;
01101             v->s.quarter_sample = 1;
01102             v->s.mspel          = 1;
01103         } else {    // field interlaced
01104             mbmodetab = get_bits(gb, 3);
01105             imvtab = get_bits(gb, 2 + v->numref);
01106             if (!v->numref)
01107                 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
01108             else
01109                 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
01110             icbptab = get_bits(gb, 3);
01111             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01112             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01113                 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
01114                 fourmvbptab     = get_bits(gb, 2);
01115                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01116                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01117             } else {
01118                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01119             }
01120         }
01121         if (v->dquant) {
01122             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01123             vop_dquant_decoding(v);
01124         }
01125 
01126         v->ttfrm = 0; //FIXME Is that so ?
01127         if (v->vstransform) {
01128             v->ttmbf = get_bits1(gb);
01129             if (v->ttmbf) {
01130                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01131             }
01132         } else {
01133             v->ttmbf = 1;
01134             v->ttfrm = TT_8X8;
01135         }
01136         break;
01137     case AV_PICTURE_TYPE_B:
01138         // TODO: implement interlaced frame B picture decoding
01139         if (v->fcm == ILACE_FRAME)
01140             return -1;
01141         if (v->extended_mv)
01142             v->mvrange = get_unary(gb, 0, 3);
01143         else
01144             v->mvrange = 0;
01145         v->k_x     = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
01146         v->k_y     = v->mvrange + 8; //k_y can be 8 9 10 11
01147         v->range_x = 1 << (v->k_x - 1);
01148         v->range_y = 1 << (v->k_y - 1);
01149 
01150         if (v->pq < 5)
01151             v->tt_index = 0;
01152         else if (v->pq < 13)
01153             v->tt_index = 1;
01154         else
01155             v->tt_index = 2;
01156 
01157         if (v->field_mode) {
01158             int mvmode;
01159             if (v->extended_dmv)
01160                 v->dmvrange = get_unary(gb, 0, 3);
01161             mvmode = get_unary(gb, 1, 3);
01162             lowquant = (v->pq > 12) ? 0 : 1;
01163             v->mv_mode          = ff_vc1_mv_pmode_table2[lowquant][mvmode];
01164             v->qs_last          = v->s.quarter_sample;
01165             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
01166             v->s.mspel          = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
01167             status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
01168             if (status < 0)
01169                 return -1;
01170             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
01171                    "Imode: %i, Invert: %i\n", status>>1, status&1);
01172             mbmodetab = get_bits(gb, 3);
01173             if (v->mv_mode == MV_PMODE_MIXED_MV)
01174                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01175             else
01176                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01177             imvtab       = get_bits(gb, 3);
01178             v->imv_vlc   = &ff_vc1_2ref_mvdata_vlc[imvtab];
01179             icbptab      = get_bits(gb, 3);
01180             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01181             if (v->mv_mode == MV_PMODE_MIXED_MV) {
01182                 fourmvbptab     = get_bits(gb, 2);
01183                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01184             }
01185             v->numref = 1; // interlaced field B pictures are always 2-ref
01186         } else {
01187             v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
01188             v->qs_last          = v->s.quarter_sample;
01189             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
01190             v->s.mspel          = v->s.quarter_sample;
01191             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
01192             if (status < 0)
01193                 return -1;
01194             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
01195                    "Imode: %i, Invert: %i\n", status>>1, status&1);
01196             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01197             if (status < 0)
01198                 return -1;
01199             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01200                    "Imode: %i, Invert: %i\n", status>>1, status&1);
01201             v->s.mv_table_index = get_bits(gb, 2);
01202             v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01203         }
01204 
01205         if (v->dquant) {
01206             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01207             vop_dquant_decoding(v);
01208         }
01209 
01210         v->ttfrm = 0;
01211         if (v->vstransform) {
01212             v->ttmbf = get_bits1(gb);
01213             if (v->ttmbf) {
01214                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01215             }
01216         } else {
01217             v->ttmbf = 1;
01218             v->ttfrm = TT_8X8;
01219         }
01220         break;
01221     }
01222 
01223     /* AC Syntax */
01224     v->c_ac_table_index = decode012(gb);
01225     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
01226         v->y_ac_table_index = decode012(gb);
01227     }
01228     /* DC Syntax */
01229     v->s.dc_table_index = get_bits1(gb);
01230     if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
01231         && v->dquant) {
01232         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01233         vop_dquant_decoding(v);
01234     }
01235 
01236     v->bi_type = 0;
01237     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
01238         v->s.pict_type = AV_PICTURE_TYPE_B;
01239         v->bi_type = 1;
01240     }
01241     return 0;
01242 }
01243 
01244 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
01245 {
01246 { 0x0001,  2}, { 0x0005,  3}, { 0x000D,  4}, { 0x0012,  5}, { 0x000E,  6}, { 0x0015,  7},
01247 { 0x0013,  8}, { 0x003F,  8}, { 0x004B,  9}, { 0x011F,  9}, { 0x00B8, 10}, { 0x03E3, 10},
01248 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
01249 { 0x3EAE, 14}, { 0x0000,  4}, { 0x0010,  5}, { 0x0008,  7}, { 0x0020,  8}, { 0x0029,  9},
01250 { 0x01F4,  9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
01251 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003,  5}, { 0x0011,  7},
01252 { 0x00C4,  8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
01253 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013,  5}, { 0x0078,  7},
01254 { 0x0069,  9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
01255 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C,  6}, { 0x0024,  9}, { 0x0094, 11},
01256 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D,  6}, { 0x0053,  9}, { 0x01A0, 11},
01257 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013,  7}, { 0x007C,  9}, { 0x07C1, 11}, { 0x04AC, 14},
01258 { 0x001B,  7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079,  7}, { 0x03E1, 10},
01259 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021,  8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
01260 { 0x0035,  8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5,  8}, { 0x0174, 11}, { 0x0785, 13},
01261 { 0x0048,  9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C,  9}, { 0x00FA, 10}, { 0x07D6, 11},
01262 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
01263 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
01264 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
01265 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E,  4},
01266 { 0x0045,  7}, { 0x01F3,  9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019,  5},
01267 { 0x0028,  9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030,  6}, { 0x00A2, 10},
01268 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F,  6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
01269 { 0x0044,  7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063,  7}, { 0x03C3, 12}, { 0x0015,  8},
01270 { 0x08F6, 12}, { 0x0017,  8}, { 0x0498, 13}, { 0x002C,  8}, { 0x07B2, 13}, { 0x002F,  8},
01271 { 0x1F54, 13}, { 0x008D,  8}, { 0x07BD, 13}, { 0x008E,  8}, { 0x1182, 13}, { 0x00FB,  8},
01272 { 0x050B, 13}, { 0x002D,  8}, { 0x07C0, 11}, { 0x0079,  9}, { 0x1F5F, 13}, { 0x007A,  9},
01273 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
01274 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
01275 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
01276 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A,  9}
01277 },
01278 {
01279 { 0x0000,  3}, { 0x0003,  4}, { 0x000B,  5}, { 0x0014,  6}, { 0x003F,  6}, { 0x005D,  7},
01280 { 0x00A2,  8}, { 0x00AC,  9}, { 0x016E,  9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
01281 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
01282 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004,  4},
01283 { 0x001E,  5}, { 0x0042,  7}, { 0x00B6,  8}, { 0x0173,  9}, { 0x0395, 10}, { 0x072E, 11},
01284 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005,  5}, { 0x0040,  7},
01285 { 0x0049,  9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
01286 { 0x0018,  5}, { 0x0025,  8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
01287 { 0x139C, 15}, { 0x0029,  6}, { 0x004F,  9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
01288 { 0x0038,  6}, { 0x010E,  9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058,  7},
01289 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023,  8}, { 0x02E3, 10}, { 0x04E5, 13},
01290 { 0x2E40, 14}, { 0x00A1,  8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083,  8}, { 0x013A, 11},
01291 { 0x1721, 13}, { 0x0044,  9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
01292 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
01293 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
01294 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
01295 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003,  3}, { 0x002A,  6}, { 0x00E4,  8},
01296 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
01297 { 0x0009,  4}, { 0x0054,  8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D,  4},
01298 { 0x00AD,  9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011,  5}, { 0x016B,  9}, { 0x0B7F, 12},
01299 { 0x51A4, 15}, { 0x0019,  5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D,  5}, { 0x0394, 10},
01300 { 0x28D3, 14}, { 0x002B,  6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F,  6}, { 0x0247, 12},
01301 { 0x0010,  7}, { 0x0A35, 12}, { 0x003E,  6}, { 0x0B7A, 12}, { 0x0059,  7}, { 0x105E, 13},
01302 { 0x0026,  8}, { 0x09CF, 14}, { 0x0055,  8}, { 0x1CB5, 13}, { 0x0057,  8}, { 0x0E5B, 12},
01303 { 0x00A0,  8}, { 0x1468, 13}, { 0x0170,  9}, { 0x0090, 10}, { 0x01CE,  9}, { 0x021A, 10},
01304 { 0x0218, 10}, { 0x0168,  9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
01305 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
01306 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
01307 { 0x0169,  9}
01308 },
01309 {
01310 { 0x0001,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x0016,  5}, { 0x0020,  6}, { 0x0018,  7},
01311 { 0x0008,  8}, { 0x009A,  8}, { 0x0056,  9}, { 0x013E,  9}, { 0x00F0, 10}, { 0x03A5, 10},
01312 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001,  4}, { 0x0011,  5},
01313 { 0x0002,  7}, { 0x000B,  8}, { 0x0012,  9}, { 0x01D6,  9}, { 0x027E, 10}, { 0x0191, 11},
01314 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004,  5}, { 0x0014,  7}, { 0x009E,  8},
01315 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017,  5},
01316 { 0x004E,  7}, { 0x005E,  9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
01317 { 0x000E,  6}, { 0x00E1,  8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B,  6},
01318 { 0x001C,  9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006,  7}, { 0x007A,  9}, { 0x0190, 11},
01319 { 0x0137, 13}, { 0x001B,  7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071,  7}, { 0x00D7, 10},
01320 { 0x09BF, 12}, { 0x0007,  8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034,  8}, { 0x0265, 10},
01321 { 0x009F, 12}, { 0x00E0,  8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015,  9}, { 0x017D, 11},
01322 { 0x0EBB, 12}, { 0x0014,  9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
01323 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
01324 { 0x013A, 13}, { 0x000A,  4}, { 0x0042,  7}, { 0x01D3,  9}, { 0x04DD, 11}, { 0x0012,  5},
01325 { 0x00E8,  8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039,  6}, { 0x0264, 10}, { 0x0EBA, 12},
01326 { 0x0000,  7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F,  7}, { 0x04DE, 11}, { 0x0043,  7},
01327 { 0x04DC, 11}, { 0x0003,  8}, { 0x03CB, 12}, { 0x0006,  8}, { 0x099E, 12}, { 0x002A,  8},
01328 { 0x05F1, 13}, { 0x000F,  8}, { 0x09FE, 12}, { 0x0033,  8}, { 0x09FF, 12}, { 0x0098,  8},
01329 { 0x099F, 12}, { 0x00EA,  8}, { 0x013C, 13}, { 0x002E,  8}, { 0x0192, 11}, { 0x0136,  9},
01330 { 0x006A,  9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
01331 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
01332 { 0x0016,  7}
01333 },
01334 {
01335 { 0x0004,  3}, { 0x0014,  5}, { 0x0017,  7}, { 0x007F,  8}, { 0x0154,  9}, { 0x01F2, 10},
01336 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
01337 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B,  4}, { 0x0037,  7}, { 0x0062,  9}, { 0x0007, 11},
01338 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007,  5},
01339 { 0x006D,  8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002,  6}, { 0x0061,  9},
01340 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A,  6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
01341 { 0x001E,  6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006,  7}, { 0x0004, 11},
01342 { 0x02F8, 13}, { 0x0019,  7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057,  7}, { 0x0182, 11},
01343 { 0x2AA2, 14}, { 0x0004,  8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D,  8}, { 0x0164, 12},
01344 { 0x076D, 15}, { 0x0002,  9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD,  8}, { 0x0060, 12},
01345 { 0x0C67, 14}, { 0x001C,  9}, { 0x00EE, 13}, { 0x0003,  9}, { 0x02CF, 13}, { 0x00D9,  9},
01346 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
01347 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
01348 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003,  2}, { 0x0054,  7}, { 0x02AB, 10},
01349 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005,  4}, { 0x00F8,  9}, { 0x0AA9, 12}, { 0x005F, 15},
01350 { 0x0004,  4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004,  5}, { 0x0077, 11}, { 0x076C, 15},
01351 { 0x000E,  5}, { 0x000A, 12}, { 0x000C,  5}, { 0x0562, 11}, { 0x0004,  6}, { 0x031C, 12},
01352 { 0x0006,  6}, { 0x00C8, 13}, { 0x000D,  6}, { 0x01DA, 13}, { 0x0007,  6}, { 0x00C9, 13},
01353 { 0x0001,  7}, { 0x002E, 14}, { 0x0014,  7}, { 0x1596, 13}, { 0x000A,  7}, { 0x0AC2, 12},
01354 { 0x0016,  7}, { 0x015B, 14}, { 0x0015,  7}, { 0x015A, 14}, { 0x000F,  8}, { 0x005E, 15},
01355 { 0x007E,  8}, { 0x00AB,  8}, { 0x002D,  9}, { 0x00D8,  9}, { 0x000B,  9}, { 0x0014, 10},
01356 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E,  9},
01357 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
01358 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
01359 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D,  9}
01360 },
01361 {
01362 { 0x0002,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x000D,  5}, { 0x000C,  5}, { 0x0015,  6},
01363 { 0x0013,  6}, { 0x0012,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x001E,  8}, { 0x001D,  8},
01364 { 0x0025,  9}, { 0x0024,  9}, { 0x0023,  9}, { 0x0021,  9}, { 0x0021, 10}, { 0x0020, 10},
01365 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
01366 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E,  4}, { 0x0014,  6}, { 0x0016,  7},
01367 { 0x001C,  8}, { 0x0020,  9}, { 0x001F,  9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
01368 { 0x0055, 12}, { 0x000B,  5}, { 0x0015,  7}, { 0x001E,  9}, { 0x000C, 10}, { 0x0056, 12},
01369 { 0x0011,  6}, { 0x001B,  8}, { 0x001D,  9}, { 0x000B, 10}, { 0x0010,  6}, { 0x0022,  9},
01370 { 0x000A, 10}, { 0x000D,  6}, { 0x001C,  9}, { 0x0008, 10}, { 0x0012,  7}, { 0x001B,  9},
01371 { 0x0054, 12}, { 0x0014,  7}, { 0x001A,  9}, { 0x0057, 12}, { 0x0019,  8}, { 0x0009, 10},
01372 { 0x0018,  8}, { 0x0023, 11}, { 0x0017,  8}, { 0x0019,  9}, { 0x0018,  9}, { 0x0007, 10},
01373 { 0x0058, 12}, { 0x0007,  4}, { 0x000C,  6}, { 0x0016,  8}, { 0x0017,  9}, { 0x0006, 10},
01374 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F,  6}, { 0x0016,  9}, { 0x0005, 10},
01375 { 0x000E,  6}, { 0x0004, 10}, { 0x0011,  7}, { 0x0024, 11}, { 0x0010,  7}, { 0x0025, 11},
01376 { 0x0013,  7}, { 0x005A, 12}, { 0x0015,  8}, { 0x005B, 12}, { 0x0014,  8}, { 0x0013,  8},
01377 { 0x001A,  8}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9}, { 0x0012,  9}, { 0x0011,  9},
01378 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
01379 { 0x0003,  7}
01380 },
01381 {
01382 { 0x0002,  2}, { 0x000F,  4}, { 0x0015,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x0025,  9},
01383 { 0x0024,  9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
01384 { 0x0006,  3}, { 0x0014,  6}, { 0x001E,  8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
01385 { 0x000E,  4}, { 0x001D,  8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D,  5}, { 0x0023,  9},
01386 { 0x000D, 10}, { 0x000C,  5}, { 0x0022,  9}, { 0x0052, 12}, { 0x000B,  5}, { 0x000C, 10},
01387 { 0x0053, 12}, { 0x0013,  6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012,  6}, { 0x000A, 10},
01388 { 0x0011,  6}, { 0x0009, 10}, { 0x0010,  6}, { 0x0008, 10}, { 0x0016,  7}, { 0x0055, 12},
01389 { 0x0015,  7}, { 0x0014,  7}, { 0x001C,  8}, { 0x001B,  8}, { 0x0021,  9}, { 0x0020,  9},
01390 { 0x001F,  9}, { 0x001E,  9}, { 0x001D,  9}, { 0x001C,  9}, { 0x001B,  9}, { 0x001A,  9},
01391 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007,  4}, { 0x0019,  9},
01392 { 0x0005, 11}, { 0x000F,  6}, { 0x0004, 11}, { 0x000E,  6}, { 0x000D,  6}, { 0x000C,  6},
01393 { 0x0013,  7}, { 0x0012,  7}, { 0x0011,  7}, { 0x0010,  7}, { 0x001A,  8}, { 0x0019,  8},
01394 { 0x0018,  8}, { 0x0017,  8}, { 0x0016,  8}, { 0x0015,  8}, { 0x0014,  8}, { 0x0013,  8},
01395 { 0x0018,  9}, { 0x0017,  9}, { 0x0016,  9}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9},
01396 { 0x0012,  9}, { 0x0011,  9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
01397 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
01398 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
01399 { 0x0003,  7}
01400 },
01401 {
01402 { 0x0000,  2}, { 0x0003,  3}, { 0x000D,  4}, { 0x0005,  4}, { 0x001C,  5}, { 0x0016,  5},
01403 { 0x003F,  6}, { 0x003A,  6}, { 0x002E,  6}, { 0x0022,  6}, { 0x007B,  7}, { 0x0067,  7},
01404 { 0x005F,  7}, { 0x0047,  7}, { 0x0026,  7}, { 0x00EF,  8}, { 0x00CD,  8}, { 0x00C1,  8},
01405 { 0x00A9,  8}, { 0x004F,  8}, { 0x01F2,  9}, { 0x01DD,  9}, { 0x0199,  9}, { 0x0185,  9},
01406 { 0x015D,  9}, { 0x011B,  9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
01407 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
01408 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
01409 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
01410 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
01411 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009,  4}, { 0x0010,  5}, { 0x0029,  6}, { 0x0062,  7},
01412 { 0x00F3,  8}, { 0x00AD,  8}, { 0x01E5,  9}, { 0x0179,  9}, { 0x009C,  9}, { 0x03B1, 10},
01413 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
01414 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008,  5}, { 0x0063,  7},
01415 { 0x00AF,  8}, { 0x017B,  9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
01416 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028,  6}, { 0x00C3,  8}, { 0x0151,  9}, { 0x02A1, 10},
01417 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065,  7}, { 0x01DA,  9}, { 0x02AF, 10},
01418 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025,  7}, { 0x0118,  9}, { 0x0646, 11},
01419 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9,  8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
01420 { 0x0048,  8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180,  9}, { 0x0465, 11}, { 0x1905, 13},
01421 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
01422 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
01423 { 0x0078,  7}, { 0x0155,  9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA,  8}, { 0x07DC, 11},
01424 { 0x1907, 13}, { 0x00AC,  8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6,  9}, { 0x0AE2, 12},
01425 { 0x01DC,  9}, { 0x04ED, 12}, { 0x0184,  9}, { 0x1904, 13}, { 0x0156,  9}, { 0x09D9, 13},
01426 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
01427 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
01428 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
01429 { 0x007A,  7}
01430 },
01431 {
01432 { 0x0002,  2}, { 0x0000,  3}, { 0x001E,  5}, { 0x0004,  5}, { 0x0012,  6}, { 0x0070,  7},
01433 { 0x001A,  7}, { 0x005F,  8}, { 0x0047,  8}, { 0x01D3,  9}, { 0x00B5,  9}, { 0x0057,  9},
01434 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
01435 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
01436 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
01437 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003,  3}, { 0x000A,  5}, { 0x0077,  7}, { 0x00E5,  8},
01438 { 0x01D9,  9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
01439 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C,  4}, { 0x007D,  7}, { 0x0044,  8},
01440 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B,  5},
01441 { 0x00E2,  8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007,  5},
01442 { 0x01D8,  9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035,  6}, { 0x03E1, 10},
01443 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C,  6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
01444 { 0x0068,  7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020,  7}, { 0x0F90, 12}, { 0x7CF6, 15},
01445 { 0x00E8,  8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045,  8}, { 0x0B3A, 13}, { 0x01F1,  9},
01446 { 0x3B46, 14}, { 0x01A7,  9}, { 0x1676, 14}, { 0x0056,  9}, { 0x692A, 15}, { 0x038D, 10},
01447 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
01448 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
01449 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
01450 { 0x055F, 13}, { 0x003F,  6}, { 0x006D,  9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013,  6},
01451 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B,  6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075,  7},
01452 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E,  7}, { 0x1F22, 13}, { 0x0021,  7}, { 0x054F, 13},
01453 { 0x0014,  7}, { 0x3A44, 14}, { 0x00E4,  8}, { 0x7CF7, 15}, { 0x005E,  8}, { 0x7185, 15},
01454 { 0x0037,  8}, { 0x2C73, 15}, { 0x01DB,  9}, { 0x59DD, 16}, { 0x01C7,  9}, { 0x692B, 15},
01455 { 0x01A6,  9}, { 0x58E5, 16}, { 0x00B4,  9}, { 0x1F3D0, 17}, { 0x00B0,  9}, { 0xB1C9, 17},
01456 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
01457 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
01458 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
01459 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
01460 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
01461 { 0x0073,  7}
01462 }
01463 };
01464 
01465 static const uint16_t vlc_offs[] = {
01466         0,   520,   552,   616,  1128,  1160,  1224,  1740,  1772,  1836,  1900,  2436,
01467      2986,  3050,  3610,  4154,  4218,  4746,  5326,  5390,  5902,  6554,  7658,  8342,
01468      9304,  9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
01469     20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
01470     27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
01471     29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
01472     31714, 31746, 31778, 32306, 32340, 32372
01473 };
01474 
01480 int ff_vc1_init_common(VC1Context *v)
01481 {
01482     static int done = 0;
01483     int i = 0;
01484     static VLC_TYPE vlc_table[32372][2];
01485 
01486     v->hrd_rate = v->hrd_buffer = NULL;
01487 
01488     /* VLC tables */
01489     if (!done) {
01490         INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
01491                         ff_vc1_bfraction_bits, 1, 1,
01492                         ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
01493         INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
01494                         ff_vc1_norm2_bits, 1, 1,
01495                         ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
01496         INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
01497                         ff_vc1_norm6_bits, 1, 1,
01498                         ff_vc1_norm6_codes, 2, 2, 556);
01499         INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
01500                         ff_vc1_imode_bits, 1, 1,
01501                         ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
01502         for (i = 0; i < 3; i++) {
01503             ff_vc1_ttmb_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 0]];
01504             ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
01505             init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
01506                      ff_vc1_ttmb_bits[i], 1, 1,
01507                      ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01508             ff_vc1_ttblk_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 1]];
01509             ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
01510             init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
01511                      ff_vc1_ttblk_bits[i], 1, 1,
01512                      ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01513             ff_vc1_subblkpat_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 2]];
01514             ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
01515             init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
01516                      ff_vc1_subblkpat_bits[i], 1, 1,
01517                      ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01518         }
01519         for (i = 0; i < 4; i++) {
01520             ff_vc1_4mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 9]];
01521             ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
01522             init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
01523                      ff_vc1_4mv_block_pattern_bits[i], 1, 1,
01524                      ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01525             ff_vc1_cbpcy_p_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 10]];
01526             ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
01527             init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
01528                      ff_vc1_cbpcy_p_bits[i], 1, 1,
01529                      ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01530             ff_vc1_mv_diff_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 11]];
01531             ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
01532             init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
01533                      ff_vc1_mv_diff_bits[i], 1, 1,
01534                      ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01535         }
01536         for (i = 0; i < 8; i++) {
01537             ff_vc1_ac_coeff_table[i].table           = &vlc_table[vlc_offs[i * 2 + 21]];
01538             ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
01539             init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
01540                      &vc1_ac_tables[i][0][1], 8, 4,
01541                      &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
01542             /* initialize interlaced MVDATA tables (2-Ref) */
01543             ff_vc1_2ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 2 + 22]];
01544             ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
01545             init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
01546                      ff_vc1_2ref_mvdata_bits[i], 1, 1,
01547                      ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
01548         }
01549         for (i = 0; i < 4; i++) {
01550             /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
01551             ff_vc1_intfr_4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 37]];
01552             ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
01553             init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
01554                      ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
01555                      ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01556             /* initialize NON-4MV MBMODE VLC tables for the same */
01557             ff_vc1_intfr_non4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 38]];
01558             ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
01559             init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
01560                      ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
01561                      ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01562             /* initialize interlaced MVDATA tables (1-Ref) */
01563             ff_vc1_1ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 39]];
01564             ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
01565             init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
01566                      ff_vc1_1ref_mvdata_bits[i], 1, 1,
01567                      ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
01568         }
01569         for (i = 0; i < 4; i++) {
01570             /* Initialize 2MV Block pattern VLC tables */
01571             ff_vc1_2mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i + 49]];
01572             ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
01573             init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
01574                      ff_vc1_2mv_block_pattern_bits[i], 1, 1,
01575                      ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01576         }
01577         for (i = 0; i < 8; i++) {
01578             /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
01579             ff_vc1_icbpcy_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 53]];
01580             ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
01581             init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
01582                      ff_vc1_icbpcy_p_bits[i], 1, 1,
01583                      ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01584             /* Initialize interlaced field picture MBMODE VLC tables */
01585             ff_vc1_if_mmv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 54]];
01586             ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
01587             init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
01588                      ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
01589                      ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01590             ff_vc1_if_1mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 55]];
01591             ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
01592             init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
01593                      ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
01594                      ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01595         }
01596         done = 1;
01597     }
01598 
01599     /* Other defaults */
01600     v->pq      = -1;
01601     v->mvrange = 0; /* 7.1.1.18, p80 */
01602 
01603     return 0;
01604 }