FFmpeg
Loading...
Searching...
No Matches
vc1dec.c
Go to the documentation of this file.
1/*
2 * VC-1 and WMV3 decoder
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
27 */
28
29#include "config_components.h"
30
31#include "avcodec.h"
32#include "blockdsp.h"
33#include "codec_internal.h"
34#include "decode.h"
35#include "get_bits.h"
36#include "hwaccel_internal.h"
37#include "hwconfig.h"
38#include "mpeg_er.h"
39#include "mpegutils.h"
40#include "mpegvideo.h"
41#include "mpegvideodec.h"
42#include "msmpeg4_vc1_data.h"
43#include "profiles.h"
44#include "simple_idct.h"
45#include "vc1.h"
46#include "vc1data.h"
47#include "vc1_vlc_data.h"
49#include "libavutil/avassert.h"
50#include "libavutil/imgutils.h"
51#include "libavutil/mem.h"
52#include "libavutil/thread.h"
53
54
56#if CONFIG_VC1_DXVA2_HWACCEL
58#endif
59#if CONFIG_VC1_D3D11VA_HWACCEL
62#endif
63#if CONFIG_VC1_D3D12VA_HWACCEL
65#endif
66#if CONFIG_VC1_NVDEC_HWACCEL
68#endif
69#if CONFIG_VC1_VAAPI_HWACCEL
71#endif
72#if CONFIG_VC1_VDPAU_HWACCEL
74#endif
77};
78
79#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
80
81typedef struct SpriteData {
82 /**
83 * Transform coefficients for both sprites in 16.16 fixed point format,
84 * in the order they appear in the bitstream:
85 * x scale
86 * rotation 1 (unused)
87 * x offset
88 * rotation 2 (unused)
89 * y scale
90 * y offset
91 * alpha
92 */
93 int coefs[2][7];
94
95 int effect_type, effect_flag;
96 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
97 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
98} SpriteData;
99
100static inline int get_fp_val(GetBitContext* gb)
101{
102 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
103}
104
105static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
106{
107 c[1] = c[3] = 0;
108
109 switch (get_bits(gb, 2)) {
110 case 0:
111 c[0] = 1 << 16;
112 c[2] = get_fp_val(gb);
113 c[4] = 1 << 16;
114 break;
115 case 1:
116 c[0] = c[4] = get_fp_val(gb);
117 c[2] = get_fp_val(gb);
118 break;
119 case 2:
120 c[0] = get_fp_val(gb);
121 c[2] = get_fp_val(gb);
122 c[4] = get_fp_val(gb);
123 break;
124 case 3:
125 c[0] = get_fp_val(gb);
126 c[1] = get_fp_val(gb);
127 c[2] = get_fp_val(gb);
128 c[3] = get_fp_val(gb);
129 c[4] = get_fp_val(gb);
130 break;
131 }
132 c[5] = get_fp_val(gb);
133 if (get_bits1(gb))
134 c[6] = get_fp_val(gb);
135 else
136 c[6] = 1 << 16;
137}
138
139static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
140{
141 AVCodecContext *avctx = v->s.avctx;
142 int sprite, i;
143
144 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
145 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
146 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
147 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
148 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
149 for (i = 0; i < 7; i++)
150 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
151 sd->coefs[sprite][i] / (1<<16),
152 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
153 av_log(avctx, AV_LOG_DEBUG, "\n");
154 }
155
156 skip_bits(gb, 2);
157 if (sd->effect_type = get_bits_long(gb, 30)) {
158 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
159 case 7:
160 vc1_sprite_parse_transform(gb, sd->effect_params1);
161 break;
162 case 14:
163 vc1_sprite_parse_transform(gb, sd->effect_params1);
164 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
165 break;
166 default:
167 for (i = 0; i < sd->effect_pcount1; i++)
168 sd->effect_params1[i] = get_fp_val(gb);
169 }
170 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
171 // effect 13 is simple alpha blending and matches the opacity above
172 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
173 for (i = 0; i < sd->effect_pcount1; i++)
174 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
175 sd->effect_params1[i] / (1 << 16),
176 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
177 av_log(avctx, AV_LOG_DEBUG, "\n");
178 }
179
180 sd->effect_pcount2 = get_bits(gb, 16);
181 if (sd->effect_pcount2 > 10) {
182 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
183 return AVERROR_INVALIDDATA;
184 } else if (sd->effect_pcount2) {
185 i = -1;
186 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
187 while (++i < sd->effect_pcount2) {
188 sd->effect_params2[i] = get_fp_val(gb);
189 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
190 sd->effect_params2[i] / (1 << 16),
191 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
192 }
193 av_log(avctx, AV_LOG_DEBUG, "\n");
194 }
195 }
196 if (sd->effect_flag = get_bits1(gb))
197 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
198
199 if (get_bits_count(gb) >= gb->size_in_bits +
200 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
201 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
202 return AVERROR_INVALIDDATA;
203 }
204 if (get_bits_count(gb) < gb->size_in_bits - 8)
205 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
206
207 return 0;
208}
209
210static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
211{
212 int i, plane, row, sprite;
213 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
214 const uint8_t *src_h[2][2];
215 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
216 int ysub[2];
217 MpegEncContext *s = &v->s;
218
219 for (i = 0; i <= v->two_sprites; i++) {
220 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
221 xadv[i] = sd->coefs[i][0];
222 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
223 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
224
225 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
226 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
227 }
228 alpha = av_clip_uint16(sd->coefs[1][6]);
229
230 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
231 int width = v->output_width>>!!plane;
232
233 for (row = 0; row < v->output_height>>!!plane; row++) {
234 uint8_t *dst = v->sprite_output_frame->data[plane] +
235 v->sprite_output_frame->linesize[plane] * row;
236
237 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
238 const uint8_t *iplane = s->cur_pic.data[plane];
239 int iline = s->cur_pic.linesize[plane];
240 int ycoord = yoff[sprite] + yadv[sprite] * row;
241 int yline = ycoord >> 16;
242 int next_line;
243 ysub[sprite] = ycoord & 0xFFFF;
244 if (sprite) {
245 iplane = s->last_pic.data[plane];
246 iline = s->last_pic.linesize[plane];
247 }
248 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
249 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
250 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
251 if (ysub[sprite])
252 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
253 } else {
254 if (sr_cache[sprite][0] != yline) {
255 if (sr_cache[sprite][1] == yline) {
256 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
257 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
258 } else {
259 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
260 sr_cache[sprite][0] = yline;
261 }
262 }
263 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
264 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
265 iplane + next_line, xoff[sprite],
266 xadv[sprite], width);
267 sr_cache[sprite][1] = yline + 1;
268 }
269 src_h[sprite][0] = v->sr_rows[sprite][0];
270 src_h[sprite][1] = v->sr_rows[sprite][1];
271 }
272 }
273
274 if (!v->two_sprites) {
275 if (ysub[0]) {
276 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
277 } else {
278 memcpy(dst, src_h[0][0], width);
279 }
280 } else {
281 if (ysub[0] && ysub[1]) {
282 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
283 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
284 } else if (ysub[0]) {
285 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
286 src_h[1][0], alpha, width);
287 } else if (ysub[1]) {
288 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
289 src_h[0][0], (1<<16)-1-alpha, width);
290 } else {
291 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
292 }
293 }
294 }
295
296 if (!plane) {
297 for (i = 0; i <= v->two_sprites; i++) {
298 xoff[i] >>= 1;
299 yoff[i] >>= 1;
300 }
301 }
302
303 }
304}
305
306
307static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
308{
309 int ret;
310 MpegEncContext *s = &v->s;
311 AVCodecContext *avctx = s->avctx;
312 SpriteData sd;
313
314 memset(&sd, 0, sizeof(sd));
315
316 ret = vc1_parse_sprites(v, gb, &sd);
317 if (ret < 0)
318 return ret;
319
320 if (!s->cur_pic.data[0]) {
321 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
322 return AVERROR_UNKNOWN;
323 }
324
325 if (v->two_sprites && (!s->last_pic.ptr || !s->last_pic.data[0])) {
326 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
327 v->two_sprites = 0;
328 }
329
331 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
332 return ret;
333
334 vc1_draw_sprites(v, &sd);
335
336 return 0;
337}
338
339static av_cold void vc1_sprite_flush(AVCodecContext *avctx)
340{
341 VC1Context *v = avctx->priv_data;
342 MpegEncContext *s = &v->s;
343 MPVWorkPicture *f = &s->cur_pic;
344 int plane, i;
345
346 /* Windows Media Image codecs have a convergence interval of two keyframes.
347 Since we can't enforce it, clear to black the missing sprite. This is
348 wrong but it looks better than doing nothing. */
349
350 if (f->data[0])
351 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
352 for (i = 0; i < v->sprite_height>>!!plane; i++)
353 memset(f->data[plane] + i * f->linesize[plane],
354 plane ? 128 : 0, f->linesize[plane]);
355}
356
357#endif
358
360{
361 MpegEncContext *s = &v->s;
362 int i, ret;
363 int mb_height = FFALIGN(s->mb_height, 2);
364
365 /* Allocate mb bitplanes */
366 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
367 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
368 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
369 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
370 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
371 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
372 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
374 return AVERROR(ENOMEM);
375
376 v->n_allocated_blks = s->mb_width + 2;
377 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
378 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
379 if (!v->block || !v->cbp_base)
380 return AVERROR(ENOMEM);
381 v->cbp = v->cbp_base + 2 * s->mb_stride;
382 v->ttblk_base = av_mallocz(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
383 if (!v->ttblk_base)
384 return AVERROR(ENOMEM);
385 v->ttblk = v->ttblk_base + 2 * s->mb_stride;
386 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
387 if (!v->is_intra_base)
388 return AVERROR(ENOMEM);
389 v->is_intra = v->is_intra_base + 2 * s->mb_stride;
390 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
391 if (!v->luma_mv_base)
392 return AVERROR(ENOMEM);
393 v->luma_mv = v->luma_mv_base + 2 * s->mb_stride;
394
395 /* allocate block type info in that way so it could be used with s->block_index[] */
396 v->mb_type_base = av_mallocz(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
397 if (!v->mb_type_base)
398 return AVERROR(ENOMEM);
399 v->mb_type = v->mb_type_base + s->b8_stride + 1;
400
401 /* allocate memory to store block level MV info */
402 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1));
403 if (!v->blk_mv_type_base)
404 return AVERROR(ENOMEM);
405 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
406 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
407 if (!v->mv_f_base)
408 return AVERROR(ENOMEM);
409 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
410 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
411 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
412 if (!v->mv_f_next_base)
413 return AVERROR(ENOMEM);
414 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
415 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
416
417 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
418 for (i = 0; i < 4; i++)
419 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
420 return AVERROR(ENOMEM);
421 }
422
423 ret = ff_intrax8_common_init(s->avctx, &v->x8, v->blocks[0],
424 s->mb_width, s->mb_height);
425 if (ret < 0)
426 return ret;
427
428 return 0;
429}
430
432{
433 if (avctx->codec_id == AV_CODEC_ID_MSS2)
434 return AV_PIX_FMT_YUV420P;
435
436 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) {
439 return AV_PIX_FMT_GRAY8;
440 }
441
442 if (avctx->codec_id == AV_CODEC_ID_VC1IMAGE ||
444 return AV_PIX_FMT_YUV420P;
445
447}
448
449static void vc1_decode_reset(AVCodecContext *avctx);
450
452{
453 VC1Context *const v = avctx->priv_data;
454 MpegEncContext *const s = &v->s;
455 int ret;
456
457 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
458 if (ret < 0)
459 return ret;
460
461 ret = ff_mpv_decode_init(s, avctx);
462 if (ret < 0)
463 return ret;
464
465 avctx->pix_fmt = vc1_get_format(avctx);
466
468 if (ret < 0)
469 return ret;
470
472 if (ret < 0) {
473 vc1_decode_reset(avctx);
474 return ret;
475 }
476 return 0;
477}
478
480{
481 int i;
482 for (i = 0; i < 64; i++) {
483#define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
484 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
485 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
486 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
487 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
489 }
490 v->left_blk_sh = 0;
491 v->top_blk_sh = 3;
492}
493
494static av_cold void vc1_init_static(void)
495{
496 static VLCElem vlc_table[32372];
497 VLCInitState state = VLC_INIT_STATE(vlc_table);
498
500 vc1_norm2_bits, 1, 1,
501 vc1_norm2_codes, 1, 1, 0);
503 vc1_norm6_bits, 1, 1,
504 vc1_norm6_codes, 2, 2, 0);
506 vc1_imode_bits, 1, 1,
507 vc1_imode_codes, 1, 1, 0);
508 for (int i = 0; i < 3; i++) {
511 vc1_ttmb_bits[i], 1, 1,
512 vc1_ttmb_codes[i], 2, 2, 0);
515 vc1_ttblk_bits[i], 1, 1,
516 vc1_ttblk_codes[i], 1, 1, 0);
519 vc1_subblkpat_bits[i], 1, 1,
520 vc1_subblkpat_codes[i], 1, 1, 0);
521 }
522 for (int i = 0; i < 4; i++) {
529 vc1_cbpcy_p_bits[i], 1, 1,
530 vc1_cbpcy_p_codes[i], 2, 2, 0);
533 vc1_mv_diff_bits[i], 1, 1,
534 vc1_mv_diff_codes[i], 2, 2, 0);
535 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
539 vc1_intfr_4mv_mbmode_codes[i], 2, 2, 0);
540 /* initialize NON-4MV MBMODE VLC tables for the same */
545 /* initialize interlaced MVDATA tables (1-Ref) */
548 vc1_1ref_mvdata_bits[i], 1, 1,
549 vc1_1ref_mvdata_codes[i], 4, 4, 0);
550 /* Initialize 2MV Block pattern VLC tables */
555 }
556 for (int i = 0; i < 8; i++) {
559 &vc1_ac_tables[i][0][1], 8, 4,
560 &vc1_ac_tables[i][0][0], 8, 4, 0);
561 /* initialize interlaced MVDATA tables (2-Ref) */
564 vc1_2ref_mvdata_bits[i], 1, 1,
565 vc1_2ref_mvdata_codes[i], 4, 4, 0);
566 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
569 vc1_icbpcy_p_bits[i], 1, 1,
570 vc1_icbpcy_p_codes[i], 2, 2, 0);
571 /* Initialize interlaced field picture MBMODE VLC tables */
575 vc1_if_mmv_mbmode_codes[i], 1, 1, 0);
579 vc1_if_1mv_mbmode_codes[i], 1, 1, 0);
580 }
582}
583
584/**
585 * Init VC-1 specific tables and VC1Context members
586 * @param v The VC1Context to initialize
587 * @return Status
588 */
590{
591 static AVOnce init_static_once = AV_ONCE_INIT;
592 MpegEncContext *const s = &v->s;
593
594 /* defaults */
595 v->pq = -1;
596 v->mvrange = 0; /* 7.1.1.18, p80 */
597
598 s->avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
599 s->out_format = FMT_H263;
600
601 s->h263_pred = 1;
602 s->msmpeg4_version = MSMP4_VC1;
603
605
606 /* For error resilience */
607 ff_qpeldsp_init(&s->qdsp);
608
609 /* VLC tables */
610 ff_thread_once(&init_static_once, vc1_init_static);
611}
612
613/** Initialize a VC1/WMV3 decoder
614 * @todo TODO: Handle VC-1 IDUs (Transport level?)
615 * @todo TODO: Decipher remaining bits in extra_data
616 */
618{
619 VC1Context *v = avctx->priv_data;
620 MpegEncContext *s = &v->s;
621 GetBitContext gb;
622 int ret;
623
624 /* save the container output size for WMImage */
625 v->output_width = avctx->width;
626 v->output_height = avctx->height;
627
628 if (!avctx->extradata_size || !avctx->extradata)
629 return AVERROR_INVALIDDATA;
630 v->s.avctx = avctx;
631
633
634 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
635 int count = 0;
636
637 // looks like WMV3 has a sequence header stored in the extradata
638 // advanced sequence header may be before the first frame
639 // the last byte of the extradata is a version number, 1 for the
640 // samples we can decode
641
642 ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size);
643 if (ret < 0)
644 return ret;
645
646 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
647 return ret;
648
649 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) {
650 avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
652 }
653
654 count = avctx->extradata_size*8 - get_bits_count(&gb);
655 if (count > 0) {
656 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
657 count, get_bits_long(&gb, FFMIN(count, 32)));
658 } else if (count < 0) {
659 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
660 }
661 } else { // VC1/WVC1/WVP2
662 int seq_initialized, ep_initialized;
663
664 if (avctx->extradata_size < 16) {
665 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
666 return AVERROR_INVALIDDATA;
667 }
668
669 ret = ff_vc1_decode_extradata(avctx, v, &seq_initialized, &ep_initialized);
670 if (ret < 0)
671 return ret;
672 if (!seq_initialized || !ep_initialized) {
673 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
674 return AVERROR_INVALIDDATA;
675 }
677 }
678
679 avctx->profile = v->profile;
680 if (v->profile == PROFILE_ADVANCED)
681 avctx->level = v->level;
682
683 ff_blockdsp_init(&s->bdsp);
685
686 avctx->has_b_frames = !!avctx->max_b_frames;
687
688 if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
689 avctx->color_primaries = v->color_prim;
690 if (v->transfer_char == 1 || v->transfer_char == 7)
691 avctx->color_trc = v->transfer_char;
692 if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
693 avctx->colorspace = v->matrix_coef;
694
695 s->mb_width = (avctx->coded_width + 15) >> 4;
696 s->mb_height = (avctx->coded_height + 15) >> 4;
697
698 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
700 } else {
701 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
702 v->left_blk_sh = 3;
703 v->top_blk_sh = 0;
712 }
713
714 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
715 v->sprite_width = avctx->coded_width;
716 v->sprite_height = avctx->coded_height;
717
718 avctx->coded_width = avctx->width = v->output_width;
719 avctx->coded_height = avctx->height = v->output_height;
720
721 // prevent 16.16 overflows
722 if (v->sprite_width > 1 << 14 ||
723 v->sprite_height > 1 << 14 ||
724 v->output_width > 1 << 14 ||
725 v->output_height > 1 << 14) {
726 return AVERROR_INVALIDDATA;
727 }
728
729 if ((v->sprite_width&1) || (v->sprite_height&1)) {
730 avpriv_request_sample(avctx, "odd sprites support");
732 }
733 }
734 return 0;
735}
736
738{
739 VC1Context *v = avctx->priv_data;
740 int i;
741
743
744 for (i = 0; i < 4; i++)
745 av_freep(&v->sr_rows[i >> 1][i & 1]);
746 ff_mpv_common_end(&v->s);
747 memset(v->s.block_index, 0, sizeof(v->s.block_index));
756 av_freep(&v->mv_f_base);
758 av_freep(&v->block);
759 av_freep(&v->cbp_base);
760 av_freep(&v->ttblk_base);
761 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
764}
765
766/**
767 * Close a MSS2/VC1/WMV3 decoder
768 */
770{
771 vc1_decode_reset(avctx);
772 return ff_mpv_decode_close(avctx);
773}
774
775/** Decode a VC1/WMV3 frame
776 * @todo TODO: Handle VC-1 IDUs (Transport level?)
777 */
778static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
779 int *got_frame, AVPacket *avpkt)
780{
781 const uint8_t *buf = avpkt->data;
782 int buf_size = avpkt->size, n_slices = 0, i, ret;
783 VC1Context *v = avctx->priv_data;
784 MpegEncContext *s = &v->s;
785 uint8_t *buf2 = NULL;
786 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
787 int mb_height, n_slices1=-1;
788 struct {
789 uint8_t *buf;
790 GetBitContext gb;
791 int mby_start;
792 const uint8_t *rawbuf;
793 int raw_size;
794 } *slices = NULL, *tmp;
795 unsigned slices_allocated = 0;
796
797 v->second_field = 0;
798
799 if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
800 s->low_delay = 1;
801
802 if (buf_size >= 4 && AV_RB32(&buf[buf_size-4]) == VC1_CODE_ENDOFSEQ)
803 buf_size -= 4;
804
805 /* no supplementary picture */
806 if (buf_size == 0) {
807 /* special case for last picture */
808 if (s->low_delay == 0 && s->next_pic.ptr) {
809 if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0)
810 return ret;
811 ff_mpv_unref_picture(&s->next_pic);
812
813 *got_frame = 1;
814 }
815
816 return buf_size;
817 }
818
819 //for advanced profile we may need to parse and unescape data
820 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
821 int buf_size2 = 0;
822 size_t next_allocated = 0;
823 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
824 if (!buf2)
825 return AVERROR(ENOMEM);
826
827 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
828 const uint8_t *start, *end, *next;
829 int size;
830
831 next = buf;
832 for (start = buf, end = buf + buf_size; next < end; start = next) {
833 next = find_next_marker(start + 4, end);
834 size = next - start - 4;
835 if (size <= 0) continue;
836 switch (AV_RB32(start)) {
837 case VC1_CODE_FRAME:
838 buf_start = start;
839 buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
840 break;
841 case VC1_CODE_FIELD: {
842 int buf_size3;
843 buf_start_second_field = start;
844 av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);
845 tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;
846 if (!tmp) {
847 ret = AVERROR(ENOMEM);
848 goto err;
849 }
850 slices = tmp;
851 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
852 if (!slices[n_slices].buf) {
853 ret = AVERROR(ENOMEM);
854 goto err;
855 }
856 buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size,
857 slices[n_slices].buf);
858 ret = init_get_bits8(&slices[n_slices].gb, slices[n_slices].buf, buf_size3);
859 if (ret < 0) {
860 av_freep(&slices[n_slices].buf);
861 goto err;
862 }
863 slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
864 slices[n_slices].rawbuf = start;
865 slices[n_slices].raw_size = size + 4;
866 n_slices1 = n_slices - 1; // index of the last slice of the first field
867 n_slices++;
868 break;
869 }
870 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
871 buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
872 ret = init_get_bits8(&v->gb, buf2, buf_size2);
873 if (ret < 0)
874 goto err;
875 ff_vc1_decode_entry_point(avctx, v, &v->gb);
876 break;
877 case VC1_CODE_SLICE: {
878 int buf_size3;
879 av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);
880 tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;
881 if (!tmp) {
882 ret = AVERROR(ENOMEM);
883 goto err;
884 }
885 slices = tmp;
886 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
887 if (!slices[n_slices].buf) {
888 ret = AVERROR(ENOMEM);
889 goto err;
890 }
891 buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size,
892 slices[n_slices].buf);
893 ret = init_get_bits8(&slices[n_slices].gb, slices[n_slices].buf, buf_size3);
894 if (ret < 0) {
895 av_freep(&slices[n_slices].buf);
896 goto err;
897 }
898 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
899 slices[n_slices].rawbuf = start;
900 slices[n_slices].raw_size = size + 4;
901 n_slices++;
902 break;
903 }
904 }
905 }
906 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
907 const uint8_t *divider;
908 int buf_size3;
909
910 divider = find_next_marker(buf, buf + buf_size);
911 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
912 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
914 goto err;
915 } else { // found field marker, unescape second field
916 buf_start_second_field = divider;
917 av_size_mult(sizeof(*slices), n_slices+1, &next_allocated);
918 tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL;
919 if (!tmp) {
920 ret = AVERROR(ENOMEM);
921 goto err;
922 }
923 slices = tmp;
924 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
925 if (!slices[n_slices].buf) {
926 ret = AVERROR(ENOMEM);
927 goto err;
928 }
929 buf_size3 = v->vc1dsp.vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
930 ret = init_get_bits8(&slices[n_slices].gb, slices[n_slices].buf, buf_size3);
931 if (ret < 0) {
932 av_freep(&slices[n_slices].buf);
933 goto err;
934 }
935 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
936 slices[n_slices].rawbuf = divider;
937 slices[n_slices].raw_size = buf + buf_size - divider;
938 n_slices1 = n_slices - 1;
939 n_slices++;
940 }
941 buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, divider - buf, buf2);
942 } else {
943 buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2);
944 }
945 ret = init_get_bits8(&v->gb, buf2, buf_size2);
946 if (ret < 0)
947 goto err;
948 } else{
949 ret = init_get_bits8(&v->gb, buf, buf_size);
950 if (ret < 0)
951 goto err;
952 }
953
954 if (v->res_sprite) {
955 v->new_sprite = !get_bits1(&v->gb);
956 v->two_sprites = get_bits1(&v->gb);
957 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
958 we're using the sprite compositor. These are intentionally kept separate
959 so you can get the raw sprites by using the wmv3 decoder for WMVP or
960 the vc1 one for WVP2 */
961 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
962 if (v->new_sprite) {
963 // switch AVCodecContext parameters to those of the sprites
964 avctx->width = avctx->coded_width = v->sprite_width;
965 avctx->height = avctx->coded_height = v->sprite_height;
966 } else {
967 goto image;
968 }
969 }
970 }
971
972 if (s->context_initialized &&
973 (s->width != avctx->coded_width ||
974 s->height != avctx->coded_height)) {
975 vc1_decode_reset(avctx);
976 }
977
978 if (!s->context_initialized) {
979 ret = ff_vc1_decode_init(avctx);
980 if (ret < 0)
981 goto err;
982
983 s->low_delay = !avctx->has_b_frames || v->res_sprite;
984
985 if (v->profile == PROFILE_ADVANCED) {
986 if(avctx->coded_width<=1 || avctx->coded_height<=1) {
988 goto err;
989 }
990 s->h_edge_pos = avctx->coded_width;
991 s->v_edge_pos = avctx->coded_height;
992 }
993 }
994
995 // do parse frame header
996 v->pic_header_flag = 0;
998 if (v->profile < PROFILE_ADVANCED) {
999 if ((ret = ff_vc1_parse_frame_header(v, &v->gb)) < 0) {
1000 goto err;
1001 }
1002 } else {
1003 if ((ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
1004 goto err;
1005 }
1006 }
1007 v->first_pic_header_flag = 0;
1008
1009 if (avctx->debug & FF_DEBUG_PICT_INFO)
1010 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
1011
1012 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
1013 && s->pict_type != AV_PICTURE_TYPE_I) {
1014 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
1016 goto err;
1017 }
1018 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
1019 && v->field_mode) {
1020 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
1022 goto err;
1023 }
1024 if ((s->mb_height >> v->field_mode) == 0) {
1025 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
1027 goto err;
1028 }
1029
1030 /* skip B-frames if we don't have reference frames */
1031 if (!s->last_pic.ptr && s->pict_type == AV_PICTURE_TYPE_B) {
1032 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
1033 goto end;
1034 }
1035 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
1036 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
1037 avctx->skip_frame >= AVDISCARD_ALL) {
1038 goto end;
1039 }
1040
1041 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
1042 goto err;
1043 }
1044
1050
1051 // process pulldown flags
1052 s->cur_pic.ptr->f->repeat_pict = 0;
1053 // Pulldown flags are only valid when 'broadcast' has been set.
1054 if (v->rff) {
1055 // repeat field
1056 s->cur_pic.ptr->f->repeat_pict = 1;
1057 } else if (v->rptfrm) {
1058 // repeat frames
1059 s->cur_pic.ptr->f->repeat_pict = v->rptfrm * 2;
1060 }
1061
1062 if (avctx->hwaccel) {
1063 const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1064 s->mb_y = 0;
1065 if (v->field_mode && buf_start_second_field) {
1066 // decode first field
1067 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
1068 ret = hwaccel->start_frame(avctx, avpkt->buf, buf_start,
1069 buf_start_second_field - buf_start);
1070 if (ret < 0)
1071 goto err;
1072
1073 if (n_slices1 == -1) {
1074 // no slices, decode the field as-is
1075 ret = hwaccel->decode_slice(avctx, buf_start,
1076 buf_start_second_field - buf_start);
1077 if (ret < 0)
1078 goto err;
1079 } else {
1080 ret = hwaccel->decode_slice(avctx, buf_start,
1081 slices[0].rawbuf - buf_start);
1082 if (ret < 0)
1083 goto err;
1084
1085 for (i = 0 ; i < n_slices1 + 1; i++) {
1086 v->gb = slices[i].gb;
1087 s->mb_y = slices[i].mby_start;
1088
1089 v->pic_header_flag = get_bits1(&v->gb);
1090 if (v->pic_header_flag) {
1091 if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
1092 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1094 if (avctx->err_recognition & AV_EF_EXPLODE)
1095 goto err;
1096 continue;
1097 }
1098 }
1099
1100 ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,
1101 slices[i].raw_size);
1102 if (ret < 0)
1103 goto err;
1104 }
1105 }
1106
1107 if ((ret = hwaccel->end_frame(avctx)) < 0)
1108 goto err;
1109
1110 // decode second field
1111 v->gb = slices[n_slices1 + 1].gb;
1112 s->mb_y = slices[n_slices1 + 1].mby_start;
1113 s->picture_structure = PICT_TOP_FIELD + v->tff;
1114 v->second_field = 1;
1115 v->pic_header_flag = 0;
1116 if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
1117 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
1119 goto err;
1120 }
1121 v->s.cur_pic.ptr->f->pict_type = v->s.pict_type;
1122
1123 ret = hwaccel->start_frame(avctx, avpkt->buf, buf_start_second_field,
1124 (buf + buf_size) - buf_start_second_field);
1125 if (ret < 0)
1126 goto err;
1127
1128 if (n_slices - n_slices1 == 2) {
1129 // no slices, decode the field as-is
1130 ret = hwaccel->decode_slice(avctx, buf_start_second_field,
1131 (buf + buf_size) - buf_start_second_field);
1132 if (ret < 0)
1133 goto err;
1134 } else {
1135 ret = hwaccel->decode_slice(avctx, buf_start_second_field,
1136 slices[n_slices1 + 2].rawbuf - buf_start_second_field);
1137 if (ret < 0)
1138 goto err;
1139
1140 for (i = n_slices1 + 2; i < n_slices; i++) {
1141 v->gb = slices[i].gb;
1142 s->mb_y = slices[i].mby_start;
1143
1144 v->pic_header_flag = get_bits1(&v->gb);
1145 if (v->pic_header_flag) {
1146 if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
1147 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1149 if (avctx->err_recognition & AV_EF_EXPLODE)
1150 goto err;
1151 continue;
1152 }
1153 }
1154
1155 ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,
1156 slices[i].raw_size);
1157 if (ret < 0)
1158 goto err;
1159 }
1160 }
1161
1162 if ((ret = hwaccel->end_frame(avctx)) < 0)
1163 goto err;
1164 } else {
1165 s->picture_structure = PICT_FRAME;
1166 ret = hwaccel->start_frame(avctx, avpkt->buf, buf_start,
1167 (buf + buf_size) - buf_start);
1168 if (ret < 0)
1169 goto err;
1170
1171 if (n_slices == 0) {
1172 // no slices, decode the frame as-is
1173 ret = hwaccel->decode_slice(avctx, buf_start,
1174 (buf + buf_size) - buf_start);
1175 if (ret < 0)
1176 goto err;
1177 } else {
1178 // decode the frame part as the first slice
1179 ret = hwaccel->decode_slice(avctx, buf_start,
1180 slices[0].rawbuf - buf_start);
1181 if (ret < 0)
1182 goto err;
1183
1184 // and process the slices as additional slices afterwards
1185 for (i = 0 ; i < n_slices; i++) {
1186 v->gb = slices[i].gb;
1187 s->mb_y = slices[i].mby_start;
1188
1189 v->pic_header_flag = get_bits1(&v->gb);
1190 if (v->pic_header_flag) {
1191 if (ff_vc1_parse_frame_header_adv(v, &v->gb) < 0) {
1192 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1194 if (avctx->err_recognition & AV_EF_EXPLODE)
1195 goto err;
1196 continue;
1197 }
1198 }
1199
1200 ret = hwaccel->decode_slice(avctx, slices[i].rawbuf,
1201 slices[i].raw_size);
1202 if (ret < 0)
1203 goto err;
1204 }
1205 }
1206 if ((ret = hwaccel->end_frame(avctx)) < 0)
1207 goto err;
1208 }
1209 } else {
1210 int header_ret = 0;
1211
1213
1214 v->end_mb_x = s->mb_width;
1215 if (v->field_mode) {
1216 s->cur_pic.linesize[0] <<= 1;
1217 s->cur_pic.linesize[1] <<= 1;
1218 s->cur_pic.linesize[2] <<= 1;
1219 s->linesize <<= 1;
1220 s->uvlinesize <<= 1;
1221 }
1222 mb_height = s->mb_height >> v->field_mode;
1223
1224 av_assert0 (mb_height > 0);
1225
1226 for (i = 0; i <= n_slices; i++) {
1227 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1228 if (v->field_mode <= 0) {
1229 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1230 "picture boundary (%d >= %d)\n", i,
1231 slices[i - 1].mby_start, mb_height);
1232 continue;
1233 }
1234 v->second_field = 1;
1235 av_assert0((s->mb_height & 1) == 0);
1236 v->blocks_off = s->b8_stride * (s->mb_height&~1);
1237 v->mb_off = s->mb_stride * s->mb_height >> 1;
1238 } else {
1239 v->second_field = 0;
1240 v->blocks_off = 0;
1241 v->mb_off = 0;
1242 }
1243 if (i) {
1244 v->pic_header_flag = 0;
1245 if (v->field_mode && i == n_slices1 + 2) {
1246 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
1247 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1249 if (avctx->err_recognition & AV_EF_EXPLODE)
1250 goto err;
1251 continue;
1252 }
1253 } else if (get_bits1(&v->gb)) {
1254 v->pic_header_flag = 1;
1255 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &v->gb)) < 0) {
1256 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1258 if (avctx->err_recognition & AV_EF_EXPLODE)
1259 goto err;
1260 continue;
1261 }
1262 }
1263 }
1264 if (header_ret < 0)
1265 continue;
1266 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1267 if (!v->field_mode || v->second_field)
1268 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1269 else {
1270 if (i >= n_slices) {
1271 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1272 continue;
1273 }
1274 s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1275 }
1276 if (s->end_mb_y <= s->start_mb_y) {
1277 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1278 continue;
1279 }
1280 if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1281 (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1282 !v->cbpcy_vlc) {
1283 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1284 continue;
1285 }
1287 if (i != n_slices) {
1288 v->gb = slices[i].gb;
1289 }
1290 }
1291 if (v->field_mode) {
1292 v->second_field = 0;
1293 s->cur_pic.linesize[0] >>= 1;
1294 s->cur_pic.linesize[1] >>= 1;
1295 s->cur_pic.linesize[2] >>= 1;
1296 s->linesize >>= 1;
1297 s->uvlinesize >>= 1;
1299 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1300 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1301 }
1302 }
1303 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1304 get_bits_count(&v->gb), v->gb.size_in_bits);
1305// if (get_bits_count(&v->gb) > buf_size * 8)
1306// return -1;
1307 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1309 goto err;
1310 }
1311 if ( !v->field_mode
1312 && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE
1313 && avctx->codec_id != AV_CODEC_ID_VC1IMAGE)
1314 ff_er_frame_end(&s->er, NULL);
1315 }
1316
1318
1319 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1320image:
1321 avctx->width = avctx->coded_width = v->output_width;
1322 avctx->height = avctx->coded_height = v->output_height;
1323 if (avctx->skip_frame >= AVDISCARD_NONREF)
1324 goto end;
1325 if (!v->sprite_output_frame &&
1327 ret = AVERROR(ENOMEM);
1328 goto err;
1329 }
1330#if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1331 if ((ret = vc1_decode_sprites(v, &v->gb)) < 0)
1332 goto err;
1333#endif
1334 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1335 goto err;
1336 *got_frame = 1;
1337 } else {
1338 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1339 if ((ret = av_frame_ref(pict, s->cur_pic.ptr->f)) < 0)
1340 goto err;
1341 ff_print_debug_info(s, s->cur_pic.ptr, pict);
1342 *got_frame = 1;
1343 } else if (s->last_pic.ptr) {
1344 if ((ret = av_frame_ref(pict, s->last_pic.ptr->f)) < 0)
1345 goto err;
1346 ff_print_debug_info(s, s->last_pic.ptr, pict);
1347 *got_frame = 1;
1348 }
1349 }
1350
1351end:
1352 ret = buf_size;
1353err:
1354 av_free(buf2);
1355 for (i = 0; i < n_slices; i++)
1356 av_free(slices[i].buf);
1357 av_free(slices);
1358 return ret;
1359}
1360
1361
1363 .p.name = "vc1",
1364 CODEC_LONG_NAME("SMPTE VC-1"),
1365 .p.type = AVMEDIA_TYPE_VIDEO,
1366 .p.id = AV_CODEC_ID_VC1,
1367 .priv_data_size = sizeof(VC1Context),
1371 .flush = ff_mpeg_flush,
1372 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1373 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1374#if CONFIG_VC1_DXVA2_HWACCEL
1375 HWACCEL_DXVA2(vc1),
1376#endif
1377#if CONFIG_VC1_D3D11VA_HWACCEL
1378 HWACCEL_D3D11VA(vc1),
1379#endif
1380#if CONFIG_VC1_D3D11VA2_HWACCEL
1381 HWACCEL_D3D11VA2(vc1),
1382#endif
1383#if CONFIG_VC1_D3D12VA_HWACCEL
1384 HWACCEL_D3D12VA(vc1),
1385#endif
1386#if CONFIG_VC1_NVDEC_HWACCEL
1387 HWACCEL_NVDEC(vc1),
1388#endif
1389#if CONFIG_VC1_NVDEC_CUARRAY_HWACCEL
1391#endif
1392#if CONFIG_VC1_VAAPI_HWACCEL
1393 HWACCEL_VAAPI(vc1),
1394#endif
1395#if CONFIG_VC1_VDPAU_HWACCEL
1396 HWACCEL_VDPAU(vc1),
1397#endif
1398 NULL
1399 },
1401};
1402
1403#if CONFIG_WMV3_DECODER
1404const FFCodec ff_wmv3_decoder = {
1405 .p.name = "wmv3",
1406 CODEC_LONG_NAME("Windows Media Video 9"),
1407 .p.type = AVMEDIA_TYPE_VIDEO,
1408 .p.id = AV_CODEC_ID_WMV3,
1409 .priv_data_size = sizeof(VC1Context),
1413 .flush = ff_mpeg_flush,
1414 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1415 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1416#if CONFIG_WMV3_DXVA2_HWACCEL
1417 HWACCEL_DXVA2(wmv3),
1418#endif
1419#if CONFIG_WMV3_D3D11VA_HWACCEL
1420 HWACCEL_D3D11VA(wmv3),
1421#endif
1422#if CONFIG_WMV3_D3D11VA2_HWACCEL
1423 HWACCEL_D3D11VA2(wmv3),
1424#endif
1425#if CONFIG_WMV3_D3D12VA_HWACCEL
1426 HWACCEL_D3D12VA(wmv3),
1427#endif
1428#if CONFIG_WMV3_NVDEC_HWACCEL
1429 HWACCEL_NVDEC(wmv3),
1430#endif
1431#if CONFIG_WMV3_NVDEC_CUARRAY_HWACCEL
1433#endif
1434#if CONFIG_WMV3_VAAPI_HWACCEL
1435 HWACCEL_VAAPI(wmv3),
1436#endif
1437#if CONFIG_WMV3_VDPAU_HWACCEL
1438 HWACCEL_VDPAU(wmv3),
1439#endif
1440 NULL
1441 },
1443};
1444#endif
1445
1446#if CONFIG_WMV3IMAGE_DECODER
1448 .p.name = "wmv3image",
1449 CODEC_LONG_NAME("Windows Media Video 9 Image"),
1450 .p.type = AVMEDIA_TYPE_VIDEO,
1451 .p.id = AV_CODEC_ID_WMV3IMAGE,
1452 .priv_data_size = sizeof(VC1Context),
1456 .p.capabilities = AV_CODEC_CAP_DR1,
1457 .flush = vc1_sprite_flush,
1458};
1459#endif
1460
1461#if CONFIG_VC1IMAGE_DECODER
1463 .p.name = "vc1image",
1464 CODEC_LONG_NAME("Windows Media Video 9 Image v2"),
1465 .p.type = AVMEDIA_TYPE_VIDEO,
1466 .p.id = AV_CODEC_ID_VC1IMAGE,
1467 .priv_data_size = sizeof(VC1Context),
1471 .p.capabilities = AV_CODEC_CAP_DR1,
1472 .flush = vc1_sprite_flush,
1473};
1474#endif
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:97
const FFCodec ff_vc1_decoder
Definition vc1dec.c:1362
const FFCodec ff_vc1image_decoder
const FFCodec ff_wmv3_decoder
const FFCodec ff_wmv3image_decoder
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
Libavcodec external API header.
#define FF_DEBUG_PICT_INFO
Definition avcodec.h:1399
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define f(width, name)
Definition cbs_vp8.c:236
#define s(width, name)
Definition cbs_vp9.c:198
#define FF_CODEC_DECODE_CB(func)
#define CODEC_LONG_NAME(str)
#define av_clip
Definition common.h:100
#define av_clip_uint16
Definition common.h:112
#define NULL
Definition coverity.c:32
#define abs(x)
#define IS_MARKER(state)
Definition dca_parser.c:52
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition decode.c:1814
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition decode.c:1248
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition defs.h:51
int(* init)(AVBSFContext *ctx)
Definition dts2pts.c:613
void ff_er_frame_end(ERContext *s, int *decode_error_flags)
Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...
static const char * hwaccel
Definition ffplay.c:406
int ret
Definition ffplay.c:391
bitstream reader API header.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition get_bits.h:424
static unsigned int get_bits1(GetBitContext *s)
Definition get_bits.h:391
static void skip_bits(GetBitContext *s, int n)
Definition get_bits.h:383
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition get_bits.h:544
static int get_bits_count(const GetBitContext *s)
Definition get_bits.h:254
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition get_bits.h:337
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition codec.h:79
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition codec.h:49
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition avcodec.h:302
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition avcodec.h:314
@ AV_CODEC_ID_VC1IMAGE
Definition codec_id.h:202
@ AV_CODEC_ID_VC1
Definition codec_id.h:120
@ AV_CODEC_ID_WMV3IMAGE
Definition codec_id.h:201
@ AV_CODEC_ID_MSS2
Definition codec_id.h:216
@ AV_CODEC_ID_WMV3
Definition codec_id.h:121
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition defs.h:40
@ AVDISCARD_ALL
discard all
Definition defs.h:248
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition defs.h:247
@ AVDISCARD_NONREF
discard all non reference
Definition defs.h:244
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition error.h:73
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition error.h:64
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
#define AVERROR(e)
Definition error.h:45
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition frame.h:702
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition frame.h:707
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition frame.c:499
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition frame.c:281
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition frame.c:65
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition frame.c:53
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
#define AV_LOG_INFO
Standard information.
Definition log.h:221
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition mem.c:601
int av_size_mult(size_t a, size_t b, size_t *r)
Multiply two size_t values checking for overflow.
Definition mem.c:671
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition imgutils.c:318
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition utils.c:40
@ AV_PICTURE_TYPE_I
Intra.
Definition avutil.h:278
@ AV_PICTURE_TYPE_BI
BI type.
Definition avutil.h:284
@ AV_PICTURE_TYPE_P
Predicted.
Definition avutil.h:279
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition avutil.h:280
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
#define HWACCEL_NVDEC_CUARRAY(codec)
Definition hwconfig.h:70
#define HWACCEL_DXVA2(codec)
Definition hwconfig.h:64
#define HWACCEL_VDPAU(codec)
Definition hwconfig.h:74
#define HWACCEL_D3D12VA(codec)
Definition hwconfig.h:82
#define HWACCEL_NVDEC(codec)
Definition hwconfig.h:68
#define HWACCEL_VAAPI(codec)
Definition hwconfig.h:72
#define HWACCEL_D3D11VA(codec)
Definition hwconfig.h:80
#define HWACCEL_D3D11VA2(codec)
Definition hwconfig.h:66
static const int16_t alpha[]
Definition ilbcdata.h:55
misc image utilities
av_cold int ff_intrax8_common_init(AVCodecContext *avctx, IntraX8Context *w, int16_t block[64], int mb_width, int mb_height)
Initialize IntraX8 frame decoder.
Definition intrax8.c:679
#define AC_VLC_BITS
Definition intrax8.c:42
av_cold void ff_intrax8_common_end(IntraX8Context *w)
Destroy IntraX8 frame structure.
Definition intrax8.c:713
#define AV_RB32(p)
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition blockdsp.c:58
av_cold void CBS_FUNC close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition cbs.c:118
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition h264chroma.c:43
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition qpeldsp.c:784
av_cold int ff_vc1_decode_init(AVCodecContext *avctx)
Definition vc1dec.c:451
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
Close a MSS2/VC1/WMV3 decoder.
Definition vc1dec.c:769
static av_cold int vc1_decode_init(AVCodecContext *avctx)
Initialize a VC1/WMV3 decoder.
Definition vc1dec.c:617
static av_cold void vc1_init_static(void)
Definition vc1dec.c:494
static void vc1_decode_reset(AVCodecContext *avctx)
Definition vc1dec.c:737
static enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[]
Definition vc1dec.c:55
static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Decode a VC1/WMV3 frame.
Definition vc1dec.c:778
#define transpose(x)
static enum AVPixelFormat vc1_get_format(AVCodecContext *avctx)
Definition vc1dec.c:431
static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
Definition vc1dec.c:359
av_cold void ff_vc1_init_common(VC1Context *v)
Init VC-1 specific tables and VC1Context members.
Definition vc1dec.c:589
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
Definition vc1dec.c:479
av_cold void ff_vc1dsp_init(VC1DSPContext *dsp)
Definition vc1dsp.c:968
Macro definitions for various function/variable attributes.
#define av_cold
Definition attributes.h:117
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition internal.h:97
#define AVOnce
Definition thread.h:202
static int ff_thread_once(char *control, void(*routine)(void))
Definition thread.h:205
#define AV_ONCE_INIT
Definition thread.h:203
#define FFSWAP(type, a, b)
Definition macros.h:52
#define FFMIN(a, b)
Definition macros.h:49
#define FFMAX(a, b)
Definition macros.h:47
#define FFALIGN(x, a)
Definition macros.h:78
Memory handling functions.
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition mpeg_er.c:46
void ff_mpv_unref_picture(MPVWorkPicture *pic)
Definition mpegpicture.c:97
#define PICT_TOP_FIELD
Definition mpegutils.h:31
#define PICT_BOTTOM_FIELD
Definition mpegutils.h:32
#define PICT_FRAME
Definition mpegutils.h:33
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition mpegvideo.c:359
av_cold void ff_mpv_common_end(MpegEncContext *s)
Definition mpegvideo.c:428
mpegvideo header.
@ FMT_H263
Definition mpegvideo.h:57
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
av_cold void ff_mpeg_flush(AVCodecContext *avctx)
void ff_mpv_frame_end(MpegEncContext *s)
void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)
av_cold int ff_mpv_decode_close(AVCodecContext *avctx)
av_cold int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
mpegvideo decoder header.
av_cold void ff_msmp4_vc1_vlcs_init_once(void)
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
#define av_malloc(s)
Definition ops_static.c:52
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition pixfmt.h:813
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition pixfmt.h:775
@ AVCOL_RANGE_UNSPECIFIED
Definition pixfmt.h:758
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition pixfmt.h:73
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition pixfmt.h:440
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition pixfmt.h:134
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition pixfmt.h:81
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition pixfmt.h:260
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition pixfmt.h:336
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition pixfmt.h:254
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition pixfmt.h:126
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition pixfmt.h:194
const AVProfile ff_vc1_profiles[]
Definition profiles.c:161
void ff_simple_idct44_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
void ff_simple_idct84_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
void ff_simple_idct48_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
simple idct header.
void ff_simple_idct_int16_8bit(int16_t *block)
void ff_simple_idct_add_int16_8bit(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
main external API structure.
Definition avcodec.h:443
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition avcodec.h:644
int width
picture width / height.
Definition avcodec.h:605
int debug
debug
Definition avcodec.h:1398
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition avcodec.h:685
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition avcodec.h:658
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition avcodec.h:785
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition avcodec.h:1429
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition avcodec.h:713
int level
Encoding level descriptor.
Definition avcodec.h:1656
int profile
profile
Definition avcodec.h:1646
enum AVColorSpace colorspace
YUV colorspace type.
Definition avcodec.h:672
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition avcodec.h:665
int flags
AV_CODEC_FLAG_*.
Definition avcodec.h:500
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition avcodec.h:526
enum AVCodecID codec_id
Definition avcodec.h:453
int extradata_size
Definition avcodec.h:527
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition avcodec.h:620
void * priv_data
Definition avcodec.h:470
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition avcodec.h:1677
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition avcodec.h:1422
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition frame.h:500
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition frame.h:723
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition frame.h:524
enum AVPictureType pict_type
Picture type of the frame.
Definition frame.h:571
This structure stores compressed data.
Definition packet.h:587
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition packet.h:593
int size
Definition packet.h:611
uint8_t * data
Definition packet.h:610
struct AVFrame * f
Definition mpegpicture.h:59
int field_picture
whether or not the picture was encoded in separate fields
Definition mpegpicture.h:82
MPVPicture * ptr
RefStruct reference.
Definition mpegpicture.h:99
MpegEncContext.
Definition mpegvideo.h:67
struct AVCodecContext * avctx
Definition mpegvideo.h:82
MPVWorkPicture next_pic
copy of the next picture structure.
Definition mpegvideo.h:126
MPVWorkPicture last_pic
copy of the previous picture structure.
Definition mpegvideo.h:120
enum AVPictureType pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition mpegvideo.h:154
int block_index[6]
index to current MB in block based arrays with edges
Definition mpegvideo.h:194
MPVWorkPicture cur_pic
copy of the current picture structure.
Definition mpegvideo.h:132
The VC1 Context.
Definition vc1.h:176
uint8_t * sr_rows[2][2]
Sprite resizer line cache.
Definition vc1.h:385
int16_t(* luma_mv_base)[2]
Definition vc1.h:396
int next_interlaced
whether last_pic, next_pic is interlaced
Definition vc1.h:306
int transfer_char
8 bits, Opto-electronic transfer characteristics
Definition vc1.h:209
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags.
Definition vc1.h:220
int top_blk_sh
Either 3 or 0, positions of l/t in blk[].
Definition vc1.h:244
int left_blk_sh
Definition vc1.h:244
uint8_t * over_flags_plane
Overflags bitplane.
Definition vc1.h:329
uint8_t * direct_mb_plane
bitplane for "direct" MBs
Definition vc1.h:295
int pic_header_flag
Definition vc1.h:372
int first_pic_header_flag
Definition vc1.h:371
int output_width
Definition vc1.h:384
int p_frame_skipped
Definition vc1.h:388
int two_sprites
Definition vc1.h:382
uint8_t tff
Definition vc1.h:321
const VLCElem * cbpcy_vlc
CBPCY VLC table.
Definition vc1.h:291
uint8_t * mb_type
Definition vc1.h:271
VC1DSPContext vc1dsp
Definition vc1.h:181
uint8_t * is_intra
Definition vc1.h:395
int new_sprite
Frame decoding info for sprite modes.
Definition vc1.h:381
int bi_type
Definition vc1.h:389
int second_field
Definition vc1.h:358
uint8_t zz_8x8[4][64]
Zigzag table for TT_8x8, permuted for IDCT.
Definition vc1.h:243
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition vc1.h:401
uint8_t * is_intra_base
Definition vc1.h:395
uint8_t pq
Definition vc1.h:242
H264ChromaContext h264chroma
Definition vc1.h:180
uint8_t * mb_type_base
Definition vc1.h:271
int * ttblk
Transform type at the block level.
Definition vc1.h:266
int res_fasttx
reserved, always 1
Definition vc1.h:189
int field_mode
1 for interlaced field pictures
Definition vc1.h:356
uint32_t * cbp_base
Definition vc1.h:394
int res_sprite
Simple/Main Profile sequence header.
Definition vc1.h:185
int16_t(* block)[6][64]
Definition vc1.h:392
int sprite_height
Definition vc1.h:384
uint8_t * fieldtx_plane
Definition vc1.h:350
uint8_t * mv_f_next_base
Definition vc1.h:355
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition vc1.h:294
MpegEncContext s
Definition vc1.h:177
int color_prim
8 bits, chroma coordinates of the color primaries
Definition vc1.h:208
GetBitContext gb
Definition vc1.h:178
uint8_t * mv_f[2]
0: MV obtained from same field, 1: opposite field
Definition vc1.h:354
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition vc1.h:327
int n_allocated_blks
Definition vc1.h:393
uint8_t mvrange
Ranges:
Definition vc1.h:289
IntraX8Context x8
Definition vc1.h:179
int sprite_width
Definition vc1.h:384
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition vc1.h:353
int level
Advanced Profile.
Definition vc1.h:199
uint8_t rff
Definition vc1.h:321
int last_interlaced
Definition vc1.h:306
uint32_t * cbp
Definition vc1.h:394
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition vc1.h:318
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition vc1.h:203
int * ttblk_base
Definition vc1.h:266
int blocks_off
Definition vc1.h:368
int output_height
Definition vc1.h:384
uint8_t * blk_mv_type_base
Definition vc1.h:353
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition vc1.h:296
int16_t((* luma_mv)[2]
Definition vc1.h:396
AVFrame * sprite_output_frame
Definition vc1.h:383
uint8_t * mv_f_next[2]
Definition vc1.h:355
int matrix_coef
8 bits, Color primaries->YCbCr transform matrix
Definition vc1.h:210
int mb_off
Definition vc1.h:368
uint8_t rptfrm
Definition vc1.h:321
uint8_t zzi_8x8[64]
Definition vc1.h:352
uint8_t * mv_f_base
Definition vc1.h:354
void(* vc1_inv_trans_8x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition vc1dsp.h:44
void(* sprite_v_single)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset, int width)
Definition vc1dsp.h:70
void(* vc1_inv_trans_4x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition vc1dsp.h:45
void(* vc1_inv_trans_4x8)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition vc1dsp.h:41
void(* sprite_v_double_onescale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset1, const uint8_t *src2a, int alpha, int width)
Definition vc1dsp.h:72
void(* sprite_v_double_twoscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src1b, int offset1, const uint8_t *src2a, const uint8_t *src2b, int offset2, int alpha, int width)
Definition vc1dsp.h:74
void(* sprite_v_double_noscale)(uint8_t *dst, const uint8_t *src1a, const uint8_t *src2a, int alpha, int width)
Definition vc1dsp.h:71
void(* vc1_inv_trans_8x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition vc1dsp.h:40
int(* vc1_unescape_buffer)(const uint8_t *src, int size, uint8_t *dst)
Definition vc1dsp.h:87
void(* vc1_inv_trans_4x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition vc1dsp.h:42
void(* vc1_inv_trans_4x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition vc1dsp.h:46
void(* vc1_inv_trans_8x8)(int16_t *b)
Definition vc1dsp.h:39
void(* vc1_inv_trans_8x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition vc1dsp.h:43
void(* sprite_h)(uint8_t *dst, const uint8_t *src, int offset, int advance, int count)
Definition vc1dsp.h:69
Definition vlc.h:32
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
Definition vlc.h:220
#define av_free(p)
#define av_mallocz(s)
#define ff_dlog(a,...)
#define avpriv_request_sample(...)
#define av_freep(p)
#define av_log(a,...)
static uint8_t tmp[40]
Definition aes_ctr.c:52
#define width
Definition dsp.h:99
static struct @232240247175332074307271266321204261331170211232 state
int size
int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb)
Definition vc1.c:887
int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Decode Simple/Main Profiles sequence header.
Definition vc1.c:276
int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext *gb)
Definition vc1.c:667
int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
Definition vc1.c:495
int ff_vc1_decode_extradata(AVCodecContext *avctx, VC1Context *v, int *seq_initialized, int *ep_initialized)
Read the sequence and entry point headers carried in VC-1 extradata.
Definition vc1.c:555
int ff_vc1_decode_end(AVCodecContext *avctx)
Close a MSS2/VC1/WMV3 decoder.
Definition vc1dec.c:769
void ff_vc1_decode_blocks(VC1Context *v)
Definition vc1_block.c:2937
@ PROGRESSIVE
in the bitstream is reported as 00b
Definition vc1.h:152
static av_always_inline const uint8_t * find_next_marker(const uint8_t *src, const uint8_t *end)
Find VC-1 marker in buffer.
Definition vc1_common.h:59
@ PROFILE_ADVANCED
Definition vc1_common.h:52
@ VC1_CODE_ENDOFSEQ
Definition vc1_common.h:35
@ VC1_CODE_FIELD
Definition vc1_common.h:37
@ VC1_CODE_FRAME
Definition vc1_common.h:38
@ VC1_CODE_SLICE
Definition vc1_common.h:36
@ VC1_CODE_ENTRYPOINT
Definition vc1_common.h:39
VC-1 tables.
static const uint8_t vc1_if_mmv_mbmode_codes[8][8]
static const uint8_t vc1_2mv_block_pattern_bits[4][4]
static const uint8_t vc1_intfr_4mv_mbmode_bits[4][15]
static const uint8_t vc1_norm2_bits[4]
static const uint8_t vc1_2ref_mvdata_bits[8][126]
static const uint16_t vc1_cbpcy_p_codes[4][64]
static const uint8_t vc1_subblkpat_bits[3][15]
static const uint8_t vc1_ttmb_bits[3][16]
static const uint8_t vc1_intfr_non4mv_mbmode_bits[4][9]
static const uint8_t vc1_4mv_block_pattern_bits[4][16]
static const uint8_t vc1_subblkpat_codes[3][15]
static const uint8_t vc1_4mv_block_pattern_codes[4][16]
static const uint8_t vc1_if_1mv_mbmode_codes[8][6]
static const uint32_t vc1_1ref_mvdata_codes[4][72]
static const uint8_t vc1_norm6_bits[64]
static const uint16_t vc1_intfr_4mv_mbmode_codes[4][15]
static const uint8_t vc1_if_1mv_mbmode_bits[8][6]
static const uint32_t vc1_ac_tables[AC_MODES][186][2]
static const uint8_t vc1_1ref_mvdata_bits[4][72]
static const uint8_t vc1_ttblk_bits[3][8]
const int ff_vc1_ac_sizes[AC_MODES]
static const uint8_t vc1_intfr_non4mv_mbmode_codes[4][9]
static const uint16_t vc1_norm6_codes[64]
static const uint32_t vc1_2ref_mvdata_codes[8][126]
static const uint8_t vc1_imode_bits[7]
static const uint8_t vc1_if_mmv_mbmode_bits[8][8]
static const uint8_t vc1_norm2_codes[4]
static const uint8_t vc1_ttblk_codes[3][8]
static const uint16_t vc1_mv_diff_codes[4][73]
static const uint8_t vc1_mv_diff_bits[4][73]
static const uint8_t vc1_cbpcy_p_bits[4][64]
static const uint8_t vc1_2mv_block_pattern_codes[4][4]
static const uint8_t vc1_imode_codes[7]
static const uint8_t vc1_icbpcy_p_bits[8][63]
static const uint16_t vc1_icbpcy_p_codes[8][63]
static const uint16_t vc1_ttmb_codes[3][16]
const VLCElem * ff_vc1_2ref_mvdata_vlc[8]
Definition vc1data.c:122
const VLCElem * ff_vc1_ttblk_vlc[3]
Definition vc1data.c:115
const VLCElem * ff_vc1_icbpcy_vlc[8]
Definition vc1data.c:112
const VLCElem * ff_vc1_ac_coeff_table[8]
Definition vc1data.c:124
VLCElem ff_vc1_norm6_vlc[556]
Definition vc1data.c:107
VLCElem ff_vc1_imode_vlc[1<< VC1_IMODE_VLC_BITS]
Definition vc1data.c:105
const VLCElem * ff_vc1_subblkpat_vlc[3]
Definition vc1data.c:116
VLCElem ff_vc1_norm2_vlc[1<< VC1_NORM2_VLC_BITS]
Definition vc1data.c:106
const VLCElem * ff_vc1_ttmb_vlc[3]
Definition vc1data.c:109
const VLCElem * ff_vc1_if_1mv_mbmode_vlc[8]
Definition vc1data.c:120
const VLCElem * ff_vc1_if_mmv_mbmode_vlc[8]
Definition vc1data.c:119
const VLCElem * ff_vc1_intfr_4mv_mbmode_vlc[4]
Definition vc1data.c:117
const uint8_t ff_vc1_adv_interlaced_8x8_zz[64]
Definition vc1data.c:207
const VLCElem * ff_vc1_intfr_non4mv_mbmode_vlc[4]
Definition vc1data.c:118
const VLCElem * ff_vc1_2mv_block_pattern_vlc[4]
Definition vc1data.c:114
const VLCElem * ff_vc1_1ref_mvdata_vlc[4]
Definition vc1data.c:121
const VLCElem * ff_vc1_4mv_block_pattern_vlc[4]
Definition vc1data.c:113
const VLCElem * ff_vc1_cbpcy_p_vlc[4]
Definition vc1data.c:111
const VLCElem * ff_vc1_mv_diff_vlc[4]
Definition vc1data.c:110
VC-1 tables.
#define VC1_NORM6_VLC_BITS
Definition vc1data.h:62
#define VC1_4MV_BLOCK_PATTERN_VLC_BITS
Definition vc1data.h:73
#define VC1_INTFR_NON4MV_MBMODE_VLC_BITS
Definition vc1data.h:83
#define VC1_IMODE_VLC_BITS
Definition vc1data.h:58
#define VC1_1REF_MVDATA_VLC_BITS
Definition vc1data.h:89
#define VC1_INTFR_4MV_MBMODE_VLC_BITS
Definition vc1data.h:81
#define VC1_SUBBLKPAT_VLC_BITS
Definition vc1data.h:79
#define VC1_CBPCY_P_VLC_BITS
Definition vc1data.h:69
#define VC1_IF_1MV_MBMODE_VLC_BITS
Definition vc1data.h:87
#define VC1_TTMB_VLC_BITS
Definition vc1data.h:65
#define VC1_2MV_BLOCK_PATTERN_VLC_BITS
Definition vc1data.h:75
#define VC1_2REF_MVDATA_VLC_BITS
Definition vc1data.h:91
#define VC1_TTBLK_VLC_BITS
Definition vc1data.h:77
#define VC1_ICBPCY_VLC_BITS
Definition vc1data.h:71
#define VC1_IF_MMV_MBMODE_VLC_BITS
Definition vc1data.h:85
#define VC1_NORM2_VLC_BITS
Definition vc1data.h:60
#define VC1_MV_DIFF_VLC_BITS
Definition vc1data.h:67
#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition vlc.h:278
#define VLC_INIT_STATE(_table)
Definition vlc.h:225
static const VLCElem * ff_vlc_init_tables(VLCInitState *state, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, int flags)
Definition vlc.h:254
static double c[64]