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