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