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