vc1: Fix intensity compensation performance regression
[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         av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
482                v->s.avctx->sample_aspect_ratio.num,
483                v->s.avctx->sample_aspect_ratio.den);
484
485         if (get_bits1(gb)) { //framerate stuff
486             if (get_bits1(gb)) {
487                 v->s.avctx->time_base.num = 32;
488                 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
489             } else {
490                 int nr, dr;
491                 nr = get_bits(gb, 8);
492                 dr = get_bits(gb, 4);
493                 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
494                     v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
495                     v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
496                 }
497             }
498             if (v->broadcast) { // Pulldown may be present
499                 v->s.avctx->time_base.den  *= 2;
500                 v->s.avctx->ticks_per_frame = 2;
501             }
502         }
503
504         if (get_bits1(gb)) {
505             v->color_prim    = get_bits(gb, 8);
506             v->transfer_char = get_bits(gb, 8);
507             v->matrix_coef   = get_bits(gb, 8);
508         }
509     }
510
511     v->hrd_param_flag = get_bits1(gb);
512     if (v->hrd_param_flag) {
513         int i;
514         v->hrd_num_leaky_buckets = get_bits(gb, 5);
515         skip_bits(gb, 4); //bitrate exponent
516         skip_bits(gb, 4); //buffer size exponent
517         for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
518             skip_bits(gb, 16); //hrd_rate[n]
519             skip_bits(gb, 16); //hrd_buffer[n]
520         }
521     }
522     return 0;
523 }
524
525 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
526 {
527     int i;
528
529     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
530     v->broken_link    = get_bits1(gb);
531     v->closed_entry   = get_bits1(gb);
532     v->panscanflag    = get_bits1(gb);
533     v->refdist_flag   = get_bits1(gb);
534     v->s.loop_filter  = get_bits1(gb);
535     v->fastuvmc       = get_bits1(gb);
536     v->extended_mv    = get_bits1(gb);
537     v->dquant         = get_bits(gb, 2);
538     v->vstransform    = get_bits1(gb);
539     v->overlap        = get_bits1(gb);
540     v->quantizer_mode = get_bits(gb, 2);
541
542     if (v->hrd_param_flag) {
543         for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
544             skip_bits(gb, 8); //hrd_full[n]
545         }
546     }
547
548     if (get_bits1(gb)) {
549         avctx->width  = avctx->coded_width  = (get_bits(gb, 12) + 1) << 1;
550         avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
551     }
552     if (v->extended_mv)
553         v->extended_dmv = get_bits1(gb);
554     if ((v->range_mapy_flag = get_bits1(gb))) {
555         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
556         v->range_mapy = get_bits(gb, 3);
557     }
558     if ((v->range_mapuv_flag = get_bits1(gb))) {
559         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
560         v->range_mapuv = get_bits(gb, 3);
561     }
562
563     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
564            "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
565            "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
566            "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
567            v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
568            v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
569
570     return 0;
571 }
572
573 /* fill lookup tables for intensity compensation */
574 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do {                 \
575         int scale, shift, i;                                                  \
576         if (!lumscale) {                                                      \
577             scale = -64;                                                      \
578             shift = (255 - lumshift * 2) << 6;                                \
579             if (lumshift > 31)                                                \
580                 shift += 128 << 6;                                            \
581         } else {                                                              \
582             scale = lumscale + 32;                                            \
583             if (lumshift > 31)                                                \
584                 shift = (lumshift - 64) << 6;                                 \
585             else                                                              \
586                 shift = lumshift << 6;                                        \
587         }                                                                     \
588         for (i = 0; i < 256; i++) {                                           \
589             int iy = chain ? luty[i]  : i;                                    \
590             int iu = chain ? lutuv[i] : i;                                    \
591             luty[i]  = av_clip_uint8((scale * iy + shift + 32) >> 6);         \
592             lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
593         }                                                                     \
594     } while(0)
595
596 static void rotate_luts(VC1Context *v)
597 {
598 #define ROTATE(DEF, L, N, C, A) do {                          \
599         if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
600             C = A;                                            \
601         } else {                                              \
602             DEF;                                              \
603             memcpy(&tmp, &L  , sizeof(tmp));                  \
604             memcpy(&L  , &N  , sizeof(tmp));                  \
605             memcpy(&N  , &tmp, sizeof(tmp));                  \
606             C = N;                                            \
607         }                                                     \
608     } while(0)
609
610     ROTATE(int tmp,             v->last_use_ic, v->next_use_ic, v->curr_use_ic, v->aux_use_ic);
611     ROTATE(uint8_t tmp[2][256], v->last_luty,   v->next_luty,   v->curr_luty,   v->aux_luty);
612     ROTATE(uint8_t tmp[2][256], v->last_lutuv,  v->next_lutuv,  v->curr_lutuv,  v->aux_lutuv);
613
614     INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
615     INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
616     v->curr_use_ic = 0;
617     if (v->curr_luty == v->next_luty) {
618         // If we just initialized next_lut, clear next_use_ic to match.
619         v->next_use_ic = 0;
620     }
621 }
622
623 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
624 {
625     int pqindex, lowquant, status;
626
627     if (v->finterpflag)
628         v->interpfrm = get_bits1(gb);
629     if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
630         v->respic   =
631         v->rangered =
632         v->multires = get_bits(gb, 2) == 1;
633     else
634         skip_bits(gb, 2); //framecnt unused
635     v->rangeredfrm = 0;
636     if (v->rangered)
637         v->rangeredfrm = get_bits1(gb);
638     v->s.pict_type = get_bits1(gb);
639     if (v->s.avctx->max_b_frames) {
640         if (!v->s.pict_type) {
641             if (get_bits1(gb))
642                 v->s.pict_type = AV_PICTURE_TYPE_I;
643             else
644                 v->s.pict_type = AV_PICTURE_TYPE_B;
645         } else
646             v->s.pict_type = AV_PICTURE_TYPE_P;
647     } else
648         v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
649
650     v->bi_type = 0;
651     if (v->s.pict_type == AV_PICTURE_TYPE_B) {
652         v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
653         v->bfraction           = ff_vc1_bfraction_lut[v->bfraction_lut_index];
654         if (v->bfraction == 0) {
655             v->s.pict_type = AV_PICTURE_TYPE_BI;
656         }
657     }
658     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
659         skip_bits(gb, 7); // skip buffer fullness
660
661     if (v->parse_only)
662         return 0;
663
664     /* calculate RND */
665     if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
666         v->rnd = 1;
667     if (v->s.pict_type == AV_PICTURE_TYPE_P)
668         v->rnd ^= 1;
669
670     /* Quantizer stuff */
671     pqindex = get_bits(gb, 5);
672     if (!pqindex)
673         return -1;
674     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
675         v->pq = ff_vc1_pquant_table[0][pqindex];
676     else
677         v->pq = ff_vc1_pquant_table[1][pqindex];
678
679     v->pquantizer = 1;
680     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
681         v->pquantizer = pqindex < 9;
682     if (v->quantizer_mode == QUANT_NON_UNIFORM)
683         v->pquantizer = 0;
684     v->pqindex = pqindex;
685     if (pqindex < 9)
686         v->halfpq = get_bits1(gb);
687     else
688         v->halfpq = 0;
689     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
690         v->pquantizer = get_bits1(gb);
691     v->dquantfrm = 0;
692     if (v->extended_mv == 1)
693         v->mvrange = get_unary(gb, 0, 3);
694     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
695     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
696     v->range_x = 1 << (v->k_x - 1);
697     v->range_y = 1 << (v->k_y - 1);
698     if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
699         v->respic = get_bits(gb, 2);
700
701     if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
702         v->x8_type = get_bits1(gb);
703     } else
704         v->x8_type = 0;
705     av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
706             (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
707             pqindex, v->pq, v->halfpq, v->rangeredfrm);
708
709     if (v->first_pic_header_flag)
710         rotate_luts(v);
711
712     switch (v->s.pict_type) {
713     case AV_PICTURE_TYPE_P:
714         if (v->pq < 5)       v->tt_index = 0;
715         else if (v->pq < 13) v->tt_index = 1;
716         else                 v->tt_index = 2;
717
718         lowquant = (v->pq > 12) ? 0 : 1;
719         v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
720         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
721             v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
722             v->lumscale = get_bits(gb, 6);
723             v->lumshift = get_bits(gb, 6);
724             v->last_use_ic = 1;
725             /* fill lookup tables for intensity compensation */
726             INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
727             INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
728         }
729         v->qs_last = v->s.quarter_sample;
730         if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
731             v->s.quarter_sample = 0;
732         else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
733             if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
734                 v->s.quarter_sample = 0;
735             else
736                 v->s.quarter_sample = 1;
737         } else
738             v->s.quarter_sample = 1;
739         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));
740
741         if ((v->mv_mode  == MV_PMODE_INTENSITY_COMP &&
742              v->mv_mode2 == MV_PMODE_MIXED_MV)      ||
743             v->mv_mode   == MV_PMODE_MIXED_MV) {
744             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
745             if (status < 0)
746                 return -1;
747             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
748                    "Imode: %i, Invert: %i\n", status>>1, status&1);
749         } else {
750             v->mv_type_is_raw = 0;
751             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
752         }
753         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
754         if (status < 0)
755             return -1;
756         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
757                "Imode: %i, Invert: %i\n", status>>1, status&1);
758
759         /* Hopefully this is correct for P frames */
760         v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
761         v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
762
763         if (v->dquant) {
764             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
765             vop_dquant_decoding(v);
766         }
767
768         v->ttfrm = 0; //FIXME Is that so ?
769         if (v->vstransform) {
770             v->ttmbf = get_bits1(gb);
771             if (v->ttmbf) {
772                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
773             }
774         } else {
775             v->ttmbf = 1;
776             v->ttfrm = TT_8X8;
777         }
778         break;
779     case AV_PICTURE_TYPE_B:
780         if (v->pq < 5)       v->tt_index = 0;
781         else if (v->pq < 13) v->tt_index = 1;
782         else                 v->tt_index = 2;
783
784         v->mv_mode          = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
785         v->qs_last          = v->s.quarter_sample;
786         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
787         v->s.mspel          = v->s.quarter_sample;
788
789         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
790         if (status < 0)
791             return -1;
792         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
793                "Imode: %i, Invert: %i\n", status>>1, status&1);
794         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
795         if (status < 0)
796             return -1;
797         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
798                "Imode: %i, Invert: %i\n", status>>1, status&1);
799
800         v->s.mv_table_index = get_bits(gb, 2);
801         v->cbpcy_vlc        = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
802
803         if (v->dquant) {
804             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
805             vop_dquant_decoding(v);
806         }
807
808         v->ttfrm = 0;
809         if (v->vstransform) {
810             v->ttmbf = get_bits1(gb);
811             if (v->ttmbf) {
812                 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
813             }
814         } else {
815             v->ttmbf = 1;
816             v->ttfrm = TT_8X8;
817         }
818         break;
819     }
820
821     if (!v->x8_type) {
822         /* AC Syntax */
823         v->c_ac_table_index = decode012(gb);
824         if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
825             v->y_ac_table_index = decode012(gb);
826         }
827         /* DC Syntax */
828         v->s.dc_table_index = get_bits1(gb);
829     }
830
831     if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
832         v->s.pict_type = AV_PICTURE_TYPE_B;
833         v->bi_type     = 1;
834     }
835     return 0;
836 }
837
838 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
839 {
840     int pqindex, lowquant;
841     int status;
842     int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
843     int field_mode, fcm;
844
845     v->p_frame_skipped = 0;
846     if (v->second_field) {
847         v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
848         if (v->fptype & 4)
849             v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
850         v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
851         if (!v->pic_header_flag)
852             goto parse_common_info;
853     }
854
855     field_mode = 0;
856     if (v->interlace) {
857         fcm = decode012(gb);
858         if (fcm) {
859             if (fcm == ILACE_FIELD)
860                 field_mode = 1;
861         }
862     } else {
863         fcm = PROGRESSIVE;
864     }
865     if (!v->first_pic_header_flag && v->field_mode != field_mode)
866         return AVERROR_INVALIDDATA;
867     v->field_mode = field_mode;
868     v->fcm = fcm;
869
870     if (v->field_mode) {
871         v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
872         v->fptype = get_bits(gb, 3);
873         v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
874         if (v->fptype & 4) // B-picture
875             v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
876     } else {
877         v->s.mb_height = v->s.height + 15 >> 4;
878         switch (get_unary(gb, 0, 4)) {
879         case 0:
880             v->s.pict_type = AV_PICTURE_TYPE_P;
881             break;
882         case 1:
883             v->s.pict_type = AV_PICTURE_TYPE_B;
884             break;
885         case 2:
886             v->s.pict_type = AV_PICTURE_TYPE_I;
887             break;
888         case 3:
889             v->s.pict_type = AV_PICTURE_TYPE_BI;
890             break;
891         case 4:
892             v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
893             v->p_frame_skipped = 1;
894             break;
895         }
896     }
897     if (v->tfcntrflag)
898         skip_bits(gb, 8);
899     if (v->broadcast) {
900         if (!v->interlace || v->psf) {
901             v->rptfrm = get_bits(gb, 2);
902         } else {
903             v->tff = get_bits1(gb);
904             v->rff = get_bits1(gb);
905         }
906     }
907     if (v->panscanflag) {
908         avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
909         //...
910     }
911     if (v->p_frame_skipped) {
912         return 0;
913     }
914     v->rnd = get_bits1(gb);
915     if (v->interlace)
916         v->uvsamp = get_bits1(gb);
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             return -1; // This codepath is still incomplete thus it is disabled
1192         }
1193         if (v->extended_mv)
1194             v->mvrange = get_unary(gb, 0, 3);
1195         else
1196             v->mvrange = 0;
1197         v->k_x     = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1198         v->k_y     = v->mvrange + 8; //k_y can be 8 9 10 11
1199         v->range_x = 1 << (v->k_x - 1);
1200         v->range_y = 1 << (v->k_y - 1);
1201
1202         if (v->pq < 5)
1203             v->tt_index = 0;
1204         else if (v->pq < 13)
1205             v->tt_index = 1;
1206         else
1207             v->tt_index = 2;
1208
1209         if (v->field_mode) {
1210             int mvmode;
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 }