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