alac: make block_size signed
[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 "internal.h"
31 #include "dsputil.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 //                   "0 for reserved RES_RTM_FLAG is forbidden\n");
399         av_log(avctx, AV_LOG_ERROR,
400                "Old WMV3 version detected, some frames may be decoded incorrectly\n");
401         //return -1;
402     }
403     //TODO: figure out what they mean (always 0x402F)
404     if (!v->res_fasttx)
405         skip_bits(gb, 16);
406     av_log(avctx, AV_LOG_DEBUG,
407            "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
408            "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
409            "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
410            "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
411            v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
412            v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
413            v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
414            v->dquant, v->quantizer_mode, avctx->max_b_frames);
415     return 0;
416 }
417
418 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
419 {
420     v->res_rtm_flag = 1;
421     v->level = get_bits(gb, 3);
422     if (v->level >= 5) {
423         av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
424     }
425     v->chromaformat = get_bits(gb, 2);
426     if (v->chromaformat != 1) {
427         av_log(v->s.avctx, AV_LOG_ERROR,
428                "Only 4:2:0 chroma format supported\n");
429         return -1;
430     }
431
432     // (fps-2)/4 (->30)
433     v->frmrtq_postproc       = get_bits(gb, 3); //common
434     // (bitrate-32kbps)/64kbps
435     v->bitrtq_postproc       = get_bits(gb, 5); //common
436     v->postprocflag          = get_bits1(gb);   //common
437
438     v->s.avctx->coded_width  = (get_bits(gb, 12) + 1) << 1;
439     v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
440     v->s.avctx->width        = v->s.avctx->coded_width;
441     v->s.avctx->height       = v->s.avctx->coded_height;
442     v->broadcast             = get_bits1(gb);
443     v->interlace             = get_bits1(gb);
444     v->tfcntrflag            = get_bits1(gb);
445     v->finterpflag           = get_bits1(gb);
446     skip_bits1(gb); // reserved
447
448     av_log(v->s.avctx, AV_LOG_DEBUG,
449            "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
450            "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
451            "TFCTRflag=%i, FINTERPflag=%i\n",
452            v->level, v->frmrtq_postproc, v->bitrtq_postproc,
453            v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
454            v->tfcntrflag, v->finterpflag);
455
456     v->psf = get_bits1(gb);
457     if (v->psf) { //PsF, 6.1.13
458         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
459         return -1;
460     }
461     v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
462     if (get_bits1(gb)) { //Display Info - decoding is not affected by it
463         int w, h, ar = 0;
464         av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
465         w = get_bits(gb, 14) + 1;
466         h = get_bits(gb, 14) + 1;
467         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
468         if (get_bits1(gb))
469             ar = get_bits(gb, 4);
470         if (ar && ar < 14) {
471             v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
472         } else if (ar == 15) {
473             w = get_bits(gb, 8) + 1;
474             h = get_bits(gb, 8) + 1;
475             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
476         } else {
477             av_reduce(&v->s.avctx->sample_aspect_ratio.num,
478                       &v->s.avctx->sample_aspect_ratio.den,
479                       v->s.avctx->height * w,
480                       v->s.avctx->width * h,
481                       1 << 30);
482         }
483         av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
484                v->s.avctx->sample_aspect_ratio.num,
485                v->s.avctx->sample_aspect_ratio.den);
486
487         if (get_bits1(gb)) { //framerate stuff
488             if (get_bits1(gb)) {
489                 v->s.avctx->time_base.num = 32;
490                 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
491             } else {
492                 int nr, dr;
493                 nr = get_bits(gb, 8);
494                 dr = get_bits(gb, 4);
495                 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
496                     v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
497                     v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
498                 }
499             }
500             if (v->broadcast) { // Pulldown may be present
501                 v->s.avctx->time_base.den  *= 2;
502                 v->s.avctx->ticks_per_frame = 2;
503             }
504         }
505
506         if (get_bits1(gb)) {
507             v->color_prim    = get_bits(gb, 8);
508             v->transfer_char = get_bits(gb, 8);
509             v->matrix_coef   = get_bits(gb, 8);
510         }
511     }
512
513     v->hrd_param_flag = get_bits1(gb);
514     if (v->hrd_param_flag) {
515         int i;
516         v->hrd_num_leaky_buckets = get_bits(gb, 5);
517         skip_bits(gb, 4); //bitrate exponent
518         skip_bits(gb, 4); //buffer size exponent
519         for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
520             skip_bits(gb, 16); //hrd_rate[n]
521             skip_bits(gb, 16); //hrd_buffer[n]
522         }
523     }
524     return 0;
525 }
526
527 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
528 {
529     int i;
530
531     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
532     v->broken_link    = get_bits1(gb);
533     v->closed_entry   = get_bits1(gb);
534     v->panscanflag    = get_bits1(gb);
535     v->refdist_flag   = get_bits1(gb);
536     v->s.loop_filter  = get_bits1(gb);
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         avctx->width  = avctx->coded_width  = (get_bits(gb, 12) + 1) << 1;
552         avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
553     }
554     if (v->extended_mv)
555         v->extended_dmv = get_bits1(gb);
556     if ((v->range_mapy_flag = get_bits1(gb))) {
557         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
558         v->range_mapy = get_bits(gb, 3);
559     }
560     if ((v->range_mapuv_flag = get_bits1(gb))) {
561         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
562         v->range_mapuv = get_bits(gb, 3);
563     }
564
565     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
566            "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
567            "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
568            "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
569            v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
570            v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
571
572     return 0;
573 }
574
575 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
576 {
577     int pqindex, lowquant, status;
578
579     if (v->finterpflag)
580         v->interpfrm = get_bits1(gb);
581     skip_bits(gb, 2); //framecnt unused
582     v->rangeredfrm = 0;
583     if (v->rangered)
584         v->rangeredfrm = get_bits1(gb);
585     v->s.pict_type = get_bits1(gb);
586     if (v->s.avctx->max_b_frames) {
587         if (!v->s.pict_type) {
588             if (get_bits1(gb))
589                 v->s.pict_type = AV_PICTURE_TYPE_I;
590             else
591                 v->s.pict_type = AV_PICTURE_TYPE_B;
592         } else
593             v->s.pict_type = AV_PICTURE_TYPE_P;
594     } else
595         v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
596
597     v->bi_type = 0;
598     if (v->s.pict_type == AV_PICTURE_TYPE_B) {
599         v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
600         v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
601         if (v->bfraction == 0) {
602             v->s.pict_type = AV_PICTURE_TYPE_BI;
603         }
604     }
605     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
606         skip_bits(gb, 7); // skip buffer fullness
607
608     if (v->parse_only)
609         return 0;
610
611     /* calculate RND */
612     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
613         v->rnd = 1;
614     if (v->s.pict_type == AV_PICTURE_TYPE_P)
615         v->rnd ^= 1;
616
617     /* Quantizer stuff */
618     pqindex = get_bits(gb, 5);
619     if (!pqindex)
620         return -1;
621     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
622         v->pq = ff_vc1_pquant_table[0][pqindex];
623     else
624         v->pq = ff_vc1_pquant_table[1][pqindex];
625
626     v->pquantizer = 1;
627     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
628         v->pquantizer = pqindex < 9;
629     if (v->quantizer_mode == QUANT_NON_UNIFORM)
630         v->pquantizer = 0;
631     v->pqindex = pqindex;
632     if (pqindex < 9)
633         v->halfpq = get_bits1(gb);
634     else
635         v->halfpq = 0;
636     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
637         v->pquantizer = get_bits1(gb);
638     v->dquantfrm = 0;
639     if (v->extended_mv == 1)
640         v->mvrange = get_unary(gb, 0, 3);
641     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
642     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
643     v->range_x = 1 << (v->k_x - 1);
644     v->range_y = 1 << (v->k_y - 1);
645     if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
646         v->respic = get_bits(gb, 2);
647
648     if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
649         v->x8_type = get_bits1(gb);
650     } else
651         v->x8_type = 0;
652 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
653 //        (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
654
655     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
656         v->use_ic = 0;
657
658     switch (v->s.pict_type) {
659     case AV_PICTURE_TYPE_P:
660         if (v->pq < 5)       v->tt_index = 0;
661         else if (v->pq < 13) v->tt_index = 1;
662         else                 v->tt_index = 2;
663
664         lowquant = (v->pq > 12) ? 0 : 1;
665         v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
666         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
667             int scale, shift, i;
668             v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
669             v->lumscale = get_bits(gb, 6);
670             v->lumshift = get_bits(gb, 6);
671             v->use_ic   = 1;
672             /* fill lookup tables for intensity compensation */
673             if (!v->lumscale) {
674                 scale = -64;
675                 shift = (255 - v->lumshift * 2) << 6;
676                 if (v->lumshift > 31)
677                     shift += 128 << 6;
678             } else {
679                 scale = v->lumscale + 32;
680                 if (v->lumshift > 31)
681                     shift = (v->lumshift - 64) << 6;
682                 else
683                     shift = v->lumshift << 6;
684             }
685             for (i = 0; i < 256; i++) {
686                 v->luty[i]  = av_clip_uint8((scale * i + shift + 32) >> 6);
687                 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
688             }
689         }
690         v->qs_last = v->s.quarter_sample;
691         if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
692             v->s.quarter_sample = 0;
693         else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
694             if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
695                 v->s.quarter_sample = 0;
696             else
697                 v->s.quarter_sample = 1;
698         } else
699             v->s.quarter_sample = 1;
700         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));
701
702         if ((v->mv_mode  == MV_PMODE_INTENSITY_COMP &&
703              v->mv_mode2 == MV_PMODE_MIXED_MV)      ||
704             v->mv_mode   == MV_PMODE_MIXED_MV) {
705             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
706             if (status < 0)
707                 return -1;
708             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
709                    "Imode: %i, Invert: %i\n", status>>1, status&1);
710         } else {
711             v->mv_type_is_raw = 0;
712             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
713         }
714         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
715         if (status < 0)
716             return -1;
717         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
718                "Imode: %i, Invert: %i\n", status>>1, status&1);
719
720         /* Hopefully this is correct for P frames */
721         v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
722         v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
723
724         if (v->dquant) {
725             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
726             vop_dquant_decoding(v);
727         }
728
729         v->ttfrm = 0; //FIXME Is that so ?
730         if (v->vstransform) {
731             v->ttmbf = get_bits1(gb);
732             if (v->ttmbf) {
733                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
734             }
735         } else {
736             v->ttmbf = 1;
737             v->ttfrm = TT_8X8;
738         }
739         break;
740     case AV_PICTURE_TYPE_B:
741         if (v->pq < 5)       v->tt_index = 0;
742         else if (v->pq < 13) v->tt_index = 1;
743         else                 v->tt_index = 2;
744
745         v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
746         v->qs_last          = v->s.quarter_sample;
747         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
748         v->s.mspel          = v->s.quarter_sample;
749
750         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
751         if (status < 0)
752             return -1;
753         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
754                "Imode: %i, Invert: %i\n", status>>1, status&1);
755         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
756         if (status < 0)
757             return -1;
758         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
759                "Imode: %i, Invert: %i\n", status>>1, status&1);
760
761         v->s.mv_table_index = get_bits(gb, 2);
762         v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
763
764         if (v->dquant) {
765             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
766             vop_dquant_decoding(v);
767         }
768
769         v->ttfrm = 0;
770         if (v->vstransform) {
771             v->ttmbf = get_bits1(gb);
772             if (v->ttmbf) {
773                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
774             }
775         } else {
776             v->ttmbf = 1;
777             v->ttfrm = TT_8X8;
778         }
779         break;
780     }
781
782     if (!v->x8_type) {
783         /* AC Syntax */
784         v->c_ac_table_index = decode012(gb);
785         if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
786             v->y_ac_table_index = decode012(gb);
787         }
788         /* DC Syntax */
789         v->s.dc_table_index = get_bits1(gb);
790     }
791
792     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
793         v->s.pict_type = AV_PICTURE_TYPE_B;
794         v->bi_type     = 1;
795     }
796     return 0;
797 }
798
799 /* fill lookup tables for intensity compensation */
800 #define INIT_LUT(lumscale, lumshift, luty, lutuv)   \
801     if (!lumscale) {                                \
802         scale = -64;                                \
803         shift = (255 - lumshift * 2) << 6;          \
804         if (lumshift > 31)                          \
805             shift += 128 << 6;                      \
806     } else {                                        \
807         scale = lumscale + 32;                      \
808         if (lumshift > 31)                          \
809             shift = (lumshift - 64) << 6;           \
810         else                                        \
811             shift = lumshift << 6;                  \
812     }                                               \
813     for (i = 0; i < 256; i++) {                     \
814         luty[i]  = av_clip_uint8((scale * i + shift + 32) >> 6);           \
815         lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);  \
816     }
817
818 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
819 {
820     int pqindex, lowquant;
821     int status;
822     int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
823     int scale, shift, i; /* for initializing LUT for intensity compensation */
824
825     v->p_frame_skipped = 0;
826     if (v->second_field) {
827         v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
828         if (v->fptype & 4)
829             v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
830         v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
831         if (!v->pic_header_flag)
832             goto parse_common_info;
833     }
834
835     v->field_mode = 0;
836     if (v->interlace) {
837         v->fcm = decode012(gb);
838         if (v->fcm) {
839             if (v->fcm == ILACE_FIELD)
840                 v->field_mode = 1;
841             if (!v->warn_interlaced++)
842                 av_log(v->s.avctx, AV_LOG_ERROR,
843                        "Interlaced frames/fields support is incomplete\n");
844         }
845     } else {
846         v->fcm = PROGRESSIVE;
847     }
848
849     if (v->field_mode) {
850         v->fptype = get_bits(gb, 3);
851         v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
852         if (v->fptype & 4) // B-picture
853             v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
854     } else {
855         switch (get_unary(gb, 0, 4)) {
856         case 0:
857             v->s.pict_type = AV_PICTURE_TYPE_P;
858             break;
859         case 1:
860             v->s.pict_type = AV_PICTURE_TYPE_B;
861             break;
862         case 2:
863             v->s.pict_type = AV_PICTURE_TYPE_I;
864             break;
865         case 3:
866             v->s.pict_type = AV_PICTURE_TYPE_BI;
867             break;
868         case 4:
869             v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
870             v->p_frame_skipped = 1;
871             break;
872         }
873     }
874     if (v->tfcntrflag)
875         skip_bits(gb, 8);
876     if (v->broadcast) {
877         if (!v->interlace || v->psf) {
878             v->rptfrm = get_bits(gb, 2);
879         } else {
880             v->tff = get_bits1(gb);
881             v->rff = get_bits1(gb);
882         }
883     }
884     if (v->panscanflag) {
885         av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
886         //...
887     }
888     if (v->p_frame_skipped) {
889         return 0;
890     }
891     v->rnd = get_bits1(gb);
892     if (v->interlace)
893         v->uvsamp = get_bits1(gb);
894     if (v->field_mode) {
895         if (!v->refdist_flag)
896             v->refdist = 0;
897         else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
898             v->refdist = get_bits(gb, 2);
899             if (v->refdist == 3)
900                 v->refdist += get_unary(gb, 0, 16);
901         }
902         if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
903             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
904             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
905             v->frfd = (v->bfraction * v->refdist) >> 8;
906             v->brfd = v->refdist - v->frfd - 1;
907             if (v->brfd < 0)
908                 v->brfd = 0;
909         }
910         goto parse_common_info;
911     }
912     if (v->fcm == PROGRESSIVE) {
913         if (v->finterpflag)
914             v->interpfrm = get_bits1(gb);
915         if (v->s.pict_type == AV_PICTURE_TYPE_B) {
916             v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
917             v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
918             if (v->bfraction == 0) {
919                 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
920             }
921         }
922     }
923
924     parse_common_info:
925     if (v->field_mode)
926         v->cur_field_type = !(v->tff ^ v->second_field);
927     pqindex = get_bits(gb, 5);
928     if (!pqindex)
929         return -1;
930     v->pqindex = pqindex;
931     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
932         v->pq = ff_vc1_pquant_table[0][pqindex];
933     else
934         v->pq = ff_vc1_pquant_table[1][pqindex];
935
936     v->pquantizer = 1;
937     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
938         v->pquantizer = pqindex < 9;
939     if (v->quantizer_mode == QUANT_NON_UNIFORM)
940         v->pquantizer = 0;
941     v->pqindex = pqindex;
942     if (pqindex < 9)
943         v->halfpq = get_bits1(gb);
944     else
945         v->halfpq = 0;
946     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
947         v->pquantizer = get_bits1(gb);
948     if (v->postprocflag)
949         v->postproc = get_bits(gb, 2);
950
951     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
952         v->use_ic = 0;
953
954     if (v->parse_only)
955         return 0;
956
957     switch (v->s.pict_type) {
958     case AV_PICTURE_TYPE_I:
959     case AV_PICTURE_TYPE_BI:
960         if (v->fcm == ILACE_FRAME) { //interlace frame picture
961             status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
962             if (status < 0)
963                 return -1;
964             av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
965                    "Imode: %i, Invert: %i\n", status>>1, status&1);
966         }
967         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
968         if (status < 0)
969             return -1;
970         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
971                "Imode: %i, Invert: %i\n", status>>1, status&1);
972         v->condover = CONDOVER_NONE;
973         if (v->overlap && v->pq <= 8) {
974             v->condover = decode012(gb);
975             if (v->condover == CONDOVER_SELECT) {
976                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
977                 if (status < 0)
978                     return -1;
979                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
980                        "Imode: %i, Invert: %i\n", status>>1, status&1);
981             }
982         }
983         break;
984     case AV_PICTURE_TYPE_P:
985         if (v->field_mode) {
986             v->numref = get_bits1(gb);
987             if (!v->numref) {
988                 v->reffield          = get_bits1(gb);
989                 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
990             }
991         }
992         if (v->extended_mv)
993             v->mvrange = get_unary(gb, 0, 3);
994         else
995             v->mvrange = 0;
996         if (v->interlace) {
997             if (v->extended_dmv)
998                 v->dmvrange = get_unary(gb, 0, 3);
999             else
1000                 v->dmvrange = 0;
1001             if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1002                 v->fourmvswitch = get_bits1(gb);
1003                 v->intcomp      = get_bits1(gb);
1004                 if (v->intcomp) {
1005                     v->lumscale = get_bits(gb, 6);
1006                     v->lumshift = get_bits(gb, 6);
1007                     INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1008                 }
1009                 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1010                 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1011                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1012                 mbmodetab = get_bits(gb, 2);
1013                 if (v->fourmvswitch)
1014                     v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1015                 else
1016                     v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1017                 imvtab         = get_bits(gb, 2);
1018                 v->imv_vlc     = &ff_vc1_1ref_mvdata_vlc[imvtab];
1019                 // interlaced p-picture cbpcy range is [1, 63]
1020                 icbptab        = get_bits(gb, 3);
1021                 v->cbpcy_vlc   = &ff_vc1_icbpcy_vlc[icbptab];
1022                 twomvbptab     = get_bits(gb, 2);
1023                 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1024                 if (v->fourmvswitch) {
1025                     fourmvbptab     = get_bits(gb, 2);
1026                     v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1027                 }
1028             }
1029         }
1030         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1031         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1032         v->range_x = 1 << (v->k_x - 1);
1033         v->range_y = 1 << (v->k_y - 1);
1034
1035         if (v->pq < 5)
1036             v->tt_index = 0;
1037         else if (v->pq < 13)
1038             v->tt_index = 1;
1039         else
1040             v->tt_index = 2;
1041         if (v->fcm != ILACE_FRAME) {
1042             int mvmode;
1043             mvmode     = get_unary(gb, 1, 4);
1044             lowquant   = (v->pq > 12) ? 0 : 1;
1045             v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1046             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1047                 int mvmode2;
1048                 mvmode2 = get_unary(gb, 1, 3);
1049                 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1050                 if (v->field_mode)
1051                     v->intcompfield = decode210(gb);
1052                 v->lumscale = get_bits(gb, 6);
1053                 v->lumshift = get_bits(gb, 6);
1054                 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1055                 if ((v->field_mode) && !v->intcompfield) {
1056                     v->lumscale2 = get_bits(gb, 6);
1057                     v->lumshift2 = get_bits(gb, 6);
1058                     INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1059                 }
1060                 v->use_ic = 1;
1061             }
1062             v->qs_last = v->s.quarter_sample;
1063             if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1064                 v->s.quarter_sample = 0;
1065             else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1066                 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1067                     v->s.quarter_sample = 0;
1068                 else
1069                     v->s.quarter_sample = 1;
1070             } else
1071                 v->s.quarter_sample = 1;
1072             v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1073                            || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1074                                && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1075         }
1076         if (v->fcm == PROGRESSIVE) { // progressive
1077             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1078                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1079                 || v->mv_mode == MV_PMODE_MIXED_MV) {
1080                 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1081                 if (status < 0)
1082                     return -1;
1083                 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1084                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1085             } else {
1086                 v->mv_type_is_raw = 0;
1087                 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1088             }
1089             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1090             if (status < 0)
1091                 return -1;
1092             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1093                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1094
1095             /* Hopefully this is correct for P frames */
1096             v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1097             v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1098         } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1099             v->qs_last          = v->s.quarter_sample;
1100             v->s.quarter_sample = 1;
1101             v->s.mspel          = 1;
1102         } else {    // field interlaced
1103             mbmodetab = get_bits(gb, 3);
1104             imvtab = get_bits(gb, 2 + v->numref);
1105             if (!v->numref)
1106                 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1107             else
1108                 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1109             icbptab = get_bits(gb, 3);
1110             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1111             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1112                 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1113                 fourmvbptab     = get_bits(gb, 2);
1114                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1115                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1116             } else {
1117                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1118             }
1119         }
1120         if (v->dquant) {
1121             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1122             vop_dquant_decoding(v);
1123         }
1124
1125         v->ttfrm = 0; //FIXME Is that so ?
1126         if (v->vstransform) {
1127             v->ttmbf = get_bits1(gb);
1128             if (v->ttmbf) {
1129                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1130             }
1131         } else {
1132             v->ttmbf = 1;
1133             v->ttfrm = TT_8X8;
1134         }
1135         break;
1136     case AV_PICTURE_TYPE_B:
1137         // TODO: implement interlaced frame B picture decoding
1138         if (v->fcm == ILACE_FRAME)
1139             return -1;
1140         if (v->extended_mv)
1141             v->mvrange = get_unary(gb, 0, 3);
1142         else
1143             v->mvrange = 0;
1144         v->k_x     = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1145         v->k_y     = v->mvrange + 8; //k_y can be 8 9 10 11
1146         v->range_x = 1 << (v->k_x - 1);
1147         v->range_y = 1 << (v->k_y - 1);
1148
1149         if (v->pq < 5)
1150             v->tt_index = 0;
1151         else if (v->pq < 13)
1152             v->tt_index = 1;
1153         else
1154             v->tt_index = 2;
1155
1156         if (v->field_mode) {
1157             int mvmode;
1158             if (v->extended_dmv)
1159                 v->dmvrange = get_unary(gb, 0, 3);
1160             mvmode = get_unary(gb, 1, 3);
1161             lowquant = (v->pq > 12) ? 0 : 1;
1162             v->mv_mode          = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1163             v->qs_last          = v->s.quarter_sample;
1164             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1165             v->s.mspel          = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1166             status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1167             if (status < 0)
1168                 return -1;
1169             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1170                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1171             mbmodetab = get_bits(gb, 3);
1172             if (v->mv_mode == MV_PMODE_MIXED_MV)
1173                 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1174             else
1175                 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1176             imvtab       = get_bits(gb, 3);
1177             v->imv_vlc   = &ff_vc1_2ref_mvdata_vlc[imvtab];
1178             icbptab      = get_bits(gb, 3);
1179             v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1180             if (v->mv_mode == MV_PMODE_MIXED_MV) {
1181                 fourmvbptab     = get_bits(gb, 2);
1182                 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1183             }
1184             v->numref = 1; // interlaced field B pictures are always 2-ref
1185         } else {
1186             v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1187             v->qs_last          = v->s.quarter_sample;
1188             v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1189             v->s.mspel          = v->s.quarter_sample;
1190             status              = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1191             if (status < 0)
1192                 return -1;
1193             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1194                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1195             status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1196             if (status < 0)
1197                 return -1;
1198             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1199                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1200             v->s.mv_table_index = get_bits(gb, 2);
1201             v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1202         }
1203
1204         if (v->dquant) {
1205             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1206             vop_dquant_decoding(v);
1207         }
1208
1209         v->ttfrm = 0;
1210         if (v->vstransform) {
1211             v->ttmbf = get_bits1(gb);
1212             if (v->ttmbf) {
1213                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1214             }
1215         } else {
1216             v->ttmbf = 1;
1217             v->ttfrm = TT_8X8;
1218         }
1219         break;
1220     }
1221
1222     /* AC Syntax */
1223     v->c_ac_table_index = decode012(gb);
1224     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1225         v->y_ac_table_index = decode012(gb);
1226     }
1227     /* DC Syntax */
1228     v->s.dc_table_index = get_bits1(gb);
1229     if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1230         && v->dquant) {
1231         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1232         vop_dquant_decoding(v);
1233     }
1234
1235     v->bi_type = 0;
1236     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1237         v->s.pict_type = AV_PICTURE_TYPE_B;
1238         v->bi_type = 1;
1239     }
1240     return 0;
1241 }
1242
1243 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1244 {
1245 { 0x0001,  2}, { 0x0005,  3}, { 0x000D,  4}, { 0x0012,  5}, { 0x000E,  6}, { 0x0015,  7},
1246 { 0x0013,  8}, { 0x003F,  8}, { 0x004B,  9}, { 0x011F,  9}, { 0x00B8, 10}, { 0x03E3, 10},
1247 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1248 { 0x3EAE, 14}, { 0x0000,  4}, { 0x0010,  5}, { 0x0008,  7}, { 0x0020,  8}, { 0x0029,  9},
1249 { 0x01F4,  9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1250 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003,  5}, { 0x0011,  7},
1251 { 0x00C4,  8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1252 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013,  5}, { 0x0078,  7},
1253 { 0x0069,  9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1254 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C,  6}, { 0x0024,  9}, { 0x0094, 11},
1255 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D,  6}, { 0x0053,  9}, { 0x01A0, 11},
1256 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013,  7}, { 0x007C,  9}, { 0x07C1, 11}, { 0x04AC, 14},
1257 { 0x001B,  7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079,  7}, { 0x03E1, 10},
1258 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021,  8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1259 { 0x0035,  8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5,  8}, { 0x0174, 11}, { 0x0785, 13},
1260 { 0x0048,  9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C,  9}, { 0x00FA, 10}, { 0x07D6, 11},
1261 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1262 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1263 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1264 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E,  4},
1265 { 0x0045,  7}, { 0x01F3,  9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019,  5},
1266 { 0x0028,  9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030,  6}, { 0x00A2, 10},
1267 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F,  6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1268 { 0x0044,  7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063,  7}, { 0x03C3, 12}, { 0x0015,  8},
1269 { 0x08F6, 12}, { 0x0017,  8}, { 0x0498, 13}, { 0x002C,  8}, { 0x07B2, 13}, { 0x002F,  8},
1270 { 0x1F54, 13}, { 0x008D,  8}, { 0x07BD, 13}, { 0x008E,  8}, { 0x1182, 13}, { 0x00FB,  8},
1271 { 0x050B, 13}, { 0x002D,  8}, { 0x07C0, 11}, { 0x0079,  9}, { 0x1F5F, 13}, { 0x007A,  9},
1272 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1273 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1274 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1275 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A,  9}
1276 },
1277 {
1278 { 0x0000,  3}, { 0x0003,  4}, { 0x000B,  5}, { 0x0014,  6}, { 0x003F,  6}, { 0x005D,  7},
1279 { 0x00A2,  8}, { 0x00AC,  9}, { 0x016E,  9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1280 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1281 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004,  4},
1282 { 0x001E,  5}, { 0x0042,  7}, { 0x00B6,  8}, { 0x0173,  9}, { 0x0395, 10}, { 0x072E, 11},
1283 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005,  5}, { 0x0040,  7},
1284 { 0x0049,  9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1285 { 0x0018,  5}, { 0x0025,  8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1286 { 0x139C, 15}, { 0x0029,  6}, { 0x004F,  9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1287 { 0x0038,  6}, { 0x010E,  9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058,  7},
1288 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023,  8}, { 0x02E3, 10}, { 0x04E5, 13},
1289 { 0x2E40, 14}, { 0x00A1,  8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083,  8}, { 0x013A, 11},
1290 { 0x1721, 13}, { 0x0044,  9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1291 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1292 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1293 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1294 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003,  3}, { 0x002A,  6}, { 0x00E4,  8},
1295 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1296 { 0x0009,  4}, { 0x0054,  8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D,  4},
1297 { 0x00AD,  9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011,  5}, { 0x016B,  9}, { 0x0B7F, 12},
1298 { 0x51A4, 15}, { 0x0019,  5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D,  5}, { 0x0394, 10},
1299 { 0x28D3, 14}, { 0x002B,  6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F,  6}, { 0x0247, 12},
1300 { 0x0010,  7}, { 0x0A35, 12}, { 0x003E,  6}, { 0x0B7A, 12}, { 0x0059,  7}, { 0x105E, 13},
1301 { 0x0026,  8}, { 0x09CF, 14}, { 0x0055,  8}, { 0x1CB5, 13}, { 0x0057,  8}, { 0x0E5B, 12},
1302 { 0x00A0,  8}, { 0x1468, 13}, { 0x0170,  9}, { 0x0090, 10}, { 0x01CE,  9}, { 0x021A, 10},
1303 { 0x0218, 10}, { 0x0168,  9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1304 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1305 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1306 { 0x0169,  9}
1307 },
1308 {
1309 { 0x0001,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x0016,  5}, { 0x0020,  6}, { 0x0018,  7},
1310 { 0x0008,  8}, { 0x009A,  8}, { 0x0056,  9}, { 0x013E,  9}, { 0x00F0, 10}, { 0x03A5, 10},
1311 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001,  4}, { 0x0011,  5},
1312 { 0x0002,  7}, { 0x000B,  8}, { 0x0012,  9}, { 0x01D6,  9}, { 0x027E, 10}, { 0x0191, 11},
1313 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004,  5}, { 0x0014,  7}, { 0x009E,  8},
1314 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017,  5},
1315 { 0x004E,  7}, { 0x005E,  9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1316 { 0x000E,  6}, { 0x00E1,  8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B,  6},
1317 { 0x001C,  9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006,  7}, { 0x007A,  9}, { 0x0190, 11},
1318 { 0x0137, 13}, { 0x001B,  7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071,  7}, { 0x00D7, 10},
1319 { 0x09BF, 12}, { 0x0007,  8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034,  8}, { 0x0265, 10},
1320 { 0x009F, 12}, { 0x00E0,  8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015,  9}, { 0x017D, 11},
1321 { 0x0EBB, 12}, { 0x0014,  9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1322 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1323 { 0x013A, 13}, { 0x000A,  4}, { 0x0042,  7}, { 0x01D3,  9}, { 0x04DD, 11}, { 0x0012,  5},
1324 { 0x00E8,  8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039,  6}, { 0x0264, 10}, { 0x0EBA, 12},
1325 { 0x0000,  7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F,  7}, { 0x04DE, 11}, { 0x0043,  7},
1326 { 0x04DC, 11}, { 0x0003,  8}, { 0x03CB, 12}, { 0x0006,  8}, { 0x099E, 12}, { 0x002A,  8},
1327 { 0x05F1, 13}, { 0x000F,  8}, { 0x09FE, 12}, { 0x0033,  8}, { 0x09FF, 12}, { 0x0098,  8},
1328 { 0x099F, 12}, { 0x00EA,  8}, { 0x013C, 13}, { 0x002E,  8}, { 0x0192, 11}, { 0x0136,  9},
1329 { 0x006A,  9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1330 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1331 { 0x0016,  7}
1332 },
1333 {
1334 { 0x0004,  3}, { 0x0014,  5}, { 0x0017,  7}, { 0x007F,  8}, { 0x0154,  9}, { 0x01F2, 10},
1335 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1336 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B,  4}, { 0x0037,  7}, { 0x0062,  9}, { 0x0007, 11},
1337 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007,  5},
1338 { 0x006D,  8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002,  6}, { 0x0061,  9},
1339 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A,  6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1340 { 0x001E,  6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006,  7}, { 0x0004, 11},
1341 { 0x02F8, 13}, { 0x0019,  7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057,  7}, { 0x0182, 11},
1342 { 0x2AA2, 14}, { 0x0004,  8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D,  8}, { 0x0164, 12},
1343 { 0x076D, 15}, { 0x0002,  9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD,  8}, { 0x0060, 12},
1344 { 0x0C67, 14}, { 0x001C,  9}, { 0x00EE, 13}, { 0x0003,  9}, { 0x02CF, 13}, { 0x00D9,  9},
1345 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1346 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1347 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003,  2}, { 0x0054,  7}, { 0x02AB, 10},
1348 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005,  4}, { 0x00F8,  9}, { 0x0AA9, 12}, { 0x005F, 15},
1349 { 0x0004,  4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004,  5}, { 0x0077, 11}, { 0x076C, 15},
1350 { 0x000E,  5}, { 0x000A, 12}, { 0x000C,  5}, { 0x0562, 11}, { 0x0004,  6}, { 0x031C, 12},
1351 { 0x0006,  6}, { 0x00C8, 13}, { 0x000D,  6}, { 0x01DA, 13}, { 0x0007,  6}, { 0x00C9, 13},
1352 { 0x0001,  7}, { 0x002E, 14}, { 0x0014,  7}, { 0x1596, 13}, { 0x000A,  7}, { 0x0AC2, 12},
1353 { 0x0016,  7}, { 0x015B, 14}, { 0x0015,  7}, { 0x015A, 14}, { 0x000F,  8}, { 0x005E, 15},
1354 { 0x007E,  8}, { 0x00AB,  8}, { 0x002D,  9}, { 0x00D8,  9}, { 0x000B,  9}, { 0x0014, 10},
1355 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E,  9},
1356 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1357 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1358 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D,  9}
1359 },
1360 {
1361 { 0x0002,  2}, { 0x0006,  3}, { 0x000F,  4}, { 0x000D,  5}, { 0x000C,  5}, { 0x0015,  6},
1362 { 0x0013,  6}, { 0x0012,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x001E,  8}, { 0x001D,  8},
1363 { 0x0025,  9}, { 0x0024,  9}, { 0x0023,  9}, { 0x0021,  9}, { 0x0021, 10}, { 0x0020, 10},
1364 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1365 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E,  4}, { 0x0014,  6}, { 0x0016,  7},
1366 { 0x001C,  8}, { 0x0020,  9}, { 0x001F,  9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1367 { 0x0055, 12}, { 0x000B,  5}, { 0x0015,  7}, { 0x001E,  9}, { 0x000C, 10}, { 0x0056, 12},
1368 { 0x0011,  6}, { 0x001B,  8}, { 0x001D,  9}, { 0x000B, 10}, { 0x0010,  6}, { 0x0022,  9},
1369 { 0x000A, 10}, { 0x000D,  6}, { 0x001C,  9}, { 0x0008, 10}, { 0x0012,  7}, { 0x001B,  9},
1370 { 0x0054, 12}, { 0x0014,  7}, { 0x001A,  9}, { 0x0057, 12}, { 0x0019,  8}, { 0x0009, 10},
1371 { 0x0018,  8}, { 0x0023, 11}, { 0x0017,  8}, { 0x0019,  9}, { 0x0018,  9}, { 0x0007, 10},
1372 { 0x0058, 12}, { 0x0007,  4}, { 0x000C,  6}, { 0x0016,  8}, { 0x0017,  9}, { 0x0006, 10},
1373 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F,  6}, { 0x0016,  9}, { 0x0005, 10},
1374 { 0x000E,  6}, { 0x0004, 10}, { 0x0011,  7}, { 0x0024, 11}, { 0x0010,  7}, { 0x0025, 11},
1375 { 0x0013,  7}, { 0x005A, 12}, { 0x0015,  8}, { 0x005B, 12}, { 0x0014,  8}, { 0x0013,  8},
1376 { 0x001A,  8}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9}, { 0x0012,  9}, { 0x0011,  9},
1377 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1378 { 0x0003,  7}
1379 },
1380 {
1381 { 0x0002,  2}, { 0x000F,  4}, { 0x0015,  6}, { 0x0017,  7}, { 0x001F,  8}, { 0x0025,  9},
1382 { 0x0024,  9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1383 { 0x0006,  3}, { 0x0014,  6}, { 0x001E,  8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1384 { 0x000E,  4}, { 0x001D,  8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D,  5}, { 0x0023,  9},
1385 { 0x000D, 10}, { 0x000C,  5}, { 0x0022,  9}, { 0x0052, 12}, { 0x000B,  5}, { 0x000C, 10},
1386 { 0x0053, 12}, { 0x0013,  6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012,  6}, { 0x000A, 10},
1387 { 0x0011,  6}, { 0x0009, 10}, { 0x0010,  6}, { 0x0008, 10}, { 0x0016,  7}, { 0x0055, 12},
1388 { 0x0015,  7}, { 0x0014,  7}, { 0x001C,  8}, { 0x001B,  8}, { 0x0021,  9}, { 0x0020,  9},
1389 { 0x001F,  9}, { 0x001E,  9}, { 0x001D,  9}, { 0x001C,  9}, { 0x001B,  9}, { 0x001A,  9},
1390 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007,  4}, { 0x0019,  9},
1391 { 0x0005, 11}, { 0x000F,  6}, { 0x0004, 11}, { 0x000E,  6}, { 0x000D,  6}, { 0x000C,  6},
1392 { 0x0013,  7}, { 0x0012,  7}, { 0x0011,  7}, { 0x0010,  7}, { 0x001A,  8}, { 0x0019,  8},
1393 { 0x0018,  8}, { 0x0017,  8}, { 0x0016,  8}, { 0x0015,  8}, { 0x0014,  8}, { 0x0013,  8},
1394 { 0x0018,  9}, { 0x0017,  9}, { 0x0016,  9}, { 0x0015,  9}, { 0x0014,  9}, { 0x0013,  9},
1395 { 0x0012,  9}, { 0x0011,  9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1396 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1397 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1398 { 0x0003,  7}
1399 },
1400 {
1401 { 0x0000,  2}, { 0x0003,  3}, { 0x000D,  4}, { 0x0005,  4}, { 0x001C,  5}, { 0x0016,  5},
1402 { 0x003F,  6}, { 0x003A,  6}, { 0x002E,  6}, { 0x0022,  6}, { 0x007B,  7}, { 0x0067,  7},
1403 { 0x005F,  7}, { 0x0047,  7}, { 0x0026,  7}, { 0x00EF,  8}, { 0x00CD,  8}, { 0x00C1,  8},
1404 { 0x00A9,  8}, { 0x004F,  8}, { 0x01F2,  9}, { 0x01DD,  9}, { 0x0199,  9}, { 0x0185,  9},
1405 { 0x015D,  9}, { 0x011B,  9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1406 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1407 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1408 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1409 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1410 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009,  4}, { 0x0010,  5}, { 0x0029,  6}, { 0x0062,  7},
1411 { 0x00F3,  8}, { 0x00AD,  8}, { 0x01E5,  9}, { 0x0179,  9}, { 0x009C,  9}, { 0x03B1, 10},
1412 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1413 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008,  5}, { 0x0063,  7},
1414 { 0x00AF,  8}, { 0x017B,  9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1415 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028,  6}, { 0x00C3,  8}, { 0x0151,  9}, { 0x02A1, 10},
1416 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065,  7}, { 0x01DA,  9}, { 0x02AF, 10},
1417 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025,  7}, { 0x0118,  9}, { 0x0646, 11},
1418 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9,  8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1419 { 0x0048,  8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180,  9}, { 0x0465, 11}, { 0x1905, 13},
1420 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1421 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1422 { 0x0078,  7}, { 0x0155,  9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA,  8}, { 0x07DC, 11},
1423 { 0x1907, 13}, { 0x00AC,  8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6,  9}, { 0x0AE2, 12},
1424 { 0x01DC,  9}, { 0x04ED, 12}, { 0x0184,  9}, { 0x1904, 13}, { 0x0156,  9}, { 0x09D9, 13},
1425 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1426 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1427 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1428 { 0x007A,  7}
1429 },
1430 {
1431 { 0x0002,  2}, { 0x0000,  3}, { 0x001E,  5}, { 0x0004,  5}, { 0x0012,  6}, { 0x0070,  7},
1432 { 0x001A,  7}, { 0x005F,  8}, { 0x0047,  8}, { 0x01D3,  9}, { 0x00B5,  9}, { 0x0057,  9},
1433 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1434 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1435 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1436 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003,  3}, { 0x000A,  5}, { 0x0077,  7}, { 0x00E5,  8},
1437 { 0x01D9,  9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1438 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C,  4}, { 0x007D,  7}, { 0x0044,  8},
1439 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B,  5},
1440 { 0x00E2,  8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007,  5},
1441 { 0x01D8,  9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035,  6}, { 0x03E1, 10},
1442 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C,  6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1443 { 0x0068,  7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020,  7}, { 0x0F90, 12}, { 0x7CF6, 15},
1444 { 0x00E8,  8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045,  8}, { 0x0B3A, 13}, { 0x01F1,  9},
1445 { 0x3B46, 14}, { 0x01A7,  9}, { 0x1676, 14}, { 0x0056,  9}, { 0x692A, 15}, { 0x038D, 10},
1446 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1447 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1448 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1449 { 0x055F, 13}, { 0x003F,  6}, { 0x006D,  9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013,  6},
1450 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B,  6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075,  7},
1451 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E,  7}, { 0x1F22, 13}, { 0x0021,  7}, { 0x054F, 13},
1452 { 0x0014,  7}, { 0x3A44, 14}, { 0x00E4,  8}, { 0x7CF7, 15}, { 0x005E,  8}, { 0x7185, 15},
1453 { 0x0037,  8}, { 0x2C73, 15}, { 0x01DB,  9}, { 0x59DD, 16}, { 0x01C7,  9}, { 0x692B, 15},
1454 { 0x01A6,  9}, { 0x58E5, 16}, { 0x00B4,  9}, { 0x1F3D0, 17}, { 0x00B0,  9}, { 0xB1C9, 17},
1455 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1456 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1457 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1458 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1459 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1460 { 0x0073,  7}
1461 }
1462 };
1463
1464 static const uint16_t vlc_offs[] = {
1465         0,   520,   552,   616,  1128,  1160,  1224,  1740,  1772,  1836,  1900,  2436,
1466      2986,  3050,  3610,  4154,  4218,  4746,  5326,  5390,  5902,  6554,  7658,  8342,
1467      9304,  9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1468     20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1469     27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1470     29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1471     31714, 31746, 31778, 32306, 32340, 32372
1472 };
1473
1474 /**
1475  * Init VC-1 specific tables and VC1Context members
1476  * @param v The VC1Context to initialize
1477  * @return Status
1478  */
1479 int ff_vc1_init_common(VC1Context *v)
1480 {
1481     static int done = 0;
1482     int i = 0;
1483     static VLC_TYPE vlc_table[32372][2];
1484
1485     v->hrd_rate = v->hrd_buffer = NULL;
1486
1487     /* VLC tables */
1488     if (!done) {
1489         INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1490                         ff_vc1_bfraction_bits, 1, 1,
1491                         ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1492         INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1493                         ff_vc1_norm2_bits, 1, 1,
1494                         ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1495         INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1496                         ff_vc1_norm6_bits, 1, 1,
1497                         ff_vc1_norm6_codes, 2, 2, 556);
1498         INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1499                         ff_vc1_imode_bits, 1, 1,
1500                         ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1501         for (i = 0; i < 3; i++) {
1502             ff_vc1_ttmb_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 0]];
1503             ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1504             init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1505                      ff_vc1_ttmb_bits[i], 1, 1,
1506                      ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1507             ff_vc1_ttblk_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 1]];
1508             ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1509             init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1510                      ff_vc1_ttblk_bits[i], 1, 1,
1511                      ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1512             ff_vc1_subblkpat_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 2]];
1513             ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1514             init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1515                      ff_vc1_subblkpat_bits[i], 1, 1,
1516                      ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1517         }
1518         for (i = 0; i < 4; i++) {
1519             ff_vc1_4mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 9]];
1520             ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1521             init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1522                      ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1523                      ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1524             ff_vc1_cbpcy_p_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 10]];
1525             ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1526             init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1527                      ff_vc1_cbpcy_p_bits[i], 1, 1,
1528                      ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1529             ff_vc1_mv_diff_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 11]];
1530             ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1531             init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1532                      ff_vc1_mv_diff_bits[i], 1, 1,
1533                      ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1534         }
1535         for (i = 0; i < 8; i++) {
1536             ff_vc1_ac_coeff_table[i].table           = &vlc_table[vlc_offs[i * 2 + 21]];
1537             ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1538             init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1539                      &vc1_ac_tables[i][0][1], 8, 4,
1540                      &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1541             /* initialize interlaced MVDATA tables (2-Ref) */
1542             ff_vc1_2ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 2 + 22]];
1543             ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1544             init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1545                      ff_vc1_2ref_mvdata_bits[i], 1, 1,
1546                      ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1547         }
1548         for (i = 0; i < 4; i++) {
1549             /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1550             ff_vc1_intfr_4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 37]];
1551             ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1552             init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1553                      ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1554                      ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1555             /* initialize NON-4MV MBMODE VLC tables for the same */
1556             ff_vc1_intfr_non4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 38]];
1557             ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1558             init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1559                      ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1560                      ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1561             /* initialize interlaced MVDATA tables (1-Ref) */
1562             ff_vc1_1ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 39]];
1563             ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1564             init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1565                      ff_vc1_1ref_mvdata_bits[i], 1, 1,
1566                      ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1567         }
1568         for (i = 0; i < 4; i++) {
1569             /* Initialize 2MV Block pattern VLC tables */
1570             ff_vc1_2mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i + 49]];
1571             ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1572             init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1573                      ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1574                      ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1575         }
1576         for (i = 0; i < 8; i++) {
1577             /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1578             ff_vc1_icbpcy_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 53]];
1579             ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1580             init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1581                      ff_vc1_icbpcy_p_bits[i], 1, 1,
1582                      ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1583             /* Initialize interlaced field picture MBMODE VLC tables */
1584             ff_vc1_if_mmv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 54]];
1585             ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1586             init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1587                      ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1588                      ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1589             ff_vc1_if_1mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 55]];
1590             ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1591             init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1592                      ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1593                      ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1594         }
1595         done = 1;
1596     }
1597
1598     /* Other defaults */
1599     v->pq      = -1;
1600     v->mvrange = 0; /* 7.1.1.18, p80 */
1601
1602     return 0;
1603 }