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