FFmpeg coverage

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