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