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