Line | Branch | Exec | Source |
---|---|---|---|
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" | ||
48 | #include "libavutil/attributes.h" | ||
49 | #include "libavutil/avassert.h" | ||
50 | #include "libavutil/imgutils.h" | ||
51 | #include "libavutil/mem.h" | ||
52 | #include "libavutil/thread.h" | ||
53 | |||
54 | |||
55 | static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = { | ||
56 | #if CONFIG_VC1_DXVA2_HWACCEL | ||
57 | AV_PIX_FMT_DXVA2_VLD, | ||
58 | #endif | ||
59 | #if CONFIG_VC1_D3D11VA_HWACCEL | ||
60 | AV_PIX_FMT_D3D11VA_VLD, | ||
61 | AV_PIX_FMT_D3D11, | ||
62 | #endif | ||
63 | #if CONFIG_VC1_D3D12VA_HWACCEL | ||
64 | AV_PIX_FMT_D3D12, | ||
65 | #endif | ||
66 | #if CONFIG_VC1_NVDEC_HWACCEL | ||
67 | AV_PIX_FMT_CUDA, | ||
68 | #endif | ||
69 | #if CONFIG_VC1_VAAPI_HWACCEL | ||
70 | AV_PIX_FMT_VAAPI, | ||
71 | #endif | ||
72 | #if CONFIG_VC1_VDPAU_HWACCEL | ||
73 | AV_PIX_FMT_VDPAU, | ||
74 | #endif | ||
75 | AV_PIX_FMT_YUV420P, | ||
76 | AV_PIX_FMT_NONE | ||
77 | }; | ||
78 | |||
79 | #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER | ||
80 | |||
81 | typedef 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 | |||
100 | ✗ | static inline int get_fp_val(GetBitContext* gb) | |
101 | { | ||
102 | ✗ | return (get_bits_long(gb, 30) - (1 << 29)) << 1; | |
103 | } | ||
104 | |||
105 | ✗ | static 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 | |||
139 | ✗ | static 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 | |||
210 | ✗ | static 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 | 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 | ✗ | uint8_t *iplane = s->current_picture.f->data[plane]; | |
239 | ✗ | int iline = s->current_picture.f->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_picture.f->data[plane]; | |
246 | ✗ | iline = s->last_picture.f->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 | |||
307 | ✗ | static 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->current_picture.f || !s->current_picture.f->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_picture_ptr || !s->last_picture.f->data[0])) { | |
326 | ✗ | av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n"); | |
327 | ✗ | v->two_sprites = 0; | |
328 | } | ||
329 | |||
330 | ✗ | av_frame_unref(v->sprite_output_frame); | |
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 | |||
339 | ✗ | static void vc1_sprite_flush(AVCodecContext *avctx) | |
340 | { | ||
341 | ✗ | VC1Context *v = avctx->priv_data; | |
342 | ✗ | MpegEncContext *s = &v->s; | |
343 | ✗ | AVFrame *f = s->current_picture.f; | |
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 && 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 | |||
359 | 34 | static av_cold int vc1_decode_init_alloc_tables(VC1Context *v) | |
360 | { | ||
361 | 34 | MpegEncContext *s = &v->s; | |
362 | int i, ret; | ||
363 | 34 | int mb_height = FFALIGN(s->mb_height, 2); | |
364 | |||
365 | /* Allocate mb bitplanes */ | ||
366 | 34 | v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height); | |
367 | 34 | v->direct_mb_plane = av_malloc (s->mb_stride * mb_height); | |
368 | 34 | v->forward_mb_plane = av_malloc (s->mb_stride * mb_height); | |
369 | 34 | v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height); | |
370 | 34 | v->acpred_plane = av_malloc (s->mb_stride * mb_height); | |
371 | 34 | v->over_flags_plane = av_malloc (s->mb_stride * mb_height); | |
372 |
3/6✓ Branch 0 taken 34 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 34 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 34 times.
✗ Branch 5 not taken.
|
34 | if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane || |
373 |
3/6✓ Branch 0 taken 34 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 34 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 34 times.
|
34 | !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane) |
374 | ✗ | return AVERROR(ENOMEM); | |
375 | |||
376 | 34 | v->n_allocated_blks = s->mb_width + 2; | |
377 | 34 | v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks); | |
378 | 34 | v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride); | |
379 |
2/4✓ Branch 0 taken 34 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 34 times.
|
34 | if (!v->block || !v->cbp_base) |
380 | ✗ | return AVERROR(ENOMEM); | |
381 | 34 | v->cbp = v->cbp_base + 2 * s->mb_stride; | |
382 | 34 | v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride); | |
383 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!v->ttblk_base) |
384 | ✗ | return AVERROR(ENOMEM); | |
385 | 34 | v->ttblk = v->ttblk_base + 2 * s->mb_stride; | |
386 | 34 | v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride); | |
387 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!v->is_intra_base) |
388 | ✗ | return AVERROR(ENOMEM); | |
389 | 34 | v->is_intra = v->is_intra_base + 2 * s->mb_stride; | |
390 | 34 | v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride); | |
391 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!v->luma_mv_base) |
392 | ✗ | return AVERROR(ENOMEM); | |
393 | 34 | 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 | 34 | v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2); | |
397 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!v->mb_type_base) |
398 | ✗ | return AVERROR(ENOMEM); | |
399 | 34 | v->mb_type[0] = v->mb_type_base + s->b8_stride + 1; | |
400 | 34 | v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1; | |
401 | 34 | v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1); | |
402 | |||
403 | /* allocate memory to store block level MV info */ | ||
404 | 34 | v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2); | |
405 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!v->blk_mv_type_base) |
406 | ✗ | return AVERROR(ENOMEM); | |
407 | 34 | v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1; | |
408 | 34 | v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2)); | |
409 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!v->mv_f_base) |
410 | ✗ | return AVERROR(ENOMEM); | |
411 | 34 | v->mv_f[0] = v->mv_f_base + s->b8_stride + 1; | |
412 | 34 | v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2); | |
413 | 34 | v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2)); | |
414 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!v->mv_f_next_base) |
415 | ✗ | return AVERROR(ENOMEM); | |
416 | 34 | v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1; | |
417 | 34 | v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2); | |
418 | |||
419 |
2/4✓ Branch 0 taken 34 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 34 times.
|
34 | if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) { |
420 | ✗ | for (i = 0; i < 4; i++) | |
421 | ✗ | if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) | |
422 | ✗ | return AVERROR(ENOMEM); | |
423 | } | ||
424 | |||
425 | 34 | ret = ff_intrax8_common_init(s->avctx, &v->x8, | |
426 | 34 | s->block, s->block_last_index, | |
427 | s->mb_width, s->mb_height); | ||
428 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (ret < 0) |
429 | ✗ | return ret; | |
430 | |||
431 | 34 | return 0; | |
432 | } | ||
433 | |||
434 | 34 | static enum AVPixelFormat vc1_get_format(AVCodecContext *avctx) | |
435 | { | ||
436 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 22 times.
|
34 | if (avctx->codec_id == AV_CODEC_ID_MSS2) |
437 | 12 | return AV_PIX_FMT_YUV420P; | |
438 | |||
439 | if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) { | ||
440 | if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED) | ||
441 | avctx->color_range = AVCOL_RANGE_MPEG; | ||
442 | return AV_PIX_FMT_GRAY8; | ||
443 | } | ||
444 | |||
445 |
1/2✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
|
22 | if (avctx->codec_id == AV_CODEC_ID_VC1IMAGE || |
446 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) |
447 | ✗ | return AV_PIX_FMT_YUV420P; | |
448 | |||
449 | 22 | return ff_get_format(avctx, vc1_hwaccel_pixfmt_list_420); | |
450 | } | ||
451 | |||
452 | 34 | av_cold int ff_vc1_decode_init(AVCodecContext *avctx) | |
453 | { | ||
454 | 34 | VC1Context *const v = avctx->priv_data; | |
455 | 34 | MpegEncContext *const s = &v->s; | |
456 | int ret; | ||
457 | |||
458 | 34 | ret = av_image_check_size(avctx->width, avctx->height, 0, avctx); | |
459 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (ret < 0) |
460 | ✗ | return ret; | |
461 | |||
462 | 34 | ff_mpv_decode_init(s, avctx); | |
463 | |||
464 | 34 | avctx->pix_fmt = vc1_get_format(avctx); | |
465 | |||
466 | 34 | ret = ff_mpv_common_init(s); | |
467 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (ret < 0) |
468 | ✗ | return ret; | |
469 | |||
470 | 34 | s->y_dc_scale_table = ff_wmv3_dc_scale_table; | |
471 | 34 | s->c_dc_scale_table = ff_wmv3_dc_scale_table; | |
472 | |||
473 | 34 | ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, | |
474 | ff_wmv1_scantable[0]); | ||
475 | 34 | ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, | |
476 | ff_wmv1_scantable[1]); | ||
477 | |||
478 | 34 | ret = vc1_decode_init_alloc_tables(v); | |
479 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (ret < 0) { |
480 | ✗ | ff_vc1_decode_end(avctx); | |
481 | ✗ | return ret; | |
482 | } | ||
483 | 34 | return 0; | |
484 | } | ||
485 | |||
486 | 34 | av_cold void ff_vc1_init_transposed_scantables(VC1Context *v) | |
487 | { | ||
488 | int i; | ||
489 |
2/2✓ Branch 0 taken 2176 times.
✓ Branch 1 taken 34 times.
|
2210 | for (i = 0; i < 64; i++) { |
490 | #define transpose(x) (((x) >> 3) | (((x) & 7) << 3)) | ||
491 | 2176 | v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]); | |
492 | 2176 | v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]); | |
493 | 2176 | v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]); | |
494 | 2176 | v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]); | |
495 | 2176 | v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]); | |
496 | } | ||
497 | 34 | v->left_blk_sh = 0; | |
498 | 34 | v->top_blk_sh = 3; | |
499 | 34 | } | |
500 | |||
501 | 18 | static av_cold void vc1_init_static(void) | |
502 | { | ||
503 | static VLCElem vlc_table[32372]; | ||
504 | 18 | VLCInitState state = VLC_INIT_STATE(vlc_table); | |
505 | |||
506 | 18 | VLC_INIT_STATIC_TABLE(ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4, | |
507 | vc1_norm2_bits, 1, 1, | ||
508 | vc1_norm2_codes, 1, 1, 0); | ||
509 | 18 | VLC_INIT_STATIC_TABLE(ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64, | |
510 | vc1_norm6_bits, 1, 1, | ||
511 | vc1_norm6_codes, 2, 2, 0); | ||
512 | 18 | VLC_INIT_STATIC_TABLE(ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7, | |
513 | vc1_imode_bits, 1, 1, | ||
514 | vc1_imode_codes, 1, 1, 0); | ||
515 |
2/2✓ Branch 0 taken 54 times.
✓ Branch 1 taken 18 times.
|
72 | for (int i = 0; i < 3; i++) { |
516 | 54 | ff_vc1_ttmb_vlc[i] = | |
517 | 54 | ff_vlc_init_tables(&state, VC1_TTMB_VLC_BITS, 16, | |
518 | 54 | vc1_ttmb_bits[i], 1, 1, | |
519 | 54 | vc1_ttmb_codes[i], 2, 2, 0); | |
520 | 54 | ff_vc1_ttblk_vlc[i] = | |
521 | 54 | ff_vlc_init_tables(&state, VC1_TTBLK_VLC_BITS, 8, | |
522 | 54 | vc1_ttblk_bits[i], 1, 1, | |
523 | 54 | vc1_ttblk_codes[i], 1, 1, 0); | |
524 | 54 | ff_vc1_subblkpat_vlc[i] = | |
525 | 54 | ff_vlc_init_tables(&state, VC1_SUBBLKPAT_VLC_BITS, 15, | |
526 | 54 | vc1_subblkpat_bits[i], 1, 1, | |
527 | 54 | vc1_subblkpat_codes[i], 1, 1, 0); | |
528 | } | ||
529 |
2/2✓ Branch 0 taken 72 times.
✓ Branch 1 taken 18 times.
|
90 | for (int i = 0; i < 4; i++) { |
530 | 72 | ff_vc1_4mv_block_pattern_vlc[i] = | |
531 | 72 | ff_vlc_init_tables(&state, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16, | |
532 | 72 | vc1_4mv_block_pattern_bits[i], 1, 1, | |
533 | 72 | vc1_4mv_block_pattern_codes[i], 1, 1, 0); | |
534 | 72 | ff_vc1_cbpcy_p_vlc[i] = | |
535 | 72 | ff_vlc_init_tables(&state, VC1_CBPCY_P_VLC_BITS, 64, | |
536 | 72 | vc1_cbpcy_p_bits[i], 1, 1, | |
537 | 72 | vc1_cbpcy_p_codes[i], 2, 2, 0); | |
538 | 72 | ff_vc1_mv_diff_vlc[i] = | |
539 | 72 | ff_vlc_init_tables(&state, VC1_MV_DIFF_VLC_BITS, 73, | |
540 | 72 | vc1_mv_diff_bits[i], 1, 1, | |
541 | 72 | vc1_mv_diff_codes[i], 2, 2, 0); | |
542 | /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */ | ||
543 | 72 | ff_vc1_intfr_4mv_mbmode_vlc[i] = | |
544 | 72 | ff_vlc_init_tables(&state, VC1_INTFR_4MV_MBMODE_VLC_BITS, 15, | |
545 | 72 | vc1_intfr_4mv_mbmode_bits[i], 1, 1, | |
546 | 72 | vc1_intfr_4mv_mbmode_codes[i], 2, 2, 0); | |
547 | /* initialize NON-4MV MBMODE VLC tables for the same */ | ||
548 | 72 | ff_vc1_intfr_non4mv_mbmode_vlc[i] = | |
549 | 72 | ff_vlc_init_tables(&state, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9, | |
550 | 72 | vc1_intfr_non4mv_mbmode_bits[i], 1, 1, | |
551 | 72 | vc1_intfr_non4mv_mbmode_codes[i], 1, 1, 0); | |
552 | /* initialize interlaced MVDATA tables (1-Ref) */ | ||
553 | 72 | ff_vc1_1ref_mvdata_vlc[i] = | |
554 | 72 | ff_vlc_init_tables(&state, VC1_1REF_MVDATA_VLC_BITS, 72, | |
555 | 72 | vc1_1ref_mvdata_bits[i], 1, 1, | |
556 | 72 | vc1_1ref_mvdata_codes[i], 4, 4, 0); | |
557 | /* Initialize 2MV Block pattern VLC tables */ | ||
558 | 72 | ff_vc1_2mv_block_pattern_vlc[i] = | |
559 | 72 | ff_vlc_init_tables(&state, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4, | |
560 | 72 | vc1_2mv_block_pattern_bits[i], 1, 1, | |
561 | 72 | vc1_2mv_block_pattern_codes[i], 1, 1, 0); | |
562 | } | ||
563 |
2/2✓ Branch 0 taken 144 times.
✓ Branch 1 taken 18 times.
|
162 | for (int i = 0; i < 8; i++) { |
564 | 144 | ff_vc1_ac_coeff_table[i] = | |
565 | 144 | ff_vlc_init_tables(&state, AC_VLC_BITS, ff_vc1_ac_sizes[i], | |
566 | 144 | &vc1_ac_tables[i][0][1], 8, 4, | |
567 | 144 | &vc1_ac_tables[i][0][0], 8, 4, 0); | |
568 | /* initialize interlaced MVDATA tables (2-Ref) */ | ||
569 | 144 | ff_vc1_2ref_mvdata_vlc[i] = | |
570 | 144 | ff_vlc_init_tables(&state, VC1_2REF_MVDATA_VLC_BITS, 126, | |
571 | 144 | vc1_2ref_mvdata_bits[i], 1, 1, | |
572 | 144 | vc1_2ref_mvdata_codes[i], 4, 4, 0); | |
573 | /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */ | ||
574 | 144 | ff_vc1_icbpcy_vlc[i] = | |
575 | 144 | ff_vlc_init_tables(&state, VC1_ICBPCY_VLC_BITS, 63, | |
576 | 144 | vc1_icbpcy_p_bits[i], 1, 1, | |
577 | 144 | vc1_icbpcy_p_codes[i], 2, 2, 0); | |
578 | /* Initialize interlaced field picture MBMODE VLC tables */ | ||
579 | 144 | ff_vc1_if_mmv_mbmode_vlc[i] = | |
580 | 144 | ff_vlc_init_tables(&state, VC1_IF_MMV_MBMODE_VLC_BITS, 8, | |
581 | 144 | vc1_if_mmv_mbmode_bits[i], 1, 1, | |
582 | 144 | vc1_if_mmv_mbmode_codes[i], 1, 1, 0); | |
583 | 144 | ff_vc1_if_1mv_mbmode_vlc[i] = | |
584 | 144 | ff_vlc_init_tables(&state, VC1_IF_1MV_MBMODE_VLC_BITS, 6, | |
585 | 144 | vc1_if_1mv_mbmode_bits[i], 1, 1, | |
586 | 144 | vc1_if_1mv_mbmode_codes[i], 1, 1, 0); | |
587 | } | ||
588 | 18 | ff_msmp4_vc1_vlcs_init_once(); | |
589 | 18 | } | |
590 | |||
591 | /** | ||
592 | * Init VC-1 specific tables and VC1Context members | ||
593 | * @param v The VC1Context to initialize | ||
594 | * @return Status | ||
595 | */ | ||
596 | 34 | av_cold void ff_vc1_init_common(VC1Context *v) | |
597 | { | ||
598 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
599 | 34 | MpegEncContext *const s = &v->s; | |
600 | |||
601 | /* defaults */ | ||
602 | 34 | v->pq = -1; | |
603 | 34 | v->mvrange = 0; /* 7.1.1.18, p80 */ | |
604 | |||
605 | 34 | s->avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; | |
606 | 34 | s->out_format = FMT_H263; | |
607 | |||
608 | 34 | s->h263_pred = 1; | |
609 | 34 | s->msmpeg4_version = 6; | |
610 | |||
611 | 34 | ff_vc1dsp_init(&v->vc1dsp); | |
612 | |||
613 | /* For error resilience */ | ||
614 | 34 | ff_qpeldsp_init(&s->qdsp); | |
615 | |||
616 | /* VLC tables */ | ||
617 | 34 | ff_thread_once(&init_static_once, vc1_init_static); | |
618 | 34 | } | |
619 | |||
620 | /** Initialize a VC1/WMV3 decoder | ||
621 | * @todo TODO: Handle VC-1 IDUs (Transport level?) | ||
622 | * @todo TODO: Decipher remaining bits in extra_data | ||
623 | */ | ||
624 | 28 | static av_cold int vc1_decode_init(AVCodecContext *avctx) | |
625 | { | ||
626 | 28 | VC1Context *v = avctx->priv_data; | |
627 | 28 | MpegEncContext *s = &v->s; | |
628 | GetBitContext gb; | ||
629 | int ret; | ||
630 | |||
631 | /* save the container output size for WMImage */ | ||
632 | 28 | v->output_width = avctx->width; | |
633 | 28 | v->output_height = avctx->height; | |
634 | |||
635 |
3/4✓ Branch 0 taken 22 times.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
|
28 | if (!avctx->extradata_size || !avctx->extradata) |
636 | 6 | return AVERROR_INVALIDDATA; | |
637 | 22 | v->s.avctx = avctx; | |
638 | |||
639 | 22 | ff_vc1_init_common(v); | |
640 | |||
641 |
3/4✓ Branch 0 taken 15 times.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
|
29 | if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) { |
642 | 7 | int count = 0; | |
643 | |||
644 | // looks like WMV3 has a sequence header stored in the extradata | ||
645 | // advanced sequence header may be before the first frame | ||
646 | // the last byte of the extradata is a version number, 1 for the | ||
647 | // samples we can decode | ||
648 | |||
649 | 7 | ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size); | |
650 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
|
7 | if (ret < 0) |
651 | ✗ | return ret; | |
652 | |||
653 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
|
7 | if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) |
654 | ✗ | return ret; | |
655 | |||
656 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
7 | if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE && !v->res_sprite) { |
657 | ✗ | avpriv_request_sample(avctx, "Non sprite WMV3IMAGE"); | |
658 | ✗ | return AVERROR_PATCHWELCOME; | |
659 | } | ||
660 | |||
661 | 7 | count = avctx->extradata_size*8 - get_bits_count(&gb); | |
662 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
|
7 | if (count > 0) { |
663 | ✗ | av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n", | |
664 | count, get_bits_long(&gb, FFMIN(count, 32))); | ||
665 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
|
7 | } else if (count < 0) { |
666 | ✗ | av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count); | |
667 | } | ||
668 | } else { // VC1/WVC1/WVP2 | ||
669 | 15 | const uint8_t *start = avctx->extradata; | |
670 | 15 | uint8_t *end = avctx->extradata + avctx->extradata_size; | |
671 | const uint8_t *next; | ||
672 | int size, buf2_size; | ||
673 | 15 | uint8_t *buf2 = NULL; | |
674 | 15 | int seq_initialized = 0, ep_initialized = 0; | |
675 | |||
676 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
|
15 | if (avctx->extradata_size < 16) { |
677 | ✗ | av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size); | |
678 | ✗ | return AVERROR_INVALIDDATA; | |
679 | } | ||
680 | |||
681 | 15 | buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE); | |
682 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
|
15 | if (!buf2) |
683 | ✗ | return AVERROR(ENOMEM); | |
684 | |||
685 | 15 | start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv | |
686 | 15 | next = start; | |
687 |
2/2✓ Branch 0 taken 40 times.
✓ Branch 1 taken 15 times.
|
55 | for (; next < end; start = next) { |
688 | 40 | next = find_next_marker(start + 4, end); | |
689 | 40 | size = next - start - 4; | |
690 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
|
40 | if (size <= 0) |
691 | ✗ | continue; | |
692 | 40 | buf2_size = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2); | |
693 | 40 | init_get_bits(&gb, buf2, buf2_size * 8); | |
694 |
2/3✓ Branch 0 taken 15 times.
✓ Branch 1 taken 25 times.
✗ Branch 2 not taken.
|
40 | switch (AV_RB32(start)) { |
695 | 15 | case VC1_CODE_SEQHDR: | |
696 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
|
15 | if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) { |
697 | ✗ | av_free(buf2); | |
698 | ✗ | return ret; | |
699 | } | ||
700 | 15 | seq_initialized = 1; | |
701 | 15 | break; | |
702 | 25 | case VC1_CODE_ENTRYPOINT: | |
703 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 25 times.
|
25 | if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) { |
704 | ✗ | av_free(buf2); | |
705 | ✗ | return ret; | |
706 | } | ||
707 | 25 | ep_initialized = 1; | |
708 | 25 | break; | |
709 | } | ||
710 | } | ||
711 | 15 | av_free(buf2); | |
712 |
2/4✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
|
15 | if (!seq_initialized || !ep_initialized) { |
713 | ✗ | av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n"); | |
714 | ✗ | return AVERROR_INVALIDDATA; | |
715 | } | ||
716 | 15 | v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE); | |
717 | } | ||
718 | |||
719 | 22 | avctx->profile = v->profile; | |
720 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 7 times.
|
22 | if (v->profile == PROFILE_ADVANCED) |
721 | 15 | avctx->level = v->level; | |
722 | |||
723 | 22 | ff_blockdsp_init(&s->bdsp); | |
724 | 22 | ff_h264chroma_init(&v->h264chroma, 8); | |
725 | |||
726 | 22 | avctx->has_b_frames = !!avctx->max_b_frames; | |
727 | |||
728 |
3/6✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 22 times.
|
22 | if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6) |
729 | ✗ | avctx->color_primaries = v->color_prim; | |
730 |
2/4✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
|
22 | if (v->transfer_char == 1 || v->transfer_char == 7) |
731 | ✗ | avctx->color_trc = v->transfer_char; | |
732 |
3/6✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 22 times.
|
22 | if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7) |
733 | ✗ | avctx->colorspace = v->matrix_coef; | |
734 | |||
735 | 22 | s->mb_width = (avctx->coded_width + 15) >> 4; | |
736 | 22 | s->mb_height = (avctx->coded_height + 15) >> 4; | |
737 | |||
738 |
3/4✓ Branch 0 taken 7 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
|
22 | if (v->profile == PROFILE_ADVANCED || v->res_fasttx) { |
739 | 22 | ff_vc1_init_transposed_scantables(v); | |
740 | } else { | ||
741 | ✗ | memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64); | |
742 | ✗ | v->left_blk_sh = 3; | |
743 | ✗ | v->top_blk_sh = 0; | |
744 | ✗ | v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_int16_8bit; | |
745 | ✗ | v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add; | |
746 | ✗ | v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add; | |
747 | ✗ | v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add; | |
748 | ✗ | v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_int16_8bit; | |
749 | ✗ | v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add; | |
750 | ✗ | v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add; | |
751 | ✗ | v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add; | |
752 | } | ||
753 | |||
754 |
2/4✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
|
22 | if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) { |
755 | ✗ | v->sprite_width = avctx->coded_width; | |
756 | ✗ | v->sprite_height = avctx->coded_height; | |
757 | |||
758 | ✗ | avctx->coded_width = avctx->width = v->output_width; | |
759 | ✗ | avctx->coded_height = avctx->height = v->output_height; | |
760 | |||
761 | // prevent 16.16 overflows | ||
762 | ✗ | if (v->sprite_width > 1 << 14 || | |
763 | ✗ | v->sprite_height > 1 << 14 || | |
764 | ✗ | v->output_width > 1 << 14 || | |
765 | ✗ | v->output_height > 1 << 14) { | |
766 | ✗ | return AVERROR_INVALIDDATA; | |
767 | } | ||
768 | |||
769 | ✗ | if ((v->sprite_width&1) || (v->sprite_height&1)) { | |
770 | ✗ | avpriv_request_sample(avctx, "odd sprites support"); | |
771 | ✗ | return AVERROR_PATCHWELCOME; | |
772 | } | ||
773 | } | ||
774 | 22 | return 0; | |
775 | } | ||
776 | |||
777 | /** Close a VC1/WMV3 decoder | ||
778 | * @warning Initial try at using MpegEncContext stuff | ||
779 | */ | ||
780 | 34 | av_cold int ff_vc1_decode_end(AVCodecContext *avctx) | |
781 | { | ||
782 | 34 | VC1Context *v = avctx->priv_data; | |
783 | int i; | ||
784 | |||
785 | 34 | av_frame_free(&v->sprite_output_frame); | |
786 | |||
787 |
2/2✓ Branch 0 taken 136 times.
✓ Branch 1 taken 34 times.
|
170 | for (i = 0; i < 4; i++) |
788 | 136 | av_freep(&v->sr_rows[i >> 1][i & 1]); | |
789 | 34 | ff_mpv_common_end(&v->s); | |
790 | 34 | av_freep(&v->mv_type_mb_plane); | |
791 | 34 | av_freep(&v->direct_mb_plane); | |
792 | 34 | av_freep(&v->forward_mb_plane); | |
793 | 34 | av_freep(&v->fieldtx_plane); | |
794 | 34 | av_freep(&v->acpred_plane); | |
795 | 34 | av_freep(&v->over_flags_plane); | |
796 | 34 | av_freep(&v->mb_type_base); | |
797 | 34 | av_freep(&v->blk_mv_type_base); | |
798 | 34 | av_freep(&v->mv_f_base); | |
799 | 34 | av_freep(&v->mv_f_next_base); | |
800 | 34 | av_freep(&v->block); | |
801 | 34 | av_freep(&v->cbp_base); | |
802 | 34 | av_freep(&v->ttblk_base); | |
803 | 34 | av_freep(&v->is_intra_base); // FIXME use v->mb_type[] | |
804 | 34 | av_freep(&v->luma_mv_base); | |
805 | 34 | ff_intrax8_common_end(&v->x8); | |
806 | 34 | return 0; | |
807 | } | ||
808 | |||
809 | |||
810 | /** Decode a VC1/WMV3 frame | ||
811 | * @todo TODO: Handle VC-1 IDUs (Transport level?) | ||
812 | */ | ||
813 | 506 | static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict, | |
814 | int *got_frame, AVPacket *avpkt) | ||
815 | { | ||
816 | 506 | const uint8_t *buf = avpkt->data; | |
817 | 506 | int buf_size = avpkt->size, n_slices = 0, i, ret; | |
818 | 506 | VC1Context *v = avctx->priv_data; | |
819 | 506 | MpegEncContext *s = &v->s; | |
820 | 506 | uint8_t *buf2 = NULL; | |
821 | 506 | const uint8_t *buf_start = buf, *buf_start_second_field = NULL; | |
822 | 506 | int mb_height, n_slices1=-1; | |
823 | struct { | ||
824 | uint8_t *buf; | ||
825 | GetBitContext gb; | ||
826 | int mby_start; | ||
827 | const uint8_t *rawbuf; | ||
828 | int raw_size; | ||
829 | 506 | } *slices = NULL, *tmp; | |
830 | 506 | unsigned slices_allocated = 0; | |
831 | |||
832 | 506 | v->second_field = 0; | |
833 | |||
834 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 506 times.
|
506 | if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) |
835 | ✗ | s->low_delay = 1; | |
836 | |||
837 | /* no supplementary picture */ | ||
838 |
5/6✓ Branch 0 taken 490 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 489 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
506 | if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) { |
839 | /* special case for last picture */ | ||
840 |
4/4✓ Branch 0 taken 16 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 8 times.
|
17 | if (s->low_delay == 0 && s->next_picture_ptr) { |
841 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
|
8 | if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0) |
842 | ✗ | return ret; | |
843 | 8 | s->next_picture_ptr = NULL; | |
844 | |||
845 | 8 | *got_frame = 1; | |
846 | } | ||
847 | |||
848 | 17 | return buf_size; | |
849 | } | ||
850 | |||
851 | //for advanced profile we may need to parse and unescape data | ||
852 |
3/4✓ Branch 0 taken 183 times.
✓ Branch 1 taken 306 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 183 times.
|
795 | if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) { |
853 | 306 | int buf_size2 = 0; | |
854 | 306 | size_t next_allocated = 0; | |
855 | 306 | buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE); | |
856 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 306 times.
|
306 | if (!buf2) |
857 | ✗ | return AVERROR(ENOMEM); | |
858 | |||
859 |
1/2✓ Branch 0 taken 306 times.
✗ Branch 1 not taken.
|
306 | if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */ |
860 | const uint8_t *start, *end, *next; | ||
861 | int size; | ||
862 | |||
863 | 306 | next = buf; | |
864 |
2/2✓ Branch 0 taken 988 times.
✓ Branch 1 taken 306 times.
|
1294 | for (start = buf, end = buf + buf_size; next < end; start = next) { |
865 | 988 | next = find_next_marker(start + 4, end); | |
866 | 988 | size = next - start - 4; | |
867 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 988 times.
|
988 | if (size <= 0) continue; |
868 |
5/5✓ Branch 0 taken 306 times.
✓ Branch 1 taken 37 times.
✓ Branch 2 taken 26 times.
✓ Branch 3 taken 603 times.
✓ Branch 4 taken 16 times.
|
988 | switch (AV_RB32(start)) { |
869 | 306 | case VC1_CODE_FRAME: | |
870 | 306 | buf_start = start; | |
871 | 306 | buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2); | |
872 | 306 | break; | |
873 | 37 | case VC1_CODE_FIELD: { | |
874 | int buf_size3; | ||
875 | 37 | buf_start_second_field = start; | |
876 | 37 | av_size_mult(sizeof(*slices), n_slices+1, &next_allocated); | |
877 |
1/2✓ Branch 0 taken 37 times.
✗ Branch 1 not taken.
|
37 | tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL; |
878 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | if (!tmp) { |
879 | ✗ | ret = AVERROR(ENOMEM); | |
880 | ✗ | goto err; | |
881 | } | ||
882 | 37 | slices = tmp; | |
883 | 37 | slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE); | |
884 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | if (!slices[n_slices].buf) { |
885 | ✗ | ret = AVERROR(ENOMEM); | |
886 | ✗ | goto err; | |
887 | } | ||
888 | 37 | buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, | |
889 | 37 | slices[n_slices].buf); | |
890 | 37 | init_get_bits(&slices[n_slices].gb, slices[n_slices].buf, | |
891 | buf_size3 << 3); | ||
892 | 37 | slices[n_slices].mby_start = avctx->coded_height + 31 >> 5; | |
893 | 37 | slices[n_slices].rawbuf = start; | |
894 | 37 | slices[n_slices].raw_size = size + 4; | |
895 | 37 | n_slices1 = n_slices - 1; // index of the last slice of the first field | |
896 | 37 | n_slices++; | |
897 | 37 | break; | |
898 | } | ||
899 | 26 | case VC1_CODE_ENTRYPOINT: /* it should be before frame data */ | |
900 | 26 | buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2); | |
901 | 26 | init_get_bits(&s->gb, buf2, buf_size2 * 8); | |
902 | 26 | ff_vc1_decode_entry_point(avctx, v, &s->gb); | |
903 | 26 | break; | |
904 | 603 | case VC1_CODE_SLICE: { | |
905 | int buf_size3; | ||
906 | 603 | av_size_mult(sizeof(*slices), n_slices+1, &next_allocated); | |
907 |
1/2✓ Branch 0 taken 603 times.
✗ Branch 1 not taken.
|
603 | tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL; |
908 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 603 times.
|
603 | if (!tmp) { |
909 | ✗ | ret = AVERROR(ENOMEM); | |
910 | ✗ | goto err; | |
911 | } | ||
912 | 603 | slices = tmp; | |
913 | 603 | slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE); | |
914 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 603 times.
|
603 | if (!slices[n_slices].buf) { |
915 | ✗ | ret = AVERROR(ENOMEM); | |
916 | ✗ | goto err; | |
917 | } | ||
918 | 603 | buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, | |
919 | 603 | slices[n_slices].buf); | |
920 | 603 | init_get_bits(&slices[n_slices].gb, slices[n_slices].buf, | |
921 | buf_size3 << 3); | ||
922 | 603 | slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9); | |
923 | 603 | slices[n_slices].rawbuf = start; | |
924 | 603 | slices[n_slices].raw_size = size + 4; | |
925 | 603 | n_slices++; | |
926 | 603 | break; | |
927 | } | ||
928 | } | ||
929 | } | ||
930 | ✗ | } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */ | |
931 | const uint8_t *divider; | ||
932 | int buf_size3; | ||
933 | |||
934 | ✗ | divider = find_next_marker(buf, buf + buf_size); | |
935 | ✗ | if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) { | |
936 | ✗ | av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n"); | |
937 | ✗ | ret = AVERROR_INVALIDDATA; | |
938 | ✗ | goto err; | |
939 | } else { // found field marker, unescape second field | ||
940 | ✗ | buf_start_second_field = divider; | |
941 | ✗ | av_size_mult(sizeof(*slices), n_slices+1, &next_allocated); | |
942 | ✗ | tmp = next_allocated ? av_fast_realloc(slices, &slices_allocated, next_allocated) : NULL; | |
943 | ✗ | if (!tmp) { | |
944 | ✗ | ret = AVERROR(ENOMEM); | |
945 | ✗ | goto err; | |
946 | } | ||
947 | ✗ | slices = tmp; | |
948 | ✗ | slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE); | |
949 | ✗ | if (!slices[n_slices].buf) { | |
950 | ✗ | ret = AVERROR(ENOMEM); | |
951 | ✗ | goto err; | |
952 | } | ||
953 | ✗ | buf_size3 = v->vc1dsp.vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf); | |
954 | ✗ | init_get_bits(&slices[n_slices].gb, slices[n_slices].buf, | |
955 | buf_size3 << 3); | ||
956 | ✗ | slices[n_slices].mby_start = s->mb_height + 1 >> 1; | |
957 | ✗ | slices[n_slices].rawbuf = divider; | |
958 | ✗ | slices[n_slices].raw_size = buf + buf_size - divider; | |
959 | ✗ | n_slices1 = n_slices - 1; | |
960 | ✗ | n_slices++; | |
961 | } | ||
962 | ✗ | buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, divider - buf, buf2); | |
963 | } else { | ||
964 | ✗ | buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2); | |
965 | } | ||
966 | 306 | init_get_bits(&s->gb, buf2, buf_size2*8); | |
967 | } else{ | ||
968 | 183 | ret = init_get_bits8(&s->gb, buf, buf_size); | |
969 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
|
183 | if (ret < 0) |
970 | ✗ | return ret; | |
971 | } | ||
972 | |||
973 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
|
489 | if (v->res_sprite) { |
974 | ✗ | v->new_sprite = !get_bits1(&s->gb); | |
975 | ✗ | v->two_sprites = get_bits1(&s->gb); | |
976 | /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means | ||
977 | we're using the sprite compositor. These are intentionally kept separate | ||
978 | so you can get the raw sprites by using the wmv3 decoder for WMVP or | ||
979 | the vc1 one for WVP2 */ | ||
980 | ✗ | if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) { | |
981 | ✗ | if (v->new_sprite) { | |
982 | // switch AVCodecContext parameters to those of the sprites | ||
983 | ✗ | avctx->width = avctx->coded_width = v->sprite_width; | |
984 | ✗ | avctx->height = avctx->coded_height = v->sprite_height; | |
985 | } else { | ||
986 | ✗ | goto image; | |
987 | } | ||
988 | } | ||
989 | } | ||
990 | |||
991 |
2/2✓ Branch 0 taken 467 times.
✓ Branch 1 taken 22 times.
|
489 | if (s->context_initialized && |
992 |
1/2✓ Branch 0 taken 467 times.
✗ Branch 1 not taken.
|
467 | (s->width != avctx->coded_width || |
993 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 467 times.
|
467 | s->height != avctx->coded_height)) { |
994 | ✗ | ff_vc1_decode_end(avctx); | |
995 | } | ||
996 | |||
997 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 467 times.
|
489 | if (!s->context_initialized) { |
998 | 22 | ret = ff_vc1_decode_init(avctx); | |
999 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (ret < 0) |
1000 | ✗ | goto err; | |
1001 | |||
1002 |
3/4✓ Branch 0 taken 17 times.
✓ Branch 1 taken 5 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 17 times.
|
22 | s->low_delay = !avctx->has_b_frames || v->res_sprite; |
1003 | |||
1004 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 7 times.
|
22 | if (v->profile == PROFILE_ADVANCED) { |
1005 |
2/4✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15 times.
|
15 | if(avctx->coded_width<=1 || avctx->coded_height<=1) { |
1006 | ✗ | ret = AVERROR_INVALIDDATA; | |
1007 | ✗ | goto err; | |
1008 | } | ||
1009 | 15 | s->h_edge_pos = avctx->coded_width; | |
1010 | 15 | s->v_edge_pos = avctx->coded_height; | |
1011 | } | ||
1012 | } | ||
1013 | |||
1014 | // do parse frame header | ||
1015 | 489 | v->pic_header_flag = 0; | |
1016 | 489 | v->first_pic_header_flag = 1; | |
1017 |
2/2✓ Branch 0 taken 183 times.
✓ Branch 1 taken 306 times.
|
489 | if (v->profile < PROFILE_ADVANCED) { |
1018 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 183 times.
|
183 | if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) { |
1019 | ✗ | goto err; | |
1020 | } | ||
1021 | } else { | ||
1022 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 306 times.
|
306 | if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) { |
1023 | ✗ | goto err; | |
1024 | } | ||
1025 | } | ||
1026 | 489 | v->first_pic_header_flag = 0; | |
1027 | |||
1028 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
|
489 | if (avctx->debug & FF_DEBUG_PICT_INFO) |
1029 | ✗ | av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type)); | |
1030 | |||
1031 |
2/4✓ Branch 0 taken 489 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 489 times.
|
489 | if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) |
1032 | ✗ | && s->pict_type != AV_PICTURE_TYPE_I) { | |
1033 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n"); | |
1034 | ✗ | ret = AVERROR_INVALIDDATA; | |
1035 | ✗ | goto err; | |
1036 | } | ||
1037 |
2/4✓ Branch 0 taken 489 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 489 times.
|
489 | if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) |
1038 | ✗ | && v->field_mode) { | |
1039 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n"); | |
1040 | ✗ | ret = AVERROR_INVALIDDATA; | |
1041 | ✗ | goto err; | |
1042 | } | ||
1043 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
|
489 | if ((s->mb_height >> v->field_mode) == 0) { |
1044 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n"); | |
1045 | ✗ | ret = AVERROR_INVALIDDATA; | |
1046 | ✗ | goto err; | |
1047 | } | ||
1048 | |||
1049 | /* skip B-frames if we don't have reference frames */ | ||
1050 |
3/4✓ Branch 0 taken 32 times.
✓ Branch 1 taken 457 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 32 times.
|
489 | if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) { |
1051 | ✗ | av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n"); | |
1052 | ✗ | goto end; | |
1053 | } | ||
1054 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
489 | if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) || |
1055 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
489 | (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) || |
1056 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
|
489 | avctx->skip_frame >= AVDISCARD_ALL) { |
1057 | ✗ | goto end; | |
1058 | } | ||
1059 | |||
1060 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 489 times.
|
489 | if ((ret = ff_mpv_frame_start(s, avctx)) < 0) { |
1061 | ✗ | goto err; | |
1062 | } | ||
1063 | |||
1064 | 489 | v->s.current_picture_ptr->field_picture = v->field_mode; | |
1065 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 444 times.
|
489 | v->s.current_picture_ptr->f->flags |= AV_FRAME_FLAG_INTERLACED * (v->fcm != PROGRESSIVE); |
1066 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 444 times.
|
489 | v->s.current_picture_ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !!v->tff; |
1067 | |||
1068 | // process pulldown flags | ||
1069 | 489 | s->current_picture_ptr->f->repeat_pict = 0; | |
1070 | // Pulldown flags are only valid when 'broadcast' has been set. | ||
1071 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
|
489 | if (v->rff) { |
1072 | // repeat field | ||
1073 | ✗ | s->current_picture_ptr->f->repeat_pict = 1; | |
1074 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
|
489 | } else if (v->rptfrm) { |
1075 | // repeat frames | ||
1076 | ✗ | s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2; | |
1077 | } | ||
1078 | |||
1079 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
|
489 | if (avctx->hwaccel) { |
1080 | ✗ | const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel); | |
1081 | ✗ | s->mb_y = 0; | |
1082 | ✗ | if (v->field_mode && buf_start_second_field) { | |
1083 | // decode first field | ||
1084 | ✗ | s->picture_structure = PICT_BOTTOM_FIELD - v->tff; | |
1085 | ✗ | ret = hwaccel->start_frame(avctx, buf_start, | |
1086 | ✗ | buf_start_second_field - buf_start); | |
1087 | ✗ | if (ret < 0) | |
1088 | ✗ | goto err; | |
1089 | |||
1090 | ✗ | if (n_slices1 == -1) { | |
1091 | // no slices, decode the field as-is | ||
1092 | ✗ | ret = hwaccel->decode_slice(avctx, buf_start, | |
1093 | ✗ | buf_start_second_field - buf_start); | |
1094 | ✗ | if (ret < 0) | |
1095 | ✗ | goto err; | |
1096 | } else { | ||
1097 | ✗ | ret = hwaccel->decode_slice(avctx, buf_start, | |
1098 | ✗ | slices[0].rawbuf - buf_start); | |
1099 | ✗ | if (ret < 0) | |
1100 | ✗ | goto err; | |
1101 | |||
1102 | ✗ | for (i = 0 ; i < n_slices1 + 1; i++) { | |
1103 | ✗ | s->gb = slices[i].gb; | |
1104 | ✗ | s->mb_y = slices[i].mby_start; | |
1105 | |||
1106 | ✗ | v->pic_header_flag = get_bits1(&s->gb); | |
1107 | ✗ | if (v->pic_header_flag) { | |
1108 | ✗ | if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) { | |
1109 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n"); | |
1110 | ✗ | ret = AVERROR_INVALIDDATA; | |
1111 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
1112 | ✗ | goto err; | |
1113 | ✗ | continue; | |
1114 | } | ||
1115 | } | ||
1116 | |||
1117 | ✗ | ret = hwaccel->decode_slice(avctx, slices[i].rawbuf, | |
1118 | ✗ | slices[i].raw_size); | |
1119 | ✗ | if (ret < 0) | |
1120 | ✗ | goto err; | |
1121 | } | ||
1122 | } | ||
1123 | |||
1124 | ✗ | if ((ret = hwaccel->end_frame(avctx)) < 0) | |
1125 | ✗ | goto err; | |
1126 | |||
1127 | // decode second field | ||
1128 | ✗ | s->gb = slices[n_slices1 + 1].gb; | |
1129 | ✗ | s->mb_y = slices[n_slices1 + 1].mby_start; | |
1130 | ✗ | s->picture_structure = PICT_TOP_FIELD + v->tff; | |
1131 | ✗ | v->second_field = 1; | |
1132 | ✗ | v->pic_header_flag = 0; | |
1133 | ✗ | if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) { | |
1134 | ✗ | av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed"); | |
1135 | ✗ | ret = AVERROR_INVALIDDATA; | |
1136 | ✗ | goto err; | |
1137 | } | ||
1138 | ✗ | v->s.current_picture_ptr->f->pict_type = v->s.pict_type; | |
1139 | |||
1140 | ✗ | ret = hwaccel->start_frame(avctx, buf_start_second_field, | |
1141 | ✗ | (buf + buf_size) - buf_start_second_field); | |
1142 | ✗ | if (ret < 0) | |
1143 | ✗ | goto err; | |
1144 | |||
1145 | ✗ | if (n_slices - n_slices1 == 2) { | |
1146 | // no slices, decode the field as-is | ||
1147 | ✗ | ret = hwaccel->decode_slice(avctx, buf_start_second_field, | |
1148 | ✗ | (buf + buf_size) - buf_start_second_field); | |
1149 | ✗ | if (ret < 0) | |
1150 | ✗ | goto err; | |
1151 | } else { | ||
1152 | ✗ | ret = hwaccel->decode_slice(avctx, buf_start_second_field, | |
1153 | ✗ | slices[n_slices1 + 2].rawbuf - buf_start_second_field); | |
1154 | ✗ | if (ret < 0) | |
1155 | ✗ | goto err; | |
1156 | |||
1157 | ✗ | for (i = n_slices1 + 2; i < n_slices; i++) { | |
1158 | ✗ | s->gb = slices[i].gb; | |
1159 | ✗ | s->mb_y = slices[i].mby_start; | |
1160 | |||
1161 | ✗ | v->pic_header_flag = get_bits1(&s->gb); | |
1162 | ✗ | if (v->pic_header_flag) { | |
1163 | ✗ | if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) { | |
1164 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n"); | |
1165 | ✗ | ret = AVERROR_INVALIDDATA; | |
1166 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
1167 | ✗ | goto err; | |
1168 | ✗ | continue; | |
1169 | } | ||
1170 | } | ||
1171 | |||
1172 | ✗ | ret = hwaccel->decode_slice(avctx, slices[i].rawbuf, | |
1173 | ✗ | slices[i].raw_size); | |
1174 | ✗ | if (ret < 0) | |
1175 | ✗ | goto err; | |
1176 | } | ||
1177 | } | ||
1178 | |||
1179 | ✗ | if ((ret = hwaccel->end_frame(avctx)) < 0) | |
1180 | ✗ | goto err; | |
1181 | } else { | ||
1182 | ✗ | s->picture_structure = PICT_FRAME; | |
1183 | ✗ | ret = hwaccel->start_frame(avctx, buf_start, | |
1184 | ✗ | (buf + buf_size) - buf_start); | |
1185 | ✗ | if (ret < 0) | |
1186 | ✗ | goto err; | |
1187 | |||
1188 | ✗ | if (n_slices == 0) { | |
1189 | // no slices, decode the frame as-is | ||
1190 | ✗ | ret = hwaccel->decode_slice(avctx, buf_start, | |
1191 | ✗ | (buf + buf_size) - buf_start); | |
1192 | ✗ | if (ret < 0) | |
1193 | ✗ | goto err; | |
1194 | } else { | ||
1195 | // decode the frame part as the first slice | ||
1196 | ✗ | ret = hwaccel->decode_slice(avctx, buf_start, | |
1197 | ✗ | slices[0].rawbuf - buf_start); | |
1198 | ✗ | if (ret < 0) | |
1199 | ✗ | goto err; | |
1200 | |||
1201 | // and process the slices as additional slices afterwards | ||
1202 | ✗ | for (i = 0 ; i < n_slices; i++) { | |
1203 | ✗ | s->gb = slices[i].gb; | |
1204 | ✗ | s->mb_y = slices[i].mby_start; | |
1205 | |||
1206 | ✗ | v->pic_header_flag = get_bits1(&s->gb); | |
1207 | ✗ | if (v->pic_header_flag) { | |
1208 | ✗ | if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) { | |
1209 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n"); | |
1210 | ✗ | ret = AVERROR_INVALIDDATA; | |
1211 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
1212 | ✗ | goto err; | |
1213 | ✗ | continue; | |
1214 | } | ||
1215 | } | ||
1216 | |||
1217 | ✗ | ret = hwaccel->decode_slice(avctx, slices[i].rawbuf, | |
1218 | ✗ | slices[i].raw_size); | |
1219 | ✗ | if (ret < 0) | |
1220 | ✗ | goto err; | |
1221 | } | ||
1222 | } | ||
1223 | ✗ | if ((ret = hwaccel->end_frame(avctx)) < 0) | |
1224 | ✗ | goto err; | |
1225 | } | ||
1226 | } else { | ||
1227 | 489 | int header_ret = 0; | |
1228 | |||
1229 | 489 | ff_mpeg_er_frame_start(s); | |
1230 | |||
1231 | 489 | v->end_mb_x = s->mb_width; | |
1232 |
2/2✓ Branch 0 taken 37 times.
✓ Branch 1 taken 452 times.
|
489 | if (v->field_mode) { |
1233 | 37 | s->current_picture.f->linesize[0] <<= 1; | |
1234 | 37 | s->current_picture.f->linesize[1] <<= 1; | |
1235 | 37 | s->current_picture.f->linesize[2] <<= 1; | |
1236 | 37 | s->linesize <<= 1; | |
1237 | 37 | s->uvlinesize <<= 1; | |
1238 | } | ||
1239 | 489 | mb_height = s->mb_height >> v->field_mode; | |
1240 | |||
1241 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
|
489 | av_assert0 (mb_height > 0); |
1242 | |||
1243 |
2/2✓ Branch 0 taken 1129 times.
✓ Branch 1 taken 489 times.
|
1618 | for (i = 0; i <= n_slices; i++) { |
1244 |
4/4✓ Branch 0 taken 640 times.
✓ Branch 1 taken 489 times.
✓ Branch 2 taken 37 times.
✓ Branch 3 taken 603 times.
|
1129 | if (i > 0 && slices[i - 1].mby_start >= mb_height) { |
1245 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | if (v->field_mode <= 0) { |
1246 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond " | |
1247 | "picture boundary (%d >= %d)\n", i, | ||
1248 | ✗ | slices[i - 1].mby_start, mb_height); | |
1249 | ✗ | continue; | |
1250 | } | ||
1251 | 37 | v->second_field = 1; | |
1252 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | av_assert0((s->mb_height & 1) == 0); |
1253 | 37 | v->blocks_off = s->b8_stride * (s->mb_height&~1); | |
1254 | 37 | v->mb_off = s->mb_stride * s->mb_height >> 1; | |
1255 | } else { | ||
1256 | 1092 | v->second_field = 0; | |
1257 | 1092 | v->blocks_off = 0; | |
1258 | 1092 | v->mb_off = 0; | |
1259 | } | ||
1260 |
2/2✓ Branch 0 taken 640 times.
✓ Branch 1 taken 489 times.
|
1129 | if (i) { |
1261 | 640 | v->pic_header_flag = 0; | |
1262 |
3/4✓ Branch 0 taken 37 times.
✓ Branch 1 taken 603 times.
✓ Branch 2 taken 37 times.
✗ Branch 3 not taken.
|
640 | if (v->field_mode && i == n_slices1 + 2) { |
1263 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 37 times.
|
37 | if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) { |
1264 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n"); | |
1265 | ✗ | ret = AVERROR_INVALIDDATA; | |
1266 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
1267 | ✗ | goto err; | |
1268 | ✗ | continue; | |
1269 | } | ||
1270 |
2/2✓ Branch 1 taken 273 times.
✓ Branch 2 taken 330 times.
|
603 | } else if (get_bits1(&s->gb)) { |
1271 | 273 | v->pic_header_flag = 1; | |
1272 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 273 times.
|
273 | if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) { |
1273 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n"); | |
1274 | ✗ | ret = AVERROR_INVALIDDATA; | |
1275 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
1276 | ✗ | goto err; | |
1277 | ✗ | continue; | |
1278 | } | ||
1279 | } | ||
1280 | } | ||
1281 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1129 times.
|
1129 | if (header_ret < 0) |
1282 | ✗ | continue; | |
1283 |
2/2✓ Branch 0 taken 640 times.
✓ Branch 1 taken 489 times.
|
1129 | s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height); |
1284 |
4/4✓ Branch 0 taken 74 times.
✓ Branch 1 taken 1055 times.
✓ Branch 2 taken 37 times.
✓ Branch 3 taken 37 times.
|
1129 | if (!v->field_mode || v->second_field) |
1285 |
2/2✓ Branch 0 taken 603 times.
✓ Branch 1 taken 489 times.
|
1092 | s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height); |
1286 | else { | ||
1287 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | if (i >= n_slices) { |
1288 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n"); | |
1289 | ✗ | continue; | |
1290 | } | ||
1291 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
|
37 | s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height); |
1292 | } | ||
1293 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1129 times.
|
1129 | if (s->end_mb_y <= s->start_mb_y) { |
1294 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y); | |
1295 | ✗ | continue; | |
1296 | } | ||
1297 |
4/4✓ Branch 0 taken 984 times.
✓ Branch 1 taken 145 times.
✓ Branch 2 taken 67 times.
✓ Branch 3 taken 917 times.
|
1129 | if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) || |
1298 |
3/4✓ Branch 0 taken 109 times.
✓ Branch 1 taken 103 times.
✓ Branch 2 taken 109 times.
✗ Branch 3 not taken.
|
212 | (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) && |
1299 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1026 times.
|
1026 | !v->cbpcy_vlc) { |
1300 | ✗ | av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n"); | |
1301 | ✗ | continue; | |
1302 | } | ||
1303 | 1129 | ff_vc1_decode_blocks(v); | |
1304 |
2/2✓ Branch 0 taken 640 times.
✓ Branch 1 taken 489 times.
|
1129 | if (i != n_slices) { |
1305 | 640 | s->gb = slices[i].gb; | |
1306 | } | ||
1307 | } | ||
1308 |
2/2✓ Branch 0 taken 37 times.
✓ Branch 1 taken 452 times.
|
489 | if (v->field_mode) { |
1309 | 37 | v->second_field = 0; | |
1310 | 37 | s->current_picture.f->linesize[0] >>= 1; | |
1311 | 37 | s->current_picture.f->linesize[1] >>= 1; | |
1312 | 37 | s->current_picture.f->linesize[2] >>= 1; | |
1313 | 37 | s->linesize >>= 1; | |
1314 | 37 | s->uvlinesize >>= 1; | |
1315 |
3/4✓ Branch 0 taken 37 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 18 times.
|
37 | if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) { |
1316 | 19 | FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]); | |
1317 | 19 | FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]); | |
1318 | } | ||
1319 | } | ||
1320 | ff_dlog(s->avctx, "Consumed %i/%i bits\n", | ||
1321 | get_bits_count(&s->gb), s->gb.size_in_bits); | ||
1322 | // if (get_bits_count(&s->gb) > buf_size * 8) | ||
1323 | // return -1; | ||
1324 |
3/4✓ Branch 0 taken 1 times.
✓ Branch 1 taken 488 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
|
489 | if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) { |
1325 | ✗ | ret = AVERROR_INVALIDDATA; | |
1326 | ✗ | goto err; | |
1327 | } | ||
1328 |
2/2✓ Branch 0 taken 452 times.
✓ Branch 1 taken 37 times.
|
489 | if ( !v->field_mode |
1329 |
1/2✓ Branch 0 taken 452 times.
✗ Branch 1 not taken.
|
452 | && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE |
1330 |
1/2✓ Branch 0 taken 452 times.
✗ Branch 1 not taken.
|
452 | && avctx->codec_id != AV_CODEC_ID_VC1IMAGE) |
1331 | 452 | ff_er_frame_end(&s->er, NULL); | |
1332 | } | ||
1333 | |||
1334 | 489 | ff_mpv_frame_end(s); | |
1335 | |||
1336 |
2/4✗ Branch 0 not taken.
✓ Branch 1 taken 489 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 489 times.
|
489 | if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) { |
1337 | ✗ | image: | |
1338 | ✗ | avctx->width = avctx->coded_width = v->output_width; | |
1339 | ✗ | avctx->height = avctx->coded_height = v->output_height; | |
1340 | ✗ | if (avctx->skip_frame >= AVDISCARD_NONREF) | |
1341 | ✗ | goto end; | |
1342 | ✗ | if (!v->sprite_output_frame && | |
1343 | ✗ | !(v->sprite_output_frame = av_frame_alloc())) { | |
1344 | ✗ | ret = AVERROR(ENOMEM); | |
1345 | ✗ | goto err; | |
1346 | } | ||
1347 | #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER | ||
1348 | ✗ | if ((ret = vc1_decode_sprites(v, &s->gb)) < 0) | |
1349 | ✗ | goto err; | |
1350 | #endif | ||
1351 | ✗ | if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0) | |
1352 | ✗ | goto err; | |
1353 | ✗ | *got_frame = 1; | |
1354 | } else { | ||
1355 |
4/4✓ Branch 0 taken 398 times.
✓ Branch 1 taken 91 times.
✓ Branch 2 taken 158 times.
✓ Branch 3 taken 240 times.
|
489 | if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { |
1356 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 249 times.
|
249 | if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0) |
1357 | ✗ | goto err; | |
1358 |
2/2✓ Branch 0 taken 231 times.
✓ Branch 1 taken 18 times.
|
249 | if (!v->field_mode) |
1359 | 231 | ff_print_debug_info(s, s->current_picture_ptr, pict); | |
1360 | 249 | *got_frame = 1; | |
1361 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 223 times.
|
240 | } else if (s->last_picture_ptr) { |
1362 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 223 times.
|
223 | if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0) |
1363 | ✗ | goto err; | |
1364 |
2/2✓ Branch 0 taken 206 times.
✓ Branch 1 taken 17 times.
|
223 | if (!v->field_mode) |
1365 | 206 | ff_print_debug_info(s, s->last_picture_ptr, pict); | |
1366 | 223 | *got_frame = 1; | |
1367 | } | ||
1368 | } | ||
1369 | |||
1370 | 17 | end: | |
1371 | 489 | av_free(buf2); | |
1372 |
2/2✓ Branch 0 taken 640 times.
✓ Branch 1 taken 489 times.
|
1129 | for (i = 0; i < n_slices; i++) |
1373 | 640 | av_free(slices[i].buf); | |
1374 | 489 | av_free(slices); | |
1375 | 489 | return buf_size; | |
1376 | |||
1377 | ✗ | err: | |
1378 | ✗ | av_free(buf2); | |
1379 | ✗ | for (i = 0; i < n_slices; i++) | |
1380 | ✗ | av_free(slices[i].buf); | |
1381 | ✗ | av_free(slices); | |
1382 | ✗ | return ret; | |
1383 | } | ||
1384 | |||
1385 | |||
1386 | const FFCodec ff_vc1_decoder = { | ||
1387 | .p.name = "vc1", | ||
1388 | CODEC_LONG_NAME("SMPTE VC-1"), | ||
1389 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1390 | .p.id = AV_CODEC_ID_VC1, | ||
1391 | .priv_data_size = sizeof(VC1Context), | ||
1392 | .init = vc1_decode_init, | ||
1393 | .close = ff_vc1_decode_end, | ||
1394 | FF_CODEC_DECODE_CB(vc1_decode_frame), | ||
1395 | .flush = ff_mpeg_flush, | ||
1396 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, | ||
1397 | .hw_configs = (const AVCodecHWConfigInternal *const []) { | ||
1398 | #if CONFIG_VC1_DXVA2_HWACCEL | ||
1399 | HWACCEL_DXVA2(vc1), | ||
1400 | #endif | ||
1401 | #if CONFIG_VC1_D3D11VA_HWACCEL | ||
1402 | HWACCEL_D3D11VA(vc1), | ||
1403 | #endif | ||
1404 | #if CONFIG_VC1_D3D11VA2_HWACCEL | ||
1405 | HWACCEL_D3D11VA2(vc1), | ||
1406 | #endif | ||
1407 | #if CONFIG_VC1_D3D12VA_HWACCEL | ||
1408 | HWACCEL_D3D12VA(vc1), | ||
1409 | #endif | ||
1410 | #if CONFIG_VC1_NVDEC_HWACCEL | ||
1411 | HWACCEL_NVDEC(vc1), | ||
1412 | #endif | ||
1413 | #if CONFIG_VC1_VAAPI_HWACCEL | ||
1414 | HWACCEL_VAAPI(vc1), | ||
1415 | #endif | ||
1416 | #if CONFIG_VC1_VDPAU_HWACCEL | ||
1417 | HWACCEL_VDPAU(vc1), | ||
1418 | #endif | ||
1419 | NULL | ||
1420 | }, | ||
1421 | .p.profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles) | ||
1422 | }; | ||
1423 | |||
1424 | #if CONFIG_WMV3_DECODER | ||
1425 | const FFCodec ff_wmv3_decoder = { | ||
1426 | .p.name = "wmv3", | ||
1427 | CODEC_LONG_NAME("Windows Media Video 9"), | ||
1428 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1429 | .p.id = AV_CODEC_ID_WMV3, | ||
1430 | .priv_data_size = sizeof(VC1Context), | ||
1431 | .init = vc1_decode_init, | ||
1432 | .close = ff_vc1_decode_end, | ||
1433 | FF_CODEC_DECODE_CB(vc1_decode_frame), | ||
1434 | .flush = ff_mpeg_flush, | ||
1435 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, | ||
1436 | .hw_configs = (const AVCodecHWConfigInternal *const []) { | ||
1437 | #if CONFIG_WMV3_DXVA2_HWACCEL | ||
1438 | HWACCEL_DXVA2(wmv3), | ||
1439 | #endif | ||
1440 | #if CONFIG_WMV3_D3D11VA_HWACCEL | ||
1441 | HWACCEL_D3D11VA(wmv3), | ||
1442 | #endif | ||
1443 | #if CONFIG_WMV3_D3D11VA2_HWACCEL | ||
1444 | HWACCEL_D3D11VA2(wmv3), | ||
1445 | #endif | ||
1446 | #if CONFIG_WMV3_D3D12VA_HWACCEL | ||
1447 | HWACCEL_D3D12VA(wmv3), | ||
1448 | #endif | ||
1449 | #if CONFIG_WMV3_NVDEC_HWACCEL | ||
1450 | HWACCEL_NVDEC(wmv3), | ||
1451 | #endif | ||
1452 | #if CONFIG_WMV3_VAAPI_HWACCEL | ||
1453 | HWACCEL_VAAPI(wmv3), | ||
1454 | #endif | ||
1455 | #if CONFIG_WMV3_VDPAU_HWACCEL | ||
1456 | HWACCEL_VDPAU(wmv3), | ||
1457 | #endif | ||
1458 | NULL | ||
1459 | }, | ||
1460 | .p.profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles) | ||
1461 | }; | ||
1462 | #endif | ||
1463 | |||
1464 | #if CONFIG_WMV3IMAGE_DECODER | ||
1465 | const FFCodec ff_wmv3image_decoder = { | ||
1466 | .p.name = "wmv3image", | ||
1467 | CODEC_LONG_NAME("Windows Media Video 9 Image"), | ||
1468 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1469 | .p.id = AV_CODEC_ID_WMV3IMAGE, | ||
1470 | .priv_data_size = sizeof(VC1Context), | ||
1471 | .init = vc1_decode_init, | ||
1472 | .close = ff_vc1_decode_end, | ||
1473 | FF_CODEC_DECODE_CB(vc1_decode_frame), | ||
1474 | .p.capabilities = AV_CODEC_CAP_DR1, | ||
1475 | .flush = vc1_sprite_flush, | ||
1476 | }; | ||
1477 | #endif | ||
1478 | |||
1479 | #if CONFIG_VC1IMAGE_DECODER | ||
1480 | const FFCodec ff_vc1image_decoder = { | ||
1481 | .p.name = "vc1image", | ||
1482 | CODEC_LONG_NAME("Windows Media Video 9 Image v2"), | ||
1483 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1484 | .p.id = AV_CODEC_ID_VC1IMAGE, | ||
1485 | .priv_data_size = sizeof(VC1Context), | ||
1486 | .init = vc1_decode_init, | ||
1487 | .close = ff_vc1_decode_end, | ||
1488 | FF_CODEC_DECODE_CB(vc1_decode_frame), | ||
1489 | .p.capabilities = AV_CODEC_CAP_DR1, | ||
1490 | .flush = vc1_sprite_flush, | ||
1491 | }; | ||
1492 | #endif | ||
1493 |