FFmpeg coverage

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