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