FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/vc1dec.c
Date: 2024-04-19 17:50:32
Exec Total Coverage
Lines: 425 877 48.5%
Functions: 9 15 60.0%
Branches: 212 560 37.9%

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