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