FFmpeg coverage

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