FFmpeg coverage


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