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