FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/vc1dec.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 329 752 43.8%
Branches: 198 550 36.0%

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 "avcodec.h"
30 #include "blockdsp.h"
31 #include "get_bits.h"
32 #include "hwconfig.h"
33 #include "internal.h"
34 #include "mpeg_er.h"
35 #include "mpegvideo.h"
36 #include "msmpeg4.h"
37 #include "msmpeg4data.h"
38 #include "profiles.h"
39 #include "vc1.h"
40 #include "vc1data.h"
41 #include "libavutil/avassert.h"
42
43
44 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
45
46 typedef struct SpriteData {
47 /**
48 * Transform coefficients for both sprites in 16.16 fixed point format,
49 * in the order they appear in the bitstream:
50 * x scale
51 * rotation 1 (unused)
52 * x offset
53 * rotation 2 (unused)
54 * y scale
55 * y offset
56 * alpha
57 */
58 int coefs[2][7];
59
60 int effect_type, effect_flag;
61 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
62 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
63 } SpriteData;
64
65 static inline int get_fp_val(GetBitContext* gb)
66 {
67 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
68 }
69
70 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
71 {
72 c[1] = c[3] = 0;
73
74 switch (get_bits(gb, 2)) {
75 case 0:
76 c[0] = 1 << 16;
77 c[2] = get_fp_val(gb);
78 c[4] = 1 << 16;
79 break;
80 case 1:
81 c[0] = c[4] = get_fp_val(gb);
82 c[2] = get_fp_val(gb);
83 break;
84 case 2:
85 c[0] = get_fp_val(gb);
86 c[2] = get_fp_val(gb);
87 c[4] = get_fp_val(gb);
88 break;
89 case 3:
90 c[0] = get_fp_val(gb);
91 c[1] = get_fp_val(gb);
92 c[2] = get_fp_val(gb);
93 c[3] = get_fp_val(gb);
94 c[4] = get_fp_val(gb);
95 break;
96 }
97 c[5] = get_fp_val(gb);
98 if (get_bits1(gb))
99 c[6] = get_fp_val(gb);
100 else
101 c[6] = 1 << 16;
102 }
103
104 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
105 {
106 AVCodecContext *avctx = v->s.avctx;
107 int sprite, i;
108
109 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
110 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
111 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
112 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
113 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
114 for (i = 0; i < 7; i++)
115 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
116 sd->coefs[sprite][i] / (1<<16),
117 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
118 av_log(avctx, AV_LOG_DEBUG, "\n");
119 }
120
121 skip_bits(gb, 2);
122 if (sd->effect_type = get_bits_long(gb, 30)) {
123 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
124 case 7:
125 vc1_sprite_parse_transform(gb, sd->effect_params1);
126 break;
127 case 14:
128 vc1_sprite_parse_transform(gb, sd->effect_params1);
129 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
130 break;
131 default:
132 for (i = 0; i < sd->effect_pcount1; i++)
133 sd->effect_params1[i] = get_fp_val(gb);
134 }
135 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
136 // effect 13 is simple alpha blending and matches the opacity above
137 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
138 for (i = 0; i < sd->effect_pcount1; i++)
139 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
140 sd->effect_params1[i] / (1 << 16),
141 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
142 av_log(avctx, AV_LOG_DEBUG, "\n");
143 }
144
145 sd->effect_pcount2 = get_bits(gb, 16);
146 if (sd->effect_pcount2 > 10) {
147 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
148 return AVERROR_INVALIDDATA;
149 } else if (sd->effect_pcount2) {
150 i = -1;
151 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
152 while (++i < sd->effect_pcount2) {
153 sd->effect_params2[i] = get_fp_val(gb);
154 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
155 sd->effect_params2[i] / (1 << 16),
156 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
157 }
158 av_log(avctx, AV_LOG_DEBUG, "\n");
159 }
160 }
161 if (sd->effect_flag = get_bits1(gb))
162 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
163
164 if (get_bits_count(gb) >= gb->size_in_bits +
165 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
166 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
167 return AVERROR_INVALIDDATA;
168 }
169 if (get_bits_count(gb) < gb->size_in_bits - 8)
170 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
171
172 return 0;
173 }
174
175 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
176 {
177 int i, plane, row, sprite;
178 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
179 uint8_t* src_h[2][2];
180 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
181 int ysub[2];
182 MpegEncContext *s = &v->s;
183
184 for (i = 0; i <= v->two_sprites; i++) {
185 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
186 xadv[i] = sd->coefs[i][0];
187 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
188 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
189
190 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
191 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
192 }
193 alpha = av_clip_uint16(sd->coefs[1][6]);
194
195 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
196 int width = v->output_width>>!!plane;
197
198 for (row = 0; row < v->output_height>>!!plane; row++) {
199 uint8_t *dst = v->sprite_output_frame->data[plane] +
200 v->sprite_output_frame->linesize[plane] * row;
201
202 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
203 uint8_t *iplane = s->current_picture.f->data[plane];
204 int iline = s->current_picture.f->linesize[plane];
205 int ycoord = yoff[sprite] + yadv[sprite] * row;
206 int yline = ycoord >> 16;
207 int next_line;
208 ysub[sprite] = ycoord & 0xFFFF;
209 if (sprite) {
210 iplane = s->last_picture.f->data[plane];
211 iline = s->last_picture.f->linesize[plane];
212 }
213 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
214 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
215 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
216 if (ysub[sprite])
217 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
218 } else {
219 if (sr_cache[sprite][0] != yline) {
220 if (sr_cache[sprite][1] == yline) {
221 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
222 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
223 } else {
224 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
225 sr_cache[sprite][0] = yline;
226 }
227 }
228 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
229 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
230 iplane + next_line, xoff[sprite],
231 xadv[sprite], width);
232 sr_cache[sprite][1] = yline + 1;
233 }
234 src_h[sprite][0] = v->sr_rows[sprite][0];
235 src_h[sprite][1] = v->sr_rows[sprite][1];
236 }
237 }
238
239 if (!v->two_sprites) {
240 if (ysub[0]) {
241 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
242 } else {
243 memcpy(dst, src_h[0][0], width);
244 }
245 } else {
246 if (ysub[0] && ysub[1]) {
247 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
248 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
249 } else if (ysub[0]) {
250 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
251 src_h[1][0], alpha, width);
252 } else if (ysub[1]) {
253 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
254 src_h[0][0], (1<<16)-1-alpha, width);
255 } else {
256 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
257 }
258 }
259 }
260
261 if (!plane) {
262 for (i = 0; i <= v->two_sprites; i++) {
263 xoff[i] >>= 1;
264 yoff[i] >>= 1;
265 }
266 }
267
268 }
269 }
270
271
272 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
273 {
274 int ret;
275 MpegEncContext *s = &v->s;
276 AVCodecContext *avctx = s->avctx;
277 SpriteData sd;
278
279 memset(&sd, 0, sizeof(sd));
280
281 ret = vc1_parse_sprites(v, gb, &sd);
282 if (ret < 0)
283 return ret;
284
285 if (!s->current_picture.f || !s->current_picture.f->data[0]) {
286 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
287 return AVERROR_UNKNOWN;
288 }
289
290 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
291 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
292 v->two_sprites = 0;
293 }
294
295 av_frame_unref(v->sprite_output_frame);
296 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
297 return ret;
298
299 vc1_draw_sprites(v, &sd);
300
301 return 0;
302 }
303
304 static void vc1_sprite_flush(AVCodecContext *avctx)
305 {
306 VC1Context *v = avctx->priv_data;
307 MpegEncContext *s = &v->s;
308 AVFrame *f = s->current_picture.f;
309 int plane, i;
310
311 /* Windows Media Image codecs have a convergence interval of two keyframes.
312 Since we can't enforce it, clear to black the missing sprite. This is
313 wrong but it looks better than doing nothing. */
314
315 if (f && f->data[0])
316 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
317 for (i = 0; i < v->sprite_height>>!!plane; i++)
318 memset(f->data[plane] + i * f->linesize[plane],
319 plane ? 128 : 0, f->linesize[plane]);
320 }
321
322 #endif
323
324 42 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
325 {
326 42 MpegEncContext *s = &v->s;
327 42 int i, ret = AVERROR(ENOMEM);
328 42 int mb_height = FFALIGN(s->mb_height, 2);
329
330 /* Allocate mb bitplanes */
331 42 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
332 42 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
333 42 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
334 42 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
335 42 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
336 42 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
337
3/6
✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 42 times.
✗ Branch 5 not taken.
42 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
338
3/6
✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 42 times.
42 !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
339 goto error;
340
341 42 v->n_allocated_blks = s->mb_width + 2;
342 42 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
343 42 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
344
2/4
✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 42 times.
42 if (!v->block || !v->cbp_base)
345 goto error;
346 42 v->cbp = v->cbp_base + 2 * s->mb_stride;
347 42 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
348
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
42 if (!v->ttblk_base)
349 goto error;
350 42 v->ttblk = v->ttblk_base + 2 * s->mb_stride;
351 42 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
352
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
42 if (!v->is_intra_base)
353 goto error;
354 42 v->is_intra = v->is_intra_base + 2 * s->mb_stride;
355 42 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
356
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
42 if (!v->luma_mv_base)
357 goto error;
358 42 v->luma_mv = v->luma_mv_base + 2 * s->mb_stride;
359
360 /* allocate block type info in that way so it could be used with s->block_index[] */
361 42 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
362
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
42 if (!v->mb_type_base)
363 goto error;
364 42 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
365 42 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
366 42 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
367
368 /* allocate memory to store block level MV info */
369 42 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
370
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
42 if (!v->blk_mv_type_base)
371 goto error;
372 42 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
373 42 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
374
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
42 if (!v->mv_f_base)
375 goto error;
376 42 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
377 42 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
378 42 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
379
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
42 if (!v->mv_f_next_base)
380 goto error;
381 42 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
382 42 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
383
384
2/4
✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 42 times.
42 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
385 for (i = 0; i < 4; i++)
386 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
387 goto error;
388 }
389
390 42 ret = ff_intrax8_common_init(s->avctx, &v->x8, &s->idsp,
391 42 s->block, s->block_last_index,
392 s->mb_width, s->mb_height);
393
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
42 if (ret < 0)
394 goto error;
395
396 42 return 0;
397
398 error:
399 ff_vc1_decode_end(s->avctx);
400 return ret;
401 }
402
403 32 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
404 {
405 int i;
406
2/2
✓ Branch 0 taken 2048 times.
✓ Branch 1 taken 32 times.
2080 for (i = 0; i < 64; i++) {
407 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
408 2048 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
409 2048 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
410 2048 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
411 2048 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
412 2048 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
413 }
414 32 v->left_blk_sh = 0;
415 32 v->top_blk_sh = 3;
416 32 }
417
418 /** Initialize a VC1/WMV3 decoder
419 * @todo TODO: Handle VC-1 IDUs (Transport level?)
420 * @todo TODO: Decipher remaining bits in extra_data
421 */
422 28 static av_cold int vc1_decode_init(AVCodecContext *avctx)
423 {
424 28 VC1Context *v = avctx->priv_data;
425 28 MpegEncContext *s = &v->s;
426 GetBitContext gb;
427 int ret;
428
429 /* save the container output size for WMImage */
430 28 v->output_width = avctx->width;
431 28 v->output_height = avctx->height;
432
433
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)
434 6 return AVERROR_INVALIDDATA;
435 22 v->s.avctx = avctx;
436
437 22 ff_vc1_init_common(v);
438
439
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) {
440 7 int count = 0;
441
442 // looks like WMV3 has a sequence header stored in the extradata
443 // advanced sequence header may be before the first frame
444 // the last byte of the extradata is a version number, 1 for the
445 // samples we can decode
446
447 7 ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size);
448
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 if (ret < 0)
449 return ret;
450
451
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
7 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
452 return ret;
453
454
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) {
455 avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
456 return AVERROR_PATCHWELCOME;
457 }
458
459 7 count = avctx->extradata_size*8 - get_bits_count(&gb);
460
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 if (count > 0) {
461 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
462 count, get_bits_long(&gb, FFMIN(count, 32)));
463
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 } else if (count < 0) {
464 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
465 }
466 } else { // VC1/WVC1/WVP2
467 15 const uint8_t *start = avctx->extradata;
468 15 uint8_t *end = avctx->extradata + avctx->extradata_size;
469 const uint8_t *next;
470 int size, buf2_size;
471 15 uint8_t *buf2 = NULL;
472 15 int seq_initialized = 0, ep_initialized = 0;
473
474
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
15 if (avctx->extradata_size < 16) {
475 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
476 return AVERROR_INVALIDDATA;
477 }
478
479 15 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
480
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
15 if (!buf2)
481 return AVERROR(ENOMEM);
482
483 15 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
484 15 next = start;
485
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 15 times.
55 for (; next < end; start = next) {
486 40 next = find_next_marker(start + 4, end);
487 40 size = next - start - 4;
488
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
40 if (size <= 0)
489 continue;
490 40 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
491 40 init_get_bits(&gb, buf2, buf2_size * 8);
492
2/3
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 25 times.
✗ Branch 2 not taken.
40 switch (AV_RB32(start)) {
493 15 case VC1_CODE_SEQHDR:
494
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
15 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
495 av_free(buf2);
496 return ret;
497 }
498 15 seq_initialized = 1;
499 15 break;
500 25 case VC1_CODE_ENTRYPOINT:
501
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 25 times.
25 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
502 av_free(buf2);
503 return ret;
504 }
505 25 ep_initialized = 1;
506 25 break;
507 }
508 }
509 15 av_free(buf2);
510
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) {
511 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
512 return AVERROR_INVALIDDATA;
513 }
514 15 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
515 }
516
517 22 avctx->profile = v->profile;
518
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 7 times.
22 if (v->profile == PROFILE_ADVANCED)
519 15 avctx->level = v->level;
520
521 if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
522 22 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
523 else {
524 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
525 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
526 avctx->color_range = AVCOL_RANGE_MPEG;
527 }
528
529 // ensure static VLC tables are initialized
530
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
22 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
531 return ret;
532
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
22 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
533 return ret;
534 // Hack to ensure the above functions will be called
535 // again once we know all necessary settings.
536 // That this is necessary might indicate a bug.
537 22 ff_vc1_decode_end(avctx);
538
539 22 ff_blockdsp_init(&s->bdsp, avctx);
540 22 ff_h264chroma_init(&v->h264chroma, 8);
541 22 ff_qpeldsp_init(&s->qdsp);
542
543 22 avctx->has_b_frames = !!avctx->max_b_frames;
544
545
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)
546 avctx->color_primaries = v->color_prim;
547
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)
548 avctx->color_trc = v->transfer_char;
549
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)
550 avctx->colorspace = v->matrix_coef;
551
552 22 s->mb_width = (avctx->coded_width + 15) >> 4;
553 22 s->mb_height = (avctx->coded_height + 15) >> 4;
554
555
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) {
556 22 ff_vc1_init_transposed_scantables(v);
557 } else {
558 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
559 v->left_blk_sh = 3;
560 v->top_blk_sh = 0;
561 }
562
563
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) {
564 v->sprite_width = avctx->coded_width;
565 v->sprite_height = avctx->coded_height;
566
567 avctx->coded_width = avctx->width = v->output_width;
568 avctx->coded_height = avctx->height = v->output_height;
569
570 // prevent 16.16 overflows
571 if (v->sprite_width > 1 << 14 ||
572 v->sprite_height > 1 << 14 ||
573 v->output_width > 1 << 14 ||
574 v->output_height > 1 << 14) {
575 return AVERROR_INVALIDDATA;
576 }
577
578 if ((v->sprite_width&1) || (v->sprite_height&1)) {
579 avpriv_request_sample(avctx, "odd sprites support");
580 return AVERROR_PATCHWELCOME;
581 }
582 }
583 22 return 0;
584 }
585
586 /** Close a VC1/WMV3 decoder
587 * @warning Initial try at using MpegEncContext stuff
588 */
589 54 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
590 {
591 54 VC1Context *v = avctx->priv_data;
592 int i;
593
594 54 av_frame_free(&v->sprite_output_frame);
595
596
2/2
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 54 times.
270 for (i = 0; i < 4; i++)
597 216 av_freep(&v->sr_rows[i >> 1][i & 1]);
598 54 ff_mpv_common_end(&v->s);
599 54 av_freep(&v->mv_type_mb_plane);
600 54 av_freep(&v->direct_mb_plane);
601 54 av_freep(&v->forward_mb_plane);
602 54 av_freep(&v->fieldtx_plane);
603 54 av_freep(&v->acpred_plane);
604 54 av_freep(&v->over_flags_plane);
605 54 av_freep(&v->mb_type_base);
606 54 av_freep(&v->blk_mv_type_base);
607 54 av_freep(&v->mv_f_base);
608 54 av_freep(&v->mv_f_next_base);
609 54 av_freep(&v->block);
610 54 av_freep(&v->cbp_base);
611 54 av_freep(&v->ttblk_base);
612 54 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
613 54 av_freep(&v->luma_mv_base);
614 54 ff_intrax8_common_end(&v->x8);
615 54 return 0;
616 }
617
618
619 /** Decode a VC1/WMV3 frame
620 * @todo TODO: Handle VC-1 IDUs (Transport level?)
621 */
622 494 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
623 int *got_frame, AVPacket *avpkt)
624 {
625 494 const uint8_t *buf = avpkt->data;
626 494 int buf_size = avpkt->size, n_slices = 0, i, ret;
627 494 VC1Context *v = avctx->priv_data;
628 494 MpegEncContext *s = &v->s;
629 494 AVFrame *pict = data;
630 494 uint8_t *buf2 = NULL;
631 494 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
632 494 int mb_height, n_slices1=-1;
633 struct {
634 uint8_t *buf;
635 GetBitContext gb;
636 int mby_start;
637 const uint8_t *rawbuf;
638 int raw_size;
639 494 } *slices = NULL, *tmp;
640
641 494 v->second_field = 0;
642
643
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 494 times.
494 if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
644 s->low_delay = 1;
645
646 /* no supplementary picture */
647
5/6
✓ Branch 0 taken 477 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 476 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
494 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
648 /* special case for last picture */
649
4/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 8 times.
18 if (s->low_delay == 0 && s->next_picture_ptr) {
650
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
8 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
651 return ret;
652 8 s->next_picture_ptr = NULL;
653
654 8 *got_frame = 1;
655 }
656
657 18 return buf_size;
658 }
659
660 //for advanced profile we may need to parse and unescape data
661
3/4
✓ Branch 0 taken 178 times.
✓ Branch 1 taken 298 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 178 times.
774 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
662 298 int buf_size2 = 0;
663 298 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
664
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 298 times.
298 if (!buf2)
665 return AVERROR(ENOMEM);
666
667
1/2
✓ Branch 0 taken 298 times.
✗ Branch 1 not taken.
298 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
668 const uint8_t *start, *end, *next;
669 int size;
670
671 298 next = buf;
672
2/2
✓ Branch 0 taken 952 times.
✓ Branch 1 taken 298 times.
1250 for (start = buf, end = buf + buf_size; next < end; start = next) {
673 952 next = find_next_marker(start + 4, end);
674 952 size = next - start - 4;
675
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 952 times.
952 if (size <= 0) continue;
676
5/5
✓ Branch 0 taken 298 times.
✓ Branch 1 taken 36 times.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 597 times.
✓ Branch 4 taken 8 times.
952 switch (AV_RB32(start)) {
677 298 case VC1_CODE_FRAME:
678
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 298 times.
298 if (avctx->hwaccel)
679 buf_start = start;
680 298 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
681 298 break;
682 36 case VC1_CODE_FIELD: {
683 int buf_size3;
684
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (avctx->hwaccel)
685 buf_start_second_field = start;
686 36 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
687
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (!tmp) {
688 ret = AVERROR(ENOMEM);
689 goto err;
690 }
691 36 slices = tmp;
692 36 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
693
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (!slices[n_slices].buf) {
694 ret = AVERROR(ENOMEM);
695 goto err;
696 }
697 36 buf_size3 = vc1_unescape_buffer(start + 4, size,
698 36 slices[n_slices].buf);
699 36 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
700 buf_size3 << 3);
701 36 slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
702 36 slices[n_slices].rawbuf = start;
703 36 slices[n_slices].raw_size = size + 4;
704 36 n_slices1 = n_slices - 1; // index of the last slice of the first field
705 36 n_slices++;
706 36 break;
707 }
708 13 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
709 13 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
710 13 init_get_bits(&s->gb, buf2, buf_size2 * 8);
711 13 ff_vc1_decode_entry_point(avctx, v, &s->gb);
712 13 break;
713 597 case VC1_CODE_SLICE: {
714 int buf_size3;
715 597 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
716
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 597 times.
597 if (!tmp) {
717 ret = AVERROR(ENOMEM);
718 goto err;
719 }
720 597 slices = tmp;
721 597 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
722
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 597 times.
597 if (!slices[n_slices].buf) {
723 ret = AVERROR(ENOMEM);
724 goto err;
725 }
726 597 buf_size3 = vc1_unescape_buffer(start + 4, size,
727 597 slices[n_slices].buf);
728 597 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
729 buf_size3 << 3);
730 597 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
731 597 slices[n_slices].rawbuf = start;
732 597 slices[n_slices].raw_size = size + 4;
733 597 n_slices++;
734 597 break;
735 }
736 }
737 }
738 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
739 const uint8_t *divider;
740 int buf_size3;
741
742 divider = find_next_marker(buf, buf + buf_size);
743 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
744 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
745 ret = AVERROR_INVALIDDATA;
746 goto err;
747 } else { // found field marker, unescape second field
748 if (avctx->hwaccel)
749 buf_start_second_field = divider;
750 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
751 if (!tmp) {
752 ret = AVERROR(ENOMEM);
753 goto err;
754 }
755 slices = tmp;
756 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
757 if (!slices[n_slices].buf) {
758 ret = AVERROR(ENOMEM);
759 goto err;
760 }
761 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
762 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
763 buf_size3 << 3);
764 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
765 slices[n_slices].rawbuf = divider;
766 slices[n_slices].raw_size = buf + buf_size - divider;
767 n_slices1 = n_slices - 1;
768 n_slices++;
769 }
770 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
771 } else {
772 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
773 }
774 298 init_get_bits(&s->gb, buf2, buf_size2*8);
775 } else{
776 178 ret = init_get_bits8(&s->gb, buf, buf_size);
777
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 178 times.
178 if (ret < 0)
778 return ret;
779 }
780
781
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (v->res_sprite) {
782 v->new_sprite = !get_bits1(&s->gb);
783 v->two_sprites = get_bits1(&s->gb);
784 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
785 we're using the sprite compositor. These are intentionally kept separate
786 so you can get the raw sprites by using the wmv3 decoder for WMVP or
787 the vc1 one for WVP2 */
788 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
789 if (v->new_sprite) {
790 // switch AVCodecContext parameters to those of the sprites
791 avctx->width = avctx->coded_width = v->sprite_width;
792 avctx->height = avctx->coded_height = v->sprite_height;
793 } else {
794 goto image;
795 }
796 }
797 }
798
799
2/2
✓ Branch 0 taken 466 times.
✓ Branch 1 taken 10 times.
476 if (s->context_initialized &&
800
1/2
✓ Branch 0 taken 466 times.
✗ Branch 1 not taken.
466 (s->width != avctx->coded_width ||
801
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 466 times.
466 s->height != avctx->coded_height)) {
802 ff_vc1_decode_end(avctx);
803 }
804
805
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 466 times.
476 if (!s->context_initialized) {
806
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
10 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
807 goto err;
808
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
10 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
809 ff_mpv_common_end(s);
810 goto err;
811 }
812
813
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
10 s->low_delay = !avctx->has_b_frames || v->res_sprite;
814
815
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 3 times.
10 if (v->profile == PROFILE_ADVANCED) {
816
2/4
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
7 if(avctx->coded_width<=1 || avctx->coded_height<=1) {
817 ret = AVERROR_INVALIDDATA;
818 goto err;
819 }
820 7 s->h_edge_pos = avctx->coded_width;
821 7 s->v_edge_pos = avctx->coded_height;
822 }
823 }
824
825 // do parse frame header
826 476 v->pic_header_flag = 0;
827 476 v->first_pic_header_flag = 1;
828
2/2
✓ Branch 0 taken 178 times.
✓ Branch 1 taken 298 times.
476 if (v->profile < PROFILE_ADVANCED) {
829
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 178 times.
178 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
830 goto err;
831 }
832 } else {
833
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 298 times.
298 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
834 goto err;
835 }
836 }
837 476 v->first_pic_header_flag = 0;
838
839
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (avctx->debug & FF_DEBUG_PICT_INFO)
840 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
841
842
2/4
✓ Branch 0 taken 476 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 476 times.
476 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
843 && s->pict_type != AV_PICTURE_TYPE_I) {
844 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
845 ret = AVERROR_INVALIDDATA;
846 goto err;
847 }
848
2/4
✓ Branch 0 taken 476 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 476 times.
476 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
849 && v->field_mode) {
850 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
851 ret = AVERROR_INVALIDDATA;
852 goto err;
853 }
854
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if ((s->mb_height >> v->field_mode) == 0) {
855 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
856 ret = AVERROR_INVALIDDATA;
857 goto err;
858 }
859
860 // for skipping the frame
861 476 s->current_picture.f->pict_type = s->pict_type;
862 476 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
863
864 /* skip B-frames if we don't have reference frames */
865
4/6
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 456 times.
✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 20 times.
476 if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
866 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
867 goto end;
868 }
869
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
476 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
870
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
476 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
871
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 avctx->skip_frame >= AVDISCARD_ALL) {
872 goto end;
873 }
874
875
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (s->next_p_frame_damaged) {
876 if (s->pict_type == AV_PICTURE_TYPE_B)
877 goto end;
878 else
879 s->next_p_frame_damaged = 0;
880 }
881
882
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 476 times.
476 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
883 goto err;
884 }
885
886 476 v->s.current_picture_ptr->field_picture = v->field_mode;
887 476 v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
888 476 v->s.current_picture_ptr->f->top_field_first = v->tff;
889
890 // process pulldown flags
891 476 s->current_picture_ptr->f->repeat_pict = 0;
892 // Pulldown flags are only valid when 'broadcast' has been set.
893 // So ticks_per_frame will be 2
894
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (v->rff) {
895 // repeat field
896 s->current_picture_ptr->f->repeat_pict = 1;
897
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 } else if (v->rptfrm) {
898 // repeat frames
899 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
900 }
901
902 476 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
903 476 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
904
905
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (avctx->hwaccel) {
906 s->mb_y = 0;
907 if (v->field_mode && buf_start_second_field) {
908 // decode first field
909 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
910 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
911 goto err;
912
913 if (n_slices1 == -1) {
914 // no slices, decode the field as-is
915 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
916 goto err;
917 } else {
918 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
919 goto err;
920
921 for (i = 0 ; i < n_slices1 + 1; i++) {
922 s->gb = slices[i].gb;
923 s->mb_y = slices[i].mby_start;
924
925 v->pic_header_flag = get_bits1(&s->gb);
926 if (v->pic_header_flag) {
927 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
928 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
929 ret = AVERROR_INVALIDDATA;
930 if (avctx->err_recognition & AV_EF_EXPLODE)
931 goto err;
932 continue;
933 }
934 }
935
936 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
937 goto err;
938 }
939 }
940
941 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
942 goto err;
943
944 // decode second field
945 s->gb = slices[n_slices1 + 1].gb;
946 s->mb_y = slices[n_slices1 + 1].mby_start;
947 s->picture_structure = PICT_TOP_FIELD + v->tff;
948 v->second_field = 1;
949 v->pic_header_flag = 0;
950 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
951 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
952 ret = AVERROR_INVALIDDATA;
953 goto err;
954 }
955 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
956
957 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
958 goto err;
959
960 if (n_slices - n_slices1 == 2) {
961 // no slices, decode the field as-is
962 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
963 goto err;
964 } else {
965 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
966 goto err;
967
968 for (i = n_slices1 + 2; i < n_slices; i++) {
969 s->gb = slices[i].gb;
970 s->mb_y = slices[i].mby_start;
971
972 v->pic_header_flag = get_bits1(&s->gb);
973 if (v->pic_header_flag) {
974 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
975 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
976 ret = AVERROR_INVALIDDATA;
977 if (avctx->err_recognition & AV_EF_EXPLODE)
978 goto err;
979 continue;
980 }
981 }
982
983 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
984 goto err;
985 }
986 }
987
988 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
989 goto err;
990 } else {
991 s->picture_structure = PICT_FRAME;
992 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
993 goto err;
994
995 if (n_slices == 0) {
996 // no slices, decode the frame as-is
997 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
998 goto err;
999 } else {
1000 // decode the frame part as the first slice
1001 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
1002 goto err;
1003
1004 // and process the slices as additional slices afterwards
1005 for (i = 0 ; i < n_slices; i++) {
1006 s->gb = slices[i].gb;
1007 s->mb_y = slices[i].mby_start;
1008
1009 v->pic_header_flag = get_bits1(&s->gb);
1010 if (v->pic_header_flag) {
1011 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1012 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1013 ret = AVERROR_INVALIDDATA;
1014 if (avctx->err_recognition & AV_EF_EXPLODE)
1015 goto err;
1016 continue;
1017 }
1018 }
1019
1020 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1021 goto err;
1022 }
1023 }
1024 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1025 goto err;
1026 }
1027 } else {
1028 476 int header_ret = 0;
1029
1030 476 ff_mpeg_er_frame_start(s);
1031
1032 476 v->end_mb_x = s->mb_width;
1033
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 440 times.
476 if (v->field_mode) {
1034 36 s->current_picture.f->linesize[0] <<= 1;
1035 36 s->current_picture.f->linesize[1] <<= 1;
1036 36 s->current_picture.f->linesize[2] <<= 1;
1037 36 s->linesize <<= 1;
1038 36 s->uvlinesize <<= 1;
1039 }
1040 476 mb_height = s->mb_height >> v->field_mode;
1041
1042
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 av_assert0 (mb_height > 0);
1043
1044
2/2
✓ Branch 0 taken 1109 times.
✓ Branch 1 taken 476 times.
1585 for (i = 0; i <= n_slices; i++) {
1045
4/4
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 597 times.
1109 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1046
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (v->field_mode <= 0) {
1047 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1048 "picture boundary (%d >= %d)\n", i,
1049 slices[i - 1].mby_start, mb_height);
1050 continue;
1051 }
1052 36 v->second_field = 1;
1053
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 av_assert0((s->mb_height & 1) == 0);
1054 36 v->blocks_off = s->b8_stride * (s->mb_height&~1);
1055 36 v->mb_off = s->mb_stride * s->mb_height >> 1;
1056 } else {
1057 1073 v->second_field = 0;
1058 1073 v->blocks_off = 0;
1059 1073 v->mb_off = 0;
1060 }
1061
2/2
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
1109 if (i) {
1062 633 v->pic_header_flag = 0;
1063
3/4
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 597 times.
✓ Branch 2 taken 36 times.
✗ Branch 3 not taken.
633 if (v->field_mode && i == n_slices1 + 2) {
1064
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 36 times.
36 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1065 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1066 ret = AVERROR_INVALIDDATA;
1067 if (avctx->err_recognition & AV_EF_EXPLODE)
1068 goto err;
1069 continue;
1070 }
1071
2/2
✓ Branch 1 taken 271 times.
✓ Branch 2 taken 326 times.
597 } else if (get_bits1(&s->gb)) {
1072 271 v->pic_header_flag = 1;
1073
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 271 times.
271 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1074 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1075 ret = AVERROR_INVALIDDATA;
1076 if (avctx->err_recognition & AV_EF_EXPLODE)
1077 goto err;
1078 continue;
1079 }
1080 }
1081 }
1082
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1109 times.
1109 if (header_ret < 0)
1083 continue;
1084
2/2
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
1109 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1085
4/4
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 1037 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 36 times.
1109 if (!v->field_mode || v->second_field)
1086
2/2
✓ Branch 0 taken 597 times.
✓ Branch 1 taken 476 times.
1073 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1087 else {
1088
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (i >= n_slices) {
1089 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1090 continue;
1091 }
1092
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1093 }
1094
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1109 times.
1109 if (s->end_mb_y <= s->start_mb_y) {
1095 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1096 continue;
1097 }
1098
4/4
✓ Branch 0 taken 982 times.
✓ Branch 1 taken 127 times.
✓ Branch 2 taken 67 times.
✓ Branch 3 taken 915 times.
1109 if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1099
3/4
✓ Branch 0 taken 109 times.
✓ Branch 1 taken 85 times.
✓ Branch 2 taken 109 times.
✗ Branch 3 not taken.
194 (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1100
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1024 times.
1024 !v->cbpcy_vlc) {
1101 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1102 continue;
1103 }
1104 1109 ff_vc1_decode_blocks(v);
1105
2/2
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
1109 if (i != n_slices) {
1106 633 s->gb = slices[i].gb;
1107 }
1108 }
1109
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 440 times.
476 if (v->field_mode) {
1110 36 v->second_field = 0;
1111 36 s->current_picture.f->linesize[0] >>= 1;
1112 36 s->current_picture.f->linesize[1] >>= 1;
1113 36 s->current_picture.f->linesize[2] >>= 1;
1114 36 s->linesize >>= 1;
1115 36 s->uvlinesize >>= 1;
1116
3/4
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 18 times.
36 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1117 18 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1118 18 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1119 }
1120 }
1121 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1122 get_bits_count(&s->gb), s->gb.size_in_bits);
1123 // if (get_bits_count(&s->gb) > buf_size * 8)
1124 // return -1;
1125
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
476 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1126 ret = AVERROR_INVALIDDATA;
1127 goto err;
1128 }
1129
2/2
✓ Branch 0 taken 440 times.
✓ Branch 1 taken 36 times.
476 if ( !v->field_mode
1130
1/2
✓ Branch 0 taken 440 times.
✗ Branch 1 not taken.
440 && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE
1131
1/2
✓ Branch 0 taken 440 times.
✗ Branch 1 not taken.
440 && avctx->codec_id != AV_CODEC_ID_VC1IMAGE)
1132 440 ff_er_frame_end(&s->er);
1133 }
1134
1135 476 ff_mpv_frame_end(s);
1136
1137
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 476 times.
476 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1138 image:
1139 avctx->width = avctx->coded_width = v->output_width;
1140 avctx->height = avctx->coded_height = v->output_height;
1141 if (avctx->skip_frame >= AVDISCARD_NONREF)
1142 goto end;
1143 if (!v->sprite_output_frame &&
1144 !(v->sprite_output_frame = av_frame_alloc())) {
1145 ret = AVERROR(ENOMEM);
1146 goto err;
1147 }
1148 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1149 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1150 goto err;
1151 #endif
1152 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1153 goto err;
1154 *got_frame = 1;
1155 } else {
1156
4/4
✓ Branch 0 taken 385 times.
✓ Branch 1 taken 91 times.
✓ Branch 2 taken 154 times.
✓ Branch 3 taken 231 times.
476 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1157
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 245 times.
245 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1158 goto err;
1159
2/2
✓ Branch 0 taken 227 times.
✓ Branch 1 taken 18 times.
245 if (!v->field_mode)
1160 227 ff_print_debug_info(s, s->current_picture_ptr, pict);
1161 245 *got_frame = 1;
1162
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 223 times.
231 } else if (s->last_picture_ptr) {
1163
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 223 times.
223 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1164 goto err;
1165
2/2
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 17 times.
223 if (!v->field_mode)
1166 206 ff_print_debug_info(s, s->last_picture_ptr, pict);
1167 223 *got_frame = 1;
1168 }
1169 }
1170
1171 8 end:
1172 476 av_free(buf2);
1173
2/2
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
1109 for (i = 0; i < n_slices; i++)
1174 633 av_free(slices[i].buf);
1175 476 av_free(slices);
1176 476 return buf_size;
1177
1178 err:
1179 av_free(buf2);
1180 for (i = 0; i < n_slices; i++)
1181 av_free(slices[i].buf);
1182 av_free(slices);
1183 return ret;
1184 }
1185
1186
1187 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1188 #if CONFIG_VC1_DXVA2_HWACCEL
1189 AV_PIX_FMT_DXVA2_VLD,
1190 #endif
1191 #if CONFIG_VC1_D3D11VA_HWACCEL
1192 AV_PIX_FMT_D3D11VA_VLD,
1193 AV_PIX_FMT_D3D11,
1194 #endif
1195 #if CONFIG_VC1_NVDEC_HWACCEL
1196 AV_PIX_FMT_CUDA,
1197 #endif
1198 #if CONFIG_VC1_VAAPI_HWACCEL
1199 AV_PIX_FMT_VAAPI,
1200 #endif
1201 #if CONFIG_VC1_VDPAU_HWACCEL
1202 AV_PIX_FMT_VDPAU,
1203 #endif
1204 AV_PIX_FMT_YUV420P,
1205 AV_PIX_FMT_NONE
1206 };
1207
1208 const AVCodec ff_vc1_decoder = {
1209 .name = "vc1",
1210 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
1211 .type = AVMEDIA_TYPE_VIDEO,
1212 .id = AV_CODEC_ID_VC1,
1213 .priv_data_size = sizeof(VC1Context),
1214 .init = vc1_decode_init,
1215 .close = ff_vc1_decode_end,
1216 .decode = vc1_decode_frame,
1217 .flush = ff_mpeg_flush,
1218 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1219 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1220 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1221 #if CONFIG_VC1_DXVA2_HWACCEL
1222 HWACCEL_DXVA2(vc1),
1223 #endif
1224 #if CONFIG_VC1_D3D11VA_HWACCEL
1225 HWACCEL_D3D11VA(vc1),
1226 #endif
1227 #if CONFIG_VC1_D3D11VA2_HWACCEL
1228 HWACCEL_D3D11VA2(vc1),
1229 #endif
1230 #if CONFIG_VC1_NVDEC_HWACCEL
1231 HWACCEL_NVDEC(vc1),
1232 #endif
1233 #if CONFIG_VC1_VAAPI_HWACCEL
1234 HWACCEL_VAAPI(vc1),
1235 #endif
1236 #if CONFIG_VC1_VDPAU_HWACCEL
1237 HWACCEL_VDPAU(vc1),
1238 #endif
1239 NULL
1240 },
1241 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1242 };
1243
1244 #if CONFIG_WMV3_DECODER
1245 const AVCodec ff_wmv3_decoder = {
1246 .name = "wmv3",
1247 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
1248 .type = AVMEDIA_TYPE_VIDEO,
1249 .id = AV_CODEC_ID_WMV3,
1250 .priv_data_size = sizeof(VC1Context),
1251 .init = vc1_decode_init,
1252 .close = ff_vc1_decode_end,
1253 .decode = vc1_decode_frame,
1254 .flush = ff_mpeg_flush,
1255 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1256 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
1257 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1258 #if CONFIG_WMV3_DXVA2_HWACCEL
1259 HWACCEL_DXVA2(wmv3),
1260 #endif
1261 #if CONFIG_WMV3_D3D11VA_HWACCEL
1262 HWACCEL_D3D11VA(wmv3),
1263 #endif
1264 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1265 HWACCEL_D3D11VA2(wmv3),
1266 #endif
1267 #if CONFIG_WMV3_NVDEC_HWACCEL
1268 HWACCEL_NVDEC(wmv3),
1269 #endif
1270 #if CONFIG_WMV3_VAAPI_HWACCEL
1271 HWACCEL_VAAPI(wmv3),
1272 #endif
1273 #if CONFIG_WMV3_VDPAU_HWACCEL
1274 HWACCEL_VDPAU(wmv3),
1275 #endif
1276 NULL
1277 },
1278 .profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1279 };
1280 #endif
1281
1282 #if CONFIG_WMV3IMAGE_DECODER
1283 const AVCodec ff_wmv3image_decoder = {
1284 .name = "wmv3image",
1285 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
1286 .type = AVMEDIA_TYPE_VIDEO,
1287 .id = AV_CODEC_ID_WMV3IMAGE,
1288 .priv_data_size = sizeof(VC1Context),
1289 .init = vc1_decode_init,
1290 .close = ff_vc1_decode_end,
1291 .decode = vc1_decode_frame,
1292 .capabilities = AV_CODEC_CAP_DR1,
1293 .flush = vc1_sprite_flush,
1294 .pix_fmts = (const enum AVPixelFormat[]) {
1295 AV_PIX_FMT_YUV420P,
1296 AV_PIX_FMT_NONE
1297 },
1298 };
1299 #endif
1300
1301 #if CONFIG_VC1IMAGE_DECODER
1302 const AVCodec ff_vc1image_decoder = {
1303 .name = "vc1image",
1304 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
1305 .type = AVMEDIA_TYPE_VIDEO,
1306 .id = AV_CODEC_ID_VC1IMAGE,
1307 .priv_data_size = sizeof(VC1Context),
1308 .init = vc1_decode_init,
1309 .close = ff_vc1_decode_end,
1310 .decode = vc1_decode_frame,
1311 .capabilities = AV_CODEC_CAP_DR1,
1312 .flush = vc1_sprite_flush,
1313 .pix_fmts = (const enum AVPixelFormat[]) {
1314 AV_PIX_FMT_YUV420P,
1315 AV_PIX_FMT_NONE
1316 },
1317 };
1318 #endif
1319