FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/vc1dec.c
Date: 2022-11-28 23:49:43
Exec Total Coverage
Lines: 410 835 49.1%
Branches: 210 558 37.6%

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 "h263dec.h"
37 #include "hwconfig.h"
38 #include "mpeg_er.h"
39 #include "mpegvideo.h"
40 #include "mpegvideodec.h"
41 #include "msmpeg4_vc1_data.h"
42 #include "profiles.h"
43 #include "simple_idct.h"
44 #include "vc1.h"
45 #include "vc1data.h"
46 #include "vc1_vlc_data.h"
47 #include "libavutil/attributes.h"
48 #include "libavutil/avassert.h"
49 #include "libavutil/imgutils.h"
50 #include "libavutil/thread.h"
51
52
53 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
54
55 typedef struct SpriteData {
56 /**
57 * Transform coefficients for both sprites in 16.16 fixed point format,
58 * in the order they appear in the bitstream:
59 * x scale
60 * rotation 1 (unused)
61 * x offset
62 * rotation 2 (unused)
63 * y scale
64 * y offset
65 * alpha
66 */
67 int coefs[2][7];
68
69 int effect_type, effect_flag;
70 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
71 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
72 } SpriteData;
73
74 static inline int get_fp_val(GetBitContext* gb)
75 {
76 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
77 }
78
79 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
80 {
81 c[1] = c[3] = 0;
82
83 switch (get_bits(gb, 2)) {
84 case 0:
85 c[0] = 1 << 16;
86 c[2] = get_fp_val(gb);
87 c[4] = 1 << 16;
88 break;
89 case 1:
90 c[0] = c[4] = get_fp_val(gb);
91 c[2] = get_fp_val(gb);
92 break;
93 case 2:
94 c[0] = get_fp_val(gb);
95 c[2] = get_fp_val(gb);
96 c[4] = get_fp_val(gb);
97 break;
98 case 3:
99 c[0] = get_fp_val(gb);
100 c[1] = get_fp_val(gb);
101 c[2] = get_fp_val(gb);
102 c[3] = get_fp_val(gb);
103 c[4] = get_fp_val(gb);
104 break;
105 }
106 c[5] = get_fp_val(gb);
107 if (get_bits1(gb))
108 c[6] = get_fp_val(gb);
109 else
110 c[6] = 1 << 16;
111 }
112
113 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
114 {
115 AVCodecContext *avctx = v->s.avctx;
116 int sprite, i;
117
118 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
119 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
120 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
121 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
122 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
123 for (i = 0; i < 7; i++)
124 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
125 sd->coefs[sprite][i] / (1<<16),
126 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
127 av_log(avctx, AV_LOG_DEBUG, "\n");
128 }
129
130 skip_bits(gb, 2);
131 if (sd->effect_type = get_bits_long(gb, 30)) {
132 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
133 case 7:
134 vc1_sprite_parse_transform(gb, sd->effect_params1);
135 break;
136 case 14:
137 vc1_sprite_parse_transform(gb, sd->effect_params1);
138 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
139 break;
140 default:
141 for (i = 0; i < sd->effect_pcount1; i++)
142 sd->effect_params1[i] = get_fp_val(gb);
143 }
144 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
145 // effect 13 is simple alpha blending and matches the opacity above
146 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
147 for (i = 0; i < sd->effect_pcount1; i++)
148 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
149 sd->effect_params1[i] / (1 << 16),
150 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
151 av_log(avctx, AV_LOG_DEBUG, "\n");
152 }
153
154 sd->effect_pcount2 = get_bits(gb, 16);
155 if (sd->effect_pcount2 > 10) {
156 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
157 return AVERROR_INVALIDDATA;
158 } else if (sd->effect_pcount2) {
159 i = -1;
160 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
161 while (++i < sd->effect_pcount2) {
162 sd->effect_params2[i] = get_fp_val(gb);
163 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
164 sd->effect_params2[i] / (1 << 16),
165 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
166 }
167 av_log(avctx, AV_LOG_DEBUG, "\n");
168 }
169 }
170 if (sd->effect_flag = get_bits1(gb))
171 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
172
173 if (get_bits_count(gb) >= gb->size_in_bits +
174 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
175 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
176 return AVERROR_INVALIDDATA;
177 }
178 if (get_bits_count(gb) < gb->size_in_bits - 8)
179 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
180
181 return 0;
182 }
183
184 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
185 {
186 int i, plane, row, sprite;
187 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
188 uint8_t* src_h[2][2];
189 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
190 int ysub[2];
191 MpegEncContext *s = &v->s;
192
193 for (i = 0; i <= v->two_sprites; i++) {
194 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
195 xadv[i] = sd->coefs[i][0];
196 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
197 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
198
199 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
200 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
201 }
202 alpha = av_clip_uint16(sd->coefs[1][6]);
203
204 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
205 int width = v->output_width>>!!plane;
206
207 for (row = 0; row < v->output_height>>!!plane; row++) {
208 uint8_t *dst = v->sprite_output_frame->data[plane] +
209 v->sprite_output_frame->linesize[plane] * row;
210
211 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
212 uint8_t *iplane = s->current_picture.f->data[plane];
213 int iline = s->current_picture.f->linesize[plane];
214 int ycoord = yoff[sprite] + yadv[sprite] * row;
215 int yline = ycoord >> 16;
216 int next_line;
217 ysub[sprite] = ycoord & 0xFFFF;
218 if (sprite) {
219 iplane = s->last_picture.f->data[plane];
220 iline = s->last_picture.f->linesize[plane];
221 }
222 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
223 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
224 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
225 if (ysub[sprite])
226 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
227 } else {
228 if (sr_cache[sprite][0] != yline) {
229 if (sr_cache[sprite][1] == yline) {
230 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
231 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
232 } else {
233 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
234 sr_cache[sprite][0] = yline;
235 }
236 }
237 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
238 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
239 iplane + next_line, xoff[sprite],
240 xadv[sprite], width);
241 sr_cache[sprite][1] = yline + 1;
242 }
243 src_h[sprite][0] = v->sr_rows[sprite][0];
244 src_h[sprite][1] = v->sr_rows[sprite][1];
245 }
246 }
247
248 if (!v->two_sprites) {
249 if (ysub[0]) {
250 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
251 } else {
252 memcpy(dst, src_h[0][0], width);
253 }
254 } else {
255 if (ysub[0] && ysub[1]) {
256 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
257 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
258 } else if (ysub[0]) {
259 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
260 src_h[1][0], alpha, width);
261 } else if (ysub[1]) {
262 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
263 src_h[0][0], (1<<16)-1-alpha, width);
264 } else {
265 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
266 }
267 }
268 }
269
270 if (!plane) {
271 for (i = 0; i <= v->two_sprites; i++) {
272 xoff[i] >>= 1;
273 yoff[i] >>= 1;
274 }
275 }
276
277 }
278 }
279
280
281 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
282 {
283 int ret;
284 MpegEncContext *s = &v->s;
285 AVCodecContext *avctx = s->avctx;
286 SpriteData sd;
287
288 memset(&sd, 0, sizeof(sd));
289
290 ret = vc1_parse_sprites(v, gb, &sd);
291 if (ret < 0)
292 return ret;
293
294 if (!s->current_picture.f || !s->current_picture.f->data[0]) {
295 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
296 return AVERROR_UNKNOWN;
297 }
298
299 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
300 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
301 v->two_sprites = 0;
302 }
303
304 av_frame_unref(v->sprite_output_frame);
305 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
306 return ret;
307
308 vc1_draw_sprites(v, &sd);
309
310 return 0;
311 }
312
313 static void vc1_sprite_flush(AVCodecContext *avctx)
314 {
315 VC1Context *v = avctx->priv_data;
316 MpegEncContext *s = &v->s;
317 AVFrame *f = s->current_picture.f;
318 int plane, i;
319
320 /* Windows Media Image codecs have a convergence interval of two keyframes.
321 Since we can't enforce it, clear to black the missing sprite. This is
322 wrong but it looks better than doing nothing. */
323
324 if (f && f->data[0])
325 for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
326 for (i = 0; i < v->sprite_height>>!!plane; i++)
327 memset(f->data[plane] + i * f->linesize[plane],
328 plane ? 128 : 0, f->linesize[plane]);
329 }
330
331 #endif
332
333 22 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
334 {
335 22 MpegEncContext *s = &v->s;
336 int i, ret;
337 22 int mb_height = FFALIGN(s->mb_height, 2);
338
339 /* Allocate mb bitplanes */
340 22 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
341 22 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
342 22 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
343 22 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
344 22 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
345 22 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
346
3/6
✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 22 times.
✗ Branch 5 not taken.
22 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->forward_mb_plane ||
347
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 !v->fieldtx_plane || !v->acpred_plane || !v->over_flags_plane)
348 return AVERROR(ENOMEM);
349
350 22 v->n_allocated_blks = s->mb_width + 2;
351 22 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
352 22 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
353
2/4
✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
22 if (!v->block || !v->cbp_base)
354 return AVERROR(ENOMEM);
355 22 v->cbp = v->cbp_base + 2 * s->mb_stride;
356 22 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 3 * s->mb_stride);
357
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (!v->ttblk_base)
358 return AVERROR(ENOMEM);
359 22 v->ttblk = v->ttblk_base + 2 * s->mb_stride;
360 22 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 3 * s->mb_stride);
361
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (!v->is_intra_base)
362 return AVERROR(ENOMEM);
363 22 v->is_intra = v->is_intra_base + 2 * s->mb_stride;
364 22 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 3 * s->mb_stride);
365
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (!v->luma_mv_base)
366 return AVERROR(ENOMEM);
367 22 v->luma_mv = v->luma_mv_base + 2 * s->mb_stride;
368
369 /* allocate block type info in that way so it could be used with s->block_index[] */
370 22 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
371
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (!v->mb_type_base)
372 return AVERROR(ENOMEM);
373 22 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
374 22 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
375 22 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
376
377 /* allocate memory to store block level MV info */
378 22 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
379
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (!v->blk_mv_type_base)
380 return AVERROR(ENOMEM);
381 22 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
382 22 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
383
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (!v->mv_f_base)
384 return AVERROR(ENOMEM);
385 22 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
386 22 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
387 22 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (!v->mv_f_next_base)
389 return AVERROR(ENOMEM);
390 22 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
391 22 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
392
393
2/4
✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
22 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
394 for (i = 0; i < 4; i++)
395 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
396 return AVERROR(ENOMEM);
397 }
398
399 22 ret = ff_intrax8_common_init(s->avctx, &v->x8,
400 22 s->block, s->block_last_index,
401 s->mb_width, s->mb_height);
402
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (ret < 0)
403 return ret;
404
405 22 return 0;
406 }
407
408 22 static enum AVPixelFormat vc1_get_format(AVCodecContext *avctx)
409 {
410
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 10 times.
22 if (avctx->codec_id == AV_CODEC_ID_MSS2)
411 12 return AV_PIX_FMT_YUV420P;
412
413 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) {
414 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
415 avctx->color_range = AVCOL_RANGE_MPEG;
416 return AV_PIX_FMT_GRAY8;
417 }
418
419 10 return ff_get_format(avctx, avctx->codec->pix_fmts);
420 }
421
422 22 av_cold int ff_vc1_decode_init(AVCodecContext *avctx)
423 {
424 22 VC1Context *const v = avctx->priv_data;
425 22 MpegEncContext *const s = &v->s;
426 int ret;
427
428 22 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
429
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (ret < 0)
430 return ret;
431
432 22 ff_mpv_decode_init(s, avctx);
433 22 ff_mpv_idct_init(s);
434
435 22 avctx->pix_fmt = vc1_get_format(avctx);
436
437 22 ret = ff_mpv_common_init(s);
438
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (ret < 0)
439 return ret;
440
441 22 s->y_dc_scale_table = ff_wmv3_dc_scale_table;
442 22 s->c_dc_scale_table = ff_wmv3_dc_scale_table;
443
444 22 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,
445 ff_wmv1_scantable[0]);
446 22 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,
447 ff_wmv1_scantable[1]);
448
449 22 ret = vc1_decode_init_alloc_tables(v);
450
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (ret < 0) {
451 ff_vc1_decode_end(avctx);
452 return ret;
453 }
454 22 return 0;
455 }
456
457 34 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
458 {
459 int i;
460
2/2
✓ Branch 0 taken 2176 times.
✓ Branch 1 taken 34 times.
2210 for (i = 0; i < 64; i++) {
461 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
462 2176 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
463 2176 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
464 2176 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
465 2176 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
466 2176 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
467 }
468 34 v->left_blk_sh = 0;
469 34 v->top_blk_sh = 3;
470 34 }
471
472 static const uint16_t vlc_offs[] = {
473 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
474 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
475 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
476 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
477 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
478 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
479 31714, 31746, 31778, 32306, 32340, 32372
480 };
481
482 18 static av_cold void vc1_init_static(void)
483 {
484 static VLCElem vlc_table[32372];
485
486 18 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
487 vc1_norm2_bits, 1, 1,
488 vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
489 18 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
490 vc1_norm6_bits, 1, 1,
491 vc1_norm6_codes, 2, 2, 556);
492 18 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
493 vc1_imode_bits, 1, 1,
494 vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
495
2/2
✓ Branch 0 taken 54 times.
✓ Branch 1 taken 18 times.
72 for (int i = 0; i < 3; i++) {
496 54 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
497 54 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
498 54 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
499 vc1_ttmb_bits[i], 1, 1,
500 vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
501 54 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
502 54 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
503 54 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
504 vc1_ttblk_bits[i], 1, 1,
505 vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
506 54 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
507 54 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
508 54 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
509 vc1_subblkpat_bits[i], 1, 1,
510 vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
511 }
512
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 18 times.
90 for (int i = 0; i < 4; i++) {
513 72 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
514 72 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
515 72 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
516 vc1_4mv_block_pattern_bits[i], 1, 1,
517 vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
518 72 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
519 72 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
520 72 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
521 vc1_cbpcy_p_bits[i], 1, 1,
522 vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
523 72 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
524 72 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
525 72 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
526 vc1_mv_diff_bits[i], 1, 1,
527 vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
528 }
529
2/2
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 18 times.
162 for (int i = 0; i < 8; i++) {
530 144 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
531 144 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
532 144 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
533 &vc1_ac_tables[i][0][1], 8, 4,
534 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
535 /* initialize interlaced MVDATA tables (2-Ref) */
536 144 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
537 144 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
538 144 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
539 vc1_2ref_mvdata_bits[i], 1, 1,
540 vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
541 }
542
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 18 times.
90 for (int i = 0; i < 4; i++) {
543 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
544 72 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
545 72 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
546 72 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
547 vc1_intfr_4mv_mbmode_bits[i], 1, 1,
548 vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
549 /* initialize NON-4MV MBMODE VLC tables for the same */
550 72 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
551 72 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
552 72 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
553 vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
554 vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
555 /* initialize interlaced MVDATA tables (1-Ref) */
556 72 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
557 72 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
558 72 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
559 vc1_1ref_mvdata_bits[i], 1, 1,
560 vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
561 }
562
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 18 times.
90 for (int i = 0; i < 4; i++) {
563 /* Initialize 2MV Block pattern VLC tables */
564 72 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
565 72 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
566 72 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
567 vc1_2mv_block_pattern_bits[i], 1, 1,
568 vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
569 }
570
2/2
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 18 times.
162 for (int i = 0; i < 8; i++) {
571 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
572 144 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
573 144 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
574 144 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
575 vc1_icbpcy_p_bits[i], 1, 1,
576 vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
577 /* Initialize interlaced field picture MBMODE VLC tables */
578 144 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
579 144 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
580 144 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
581 vc1_if_mmv_mbmode_bits[i], 1, 1,
582 vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
583 144 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
584 144 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
585 144 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
586 vc1_if_1mv_mbmode_bits[i], 1, 1,
587 vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
588 }
589 18 ff_msmp4_vc1_vlcs_init_once();
590 18 }
591
592 /**
593 * Init VC-1 specific tables and VC1Context members
594 * @param v The VC1Context to initialize
595 * @return Status
596 */
597 34 av_cold void ff_vc1_init_common(VC1Context *v)
598 {
599 static AVOnce init_static_once = AV_ONCE_INIT;
600 34 MpegEncContext *const s = &v->s;
601
602 /* defaults */
603 34 v->pq = -1;
604 34 v->mvrange = 0; /* 7.1.1.18, p80 */
605
606 34 s->avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
607 34 s->out_format = FMT_H263;
608
609 34 s->h263_pred = 1;
610 34 s->msmpeg4_version = 6;
611
612 34 ff_vc1dsp_init(&v->vc1dsp);
613
614 /* For error resilience */
615 34 ff_qpeldsp_init(&s->qdsp);
616
617 /* VLC tables */
618 34 ff_thread_once(&init_static_once, vc1_init_static);
619 34 }
620
621 /** Initialize a VC1/WMV3 decoder
622 * @todo TODO: Handle VC-1 IDUs (Transport level?)
623 * @todo TODO: Decipher remaining bits in extra_data
624 */
625 28 static av_cold int vc1_decode_init(AVCodecContext *avctx)
626 {
627 28 VC1Context *v = avctx->priv_data;
628 28 MpegEncContext *s = &v->s;
629 GetBitContext gb;
630 int ret;
631
632 /* save the container output size for WMImage */
633 28 v->output_width = avctx->width;
634 28 v->output_height = avctx->height;
635
636
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)
637 6 return AVERROR_INVALIDDATA;
638 22 v->s.avctx = avctx;
639
640 22 ff_vc1_init_common(v);
641
642
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) {
643 7 int count = 0;
644
645 // looks like WMV3 has a sequence header stored in the extradata
646 // advanced sequence header may be before the first frame
647 // the last byte of the extradata is a version number, 1 for the
648 // samples we can decode
649
650 7 ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size);
651
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 if (ret < 0)
652 return ret;
653
654
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
7 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
655 return ret;
656
657
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) {
658 avpriv_request_sample(avctx, "Non sprite WMV3IMAGE");
659 return AVERROR_PATCHWELCOME;
660 }
661
662 7 count = avctx->extradata_size*8 - get_bits_count(&gb);
663
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 if (count > 0) {
664 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
665 count, get_bits_long(&gb, FFMIN(count, 32)));
666
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
7 } else if (count < 0) {
667 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
668 }
669 } else { // VC1/WVC1/WVP2
670 15 const uint8_t *start = avctx->extradata;
671 15 uint8_t *end = avctx->extradata + avctx->extradata_size;
672 const uint8_t *next;
673 int size, buf2_size;
674 15 uint8_t *buf2 = NULL;
675 15 int seq_initialized = 0, ep_initialized = 0;
676
677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
15 if (avctx->extradata_size < 16) {
678 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
679 return AVERROR_INVALIDDATA;
680 }
681
682 15 buf2 = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
683
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
15 if (!buf2)
684 return AVERROR(ENOMEM);
685
686 15 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
687 15 next = start;
688
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 15 times.
55 for (; next < end; start = next) {
689 40 next = find_next_marker(start + 4, end);
690 40 size = next - start - 4;
691
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
40 if (size <= 0)
692 continue;
693 40 buf2_size = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
694 40 init_get_bits(&gb, buf2, buf2_size * 8);
695
2/3
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 25 times.
✗ Branch 2 not taken.
40 switch (AV_RB32(start)) {
696 15 case VC1_CODE_SEQHDR:
697
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
15 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
698 av_free(buf2);
699 return ret;
700 }
701 15 seq_initialized = 1;
702 15 break;
703 25 case VC1_CODE_ENTRYPOINT:
704
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 25 times.
25 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
705 av_free(buf2);
706 return ret;
707 }
708 25 ep_initialized = 1;
709 25 break;
710 }
711 }
712 15 av_free(buf2);
713
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) {
714 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
715 return AVERROR_INVALIDDATA;
716 }
717 15 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
718 }
719
720 22 avctx->profile = v->profile;
721
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 7 times.
22 if (v->profile == PROFILE_ADVANCED)
722 15 avctx->level = v->level;
723
724 if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
725 22 avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
726 else {
727 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
728 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
729 avctx->color_range = AVCOL_RANGE_MPEG;
730 }
731
732 22 ff_blockdsp_init(&s->bdsp);
733 22 ff_h264chroma_init(&v->h264chroma, 8);
734
735 22 avctx->has_b_frames = !!avctx->max_b_frames;
736
737
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)
738 avctx->color_primaries = v->color_prim;
739
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)
740 avctx->color_trc = v->transfer_char;
741
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)
742 avctx->colorspace = v->matrix_coef;
743
744 22 s->mb_width = (avctx->coded_width + 15) >> 4;
745 22 s->mb_height = (avctx->coded_height + 15) >> 4;
746
747
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) {
748 22 ff_vc1_init_transposed_scantables(v);
749 } else {
750 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
751 v->left_blk_sh = 3;
752 v->top_blk_sh = 0;
753 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_int16_8bit;
754 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
755 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
756 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
757 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_int16_8bit;
758 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
759 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
760 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
761 }
762
763
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) {
764 v->sprite_width = avctx->coded_width;
765 v->sprite_height = avctx->coded_height;
766
767 avctx->coded_width = avctx->width = v->output_width;
768 avctx->coded_height = avctx->height = v->output_height;
769
770 // prevent 16.16 overflows
771 if (v->sprite_width > 1 << 14 ||
772 v->sprite_height > 1 << 14 ||
773 v->output_width > 1 << 14 ||
774 v->output_height > 1 << 14) {
775 return AVERROR_INVALIDDATA;
776 }
777
778 if ((v->sprite_width&1) || (v->sprite_height&1)) {
779 avpriv_request_sample(avctx, "odd sprites support");
780 return AVERROR_PATCHWELCOME;
781 }
782 }
783 22 return 0;
784 }
785
786 /** Close a VC1/WMV3 decoder
787 * @warning Initial try at using MpegEncContext stuff
788 */
789 34 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
790 {
791 34 VC1Context *v = avctx->priv_data;
792 int i;
793
794 34 av_frame_free(&v->sprite_output_frame);
795
796
2/2
✓ Branch 0 taken 136 times.
✓ Branch 1 taken 34 times.
170 for (i = 0; i < 4; i++)
797 136 av_freep(&v->sr_rows[i >> 1][i & 1]);
798 34 ff_mpv_common_end(&v->s);
799 34 av_freep(&v->mv_type_mb_plane);
800 34 av_freep(&v->direct_mb_plane);
801 34 av_freep(&v->forward_mb_plane);
802 34 av_freep(&v->fieldtx_plane);
803 34 av_freep(&v->acpred_plane);
804 34 av_freep(&v->over_flags_plane);
805 34 av_freep(&v->mb_type_base);
806 34 av_freep(&v->blk_mv_type_base);
807 34 av_freep(&v->mv_f_base);
808 34 av_freep(&v->mv_f_next_base);
809 34 av_freep(&v->block);
810 34 av_freep(&v->cbp_base);
811 34 av_freep(&v->ttblk_base);
812 34 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
813 34 av_freep(&v->luma_mv_base);
814 34 ff_intrax8_common_end(&v->x8);
815 34 return 0;
816 }
817
818
819 /** Decode a VC1/WMV3 frame
820 * @todo TODO: Handle VC-1 IDUs (Transport level?)
821 */
822 494 static int vc1_decode_frame(AVCodecContext *avctx, AVFrame *pict,
823 int *got_frame, AVPacket *avpkt)
824 {
825 494 const uint8_t *buf = avpkt->data;
826 494 int buf_size = avpkt->size, n_slices = 0, i, ret;
827 494 VC1Context *v = avctx->priv_data;
828 494 MpegEncContext *s = &v->s;
829 494 uint8_t *buf2 = NULL;
830 494 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
831 494 int mb_height, n_slices1=-1;
832 struct {
833 uint8_t *buf;
834 GetBitContext gb;
835 int mby_start;
836 const uint8_t *rawbuf;
837 int raw_size;
838 494 } *slices = NULL, *tmp;
839
840 494 v->second_field = 0;
841
842
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 494 times.
494 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 477 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 476 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
494 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 2 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 8 times.
18 if (s->low_delay == 0 && s->next_picture_ptr) {
849
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
8 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
850 return ret;
851 8 s->next_picture_ptr = NULL;
852
853 8 *got_frame = 1;
854 }
855
856 18 return buf_size;
857 }
858
859 //for advanced profile we may need to parse and unescape data
860
3/4
✓ Branch 0 taken 178 times.
✓ Branch 1 taken 298 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 178 times.
774 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
861 298 int buf_size2 = 0;
862 298 buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
863
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 298 times.
298 if (!buf2)
864 return AVERROR(ENOMEM);
865
866
1/2
✓ Branch 0 taken 298 times.
✗ Branch 1 not taken.
298 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
867 const uint8_t *start, *end, *next;
868 int size;
869
870 298 next = buf;
871
2/2
✓ Branch 0 taken 952 times.
✓ Branch 1 taken 298 times.
1250 for (start = buf, end = buf + buf_size; next < end; start = next) {
872 952 next = find_next_marker(start + 4, end);
873 952 size = next - start - 4;
874
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 952 times.
952 if (size <= 0) continue;
875
5/5
✓ Branch 0 taken 298 times.
✓ Branch 1 taken 36 times.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 597 times.
✓ Branch 4 taken 8 times.
952 switch (AV_RB32(start)) {
876 298 case VC1_CODE_FRAME:
877
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 298 times.
298 if (avctx->hwaccel)
878 buf_start = start;
879 298 buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
880 298 break;
881 36 case VC1_CODE_FIELD: {
882 int buf_size3;
883
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (avctx->hwaccel)
884 buf_start_second_field = start;
885 36 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
886
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (!tmp) {
887 ret = AVERROR(ENOMEM);
888 goto err;
889 }
890 36 slices = tmp;
891 36 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
892
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (!slices[n_slices].buf) {
893 ret = AVERROR(ENOMEM);
894 goto err;
895 }
896 36 buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size,
897 36 slices[n_slices].buf);
898 36 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
899 buf_size3 << 3);
900 36 slices[n_slices].mby_start = avctx->coded_height + 31 >> 5;
901 36 slices[n_slices].rawbuf = start;
902 36 slices[n_slices].raw_size = size + 4;
903 36 n_slices1 = n_slices - 1; // index of the last slice of the first field
904 36 n_slices++;
905 36 break;
906 }
907 13 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
908 13 buf_size2 = v->vc1dsp.vc1_unescape_buffer(start + 4, size, buf2);
909 13 init_get_bits(&s->gb, buf2, buf_size2 * 8);
910 13 ff_vc1_decode_entry_point(avctx, v, &s->gb);
911 13 break;
912 597 case VC1_CODE_SLICE: {
913 int buf_size3;
914 597 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
915
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 597 times.
597 if (!tmp) {
916 ret = AVERROR(ENOMEM);
917 goto err;
918 }
919 597 slices = tmp;
920 597 slices[n_slices].buf = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
921
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 597 times.
597 if (!slices[n_slices].buf) {
922 ret = AVERROR(ENOMEM);
923 goto err;
924 }
925 597 buf_size3 = v->vc1dsp.vc1_unescape_buffer(start + 4, size,
926 597 slices[n_slices].buf);
927 597 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
928 buf_size3 << 3);
929 597 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
930 597 slices[n_slices].rawbuf = start;
931 597 slices[n_slices].raw_size = size + 4;
932 597 n_slices++;
933 597 break;
934 }
935 }
936 }
937 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
938 const uint8_t *divider;
939 int buf_size3;
940
941 divider = find_next_marker(buf, buf + buf_size);
942 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
943 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
944 ret = AVERROR_INVALIDDATA;
945 goto err;
946 } else { // found field marker, unescape second field
947 if (avctx->hwaccel)
948 buf_start_second_field = divider;
949 tmp = av_realloc_array(slices, sizeof(*slices), n_slices+1);
950 if (!tmp) {
951 ret = AVERROR(ENOMEM);
952 goto err;
953 }
954 slices = tmp;
955 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
956 if (!slices[n_slices].buf) {
957 ret = AVERROR(ENOMEM);
958 goto err;
959 }
960 buf_size3 = v->vc1dsp.vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
961 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
962 buf_size3 << 3);
963 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
964 slices[n_slices].rawbuf = divider;
965 slices[n_slices].raw_size = buf + buf_size - divider;
966 n_slices1 = n_slices - 1;
967 n_slices++;
968 }
969 buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, divider - buf, buf2);
970 } else {
971 buf_size2 = v->vc1dsp.vc1_unescape_buffer(buf, buf_size, buf2);
972 }
973 298 init_get_bits(&s->gb, buf2, buf_size2*8);
974 } else{
975 178 ret = init_get_bits8(&s->gb, buf, buf_size);
976
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 178 times.
178 if (ret < 0)
977 return ret;
978 }
979
980
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (v->res_sprite) {
981 v->new_sprite = !get_bits1(&s->gb);
982 v->two_sprites = get_bits1(&s->gb);
983 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
984 we're using the sprite compositor. These are intentionally kept separate
985 so you can get the raw sprites by using the wmv3 decoder for WMVP or
986 the vc1 one for WVP2 */
987 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
988 if (v->new_sprite) {
989 // switch AVCodecContext parameters to those of the sprites
990 avctx->width = avctx->coded_width = v->sprite_width;
991 avctx->height = avctx->coded_height = v->sprite_height;
992 } else {
993 goto image;
994 }
995 }
996 }
997
998
2/2
✓ Branch 0 taken 466 times.
✓ Branch 1 taken 10 times.
476 if (s->context_initialized &&
999
1/2
✓ Branch 0 taken 466 times.
✗ Branch 1 not taken.
466 (s->width != avctx->coded_width ||
1000
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 466 times.
466 s->height != avctx->coded_height)) {
1001 ff_vc1_decode_end(avctx);
1002 }
1003
1004
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 466 times.
476 if (!s->context_initialized) {
1005 10 ret = ff_vc1_decode_init(avctx);
1006
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 if (ret < 0)
1007 goto err;
1008
1009
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
10 s->low_delay = !avctx->has_b_frames || v->res_sprite;
1010
1011
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 3 times.
10 if (v->profile == PROFILE_ADVANCED) {
1012
2/4
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
7 if(avctx->coded_width<=1 || avctx->coded_height<=1) {
1013 ret = AVERROR_INVALIDDATA;
1014 goto err;
1015 }
1016 7 s->h_edge_pos = avctx->coded_width;
1017 7 s->v_edge_pos = avctx->coded_height;
1018 }
1019 }
1020
1021 // do parse frame header
1022 476 v->pic_header_flag = 0;
1023 476 v->first_pic_header_flag = 1;
1024
2/2
✓ Branch 0 taken 178 times.
✓ Branch 1 taken 298 times.
476 if (v->profile < PROFILE_ADVANCED) {
1025
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 178 times.
178 if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
1026 goto err;
1027 }
1028 } else {
1029
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 298 times.
298 if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1030 goto err;
1031 }
1032 }
1033 476 v->first_pic_header_flag = 0;
1034
1035
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (avctx->debug & FF_DEBUG_PICT_INFO)
1036 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
1037
1038
2/4
✓ Branch 0 taken 476 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 476 times.
476 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
1039 && s->pict_type != AV_PICTURE_TYPE_I) {
1040 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
1041 ret = AVERROR_INVALIDDATA;
1042 goto err;
1043 }
1044
2/4
✓ Branch 0 taken 476 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 476 times.
476 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
1045 && v->field_mode) {
1046 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected Frames not Fields\n");
1047 ret = AVERROR_INVALIDDATA;
1048 goto err;
1049 }
1050
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if ((s->mb_height >> v->field_mode) == 0) {
1051 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
1052 ret = AVERROR_INVALIDDATA;
1053 goto err;
1054 }
1055
1056 // for skipping the frame
1057 476 s->current_picture.f->pict_type = s->pict_type;
1058 476 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1059
1060 /* skip B-frames if we don't have reference frames */
1061
3/4
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 456 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 20 times.
476 if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
1062 av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
1063 goto end;
1064 }
1065
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
476 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
1066
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
476 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
1067
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 avctx->skip_frame >= AVDISCARD_ALL) {
1068 goto end;
1069 }
1070
1071
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 476 times.
476 if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
1072 goto err;
1073 }
1074
1075 476 v->s.current_picture_ptr->field_picture = v->field_mode;
1076 476 v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
1077 476 v->s.current_picture_ptr->f->top_field_first = v->tff;
1078
1079 // process pulldown flags
1080 476 s->current_picture_ptr->f->repeat_pict = 0;
1081 // Pulldown flags are only valid when 'broadcast' has been set.
1082 // So ticks_per_frame will be 2
1083
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (v->rff) {
1084 // repeat field
1085 s->current_picture_ptr->f->repeat_pict = 1;
1086
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 } else if (v->rptfrm) {
1087 // repeat frames
1088 s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
1089 }
1090
1091
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 if (avctx->hwaccel) {
1092 s->mb_y = 0;
1093 if (v->field_mode && buf_start_second_field) {
1094 // decode first field
1095 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
1096 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
1097 goto err;
1098
1099 if (n_slices1 == -1) {
1100 // no slices, decode the field as-is
1101 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
1102 goto err;
1103 } else {
1104 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
1105 goto err;
1106
1107 for (i = 0 ; i < n_slices1 + 1; i++) {
1108 s->gb = slices[i].gb;
1109 s->mb_y = slices[i].mby_start;
1110
1111 v->pic_header_flag = get_bits1(&s->gb);
1112 if (v->pic_header_flag) {
1113 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1114 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1115 ret = AVERROR_INVALIDDATA;
1116 if (avctx->err_recognition & AV_EF_EXPLODE)
1117 goto err;
1118 continue;
1119 }
1120 }
1121
1122 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1123 goto err;
1124 }
1125 }
1126
1127 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1128 goto err;
1129
1130 // decode second field
1131 s->gb = slices[n_slices1 + 1].gb;
1132 s->mb_y = slices[n_slices1 + 1].mby_start;
1133 s->picture_structure = PICT_TOP_FIELD + v->tff;
1134 v->second_field = 1;
1135 v->pic_header_flag = 0;
1136 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1137 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
1138 ret = AVERROR_INVALIDDATA;
1139 goto err;
1140 }
1141 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
1142
1143 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
1144 goto err;
1145
1146 if (n_slices - n_slices1 == 2) {
1147 // no slices, decode the field as-is
1148 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
1149 goto err;
1150 } else {
1151 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, slices[n_slices1 + 2].rawbuf - buf_start_second_field)) < 0)
1152 goto err;
1153
1154 for (i = n_slices1 + 2; i < n_slices; i++) {
1155 s->gb = slices[i].gb;
1156 s->mb_y = slices[i].mby_start;
1157
1158 v->pic_header_flag = get_bits1(&s->gb);
1159 if (v->pic_header_flag) {
1160 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1161 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1162 ret = AVERROR_INVALIDDATA;
1163 if (avctx->err_recognition & AV_EF_EXPLODE)
1164 goto err;
1165 continue;
1166 }
1167 }
1168
1169 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1170 goto err;
1171 }
1172 }
1173
1174 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1175 goto err;
1176 } else {
1177 s->picture_structure = PICT_FRAME;
1178 if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
1179 goto err;
1180
1181 if (n_slices == 0) {
1182 // no slices, decode the frame as-is
1183 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
1184 goto err;
1185 } else {
1186 // decode the frame part as the first slice
1187 if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
1188 goto err;
1189
1190 // and process the slices as additional slices afterwards
1191 for (i = 0 ; i < n_slices; i++) {
1192 s->gb = slices[i].gb;
1193 s->mb_y = slices[i].mby_start;
1194
1195 v->pic_header_flag = get_bits1(&s->gb);
1196 if (v->pic_header_flag) {
1197 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
1198 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1199 ret = AVERROR_INVALIDDATA;
1200 if (avctx->err_recognition & AV_EF_EXPLODE)
1201 goto err;
1202 continue;
1203 }
1204 }
1205
1206 if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
1207 goto err;
1208 }
1209 }
1210 if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
1211 goto err;
1212 }
1213 } else {
1214 476 int header_ret = 0;
1215
1216 476 ff_mpeg_er_frame_start(s);
1217
1218 476 v->end_mb_x = s->mb_width;
1219
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 440 times.
476 if (v->field_mode) {
1220 36 s->current_picture.f->linesize[0] <<= 1;
1221 36 s->current_picture.f->linesize[1] <<= 1;
1222 36 s->current_picture.f->linesize[2] <<= 1;
1223 36 s->linesize <<= 1;
1224 36 s->uvlinesize <<= 1;
1225 }
1226 476 mb_height = s->mb_height >> v->field_mode;
1227
1228
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
476 av_assert0 (mb_height > 0);
1229
1230
2/2
✓ Branch 0 taken 1109 times.
✓ Branch 1 taken 476 times.
1585 for (i = 0; i <= n_slices; i++) {
1231
4/4
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 597 times.
1109 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
1232
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (v->field_mode <= 0) {
1233 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
1234 "picture boundary (%d >= %d)\n", i,
1235 slices[i - 1].mby_start, mb_height);
1236 continue;
1237 }
1238 36 v->second_field = 1;
1239
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 av_assert0((s->mb_height & 1) == 0);
1240 36 v->blocks_off = s->b8_stride * (s->mb_height&~1);
1241 36 v->mb_off = s->mb_stride * s->mb_height >> 1;
1242 } else {
1243 1073 v->second_field = 0;
1244 1073 v->blocks_off = 0;
1245 1073 v->mb_off = 0;
1246 }
1247
2/2
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
1109 if (i) {
1248 633 v->pic_header_flag = 0;
1249
3/4
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 597 times.
✓ Branch 2 taken 36 times.
✗ Branch 3 not taken.
633 if (v->field_mode && i == n_slices1 + 2) {
1250
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 36 times.
36 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1251 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
1252 ret = AVERROR_INVALIDDATA;
1253 if (avctx->err_recognition & AV_EF_EXPLODE)
1254 goto err;
1255 continue;
1256 }
1257
2/2
✓ Branch 1 taken 271 times.
✓ Branch 2 taken 326 times.
597 } else if (get_bits1(&s->gb)) {
1258 271 v->pic_header_flag = 1;
1259
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 271 times.
271 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
1260 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
1261 ret = AVERROR_INVALIDDATA;
1262 if (avctx->err_recognition & AV_EF_EXPLODE)
1263 goto err;
1264 continue;
1265 }
1266 }
1267 }
1268
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1109 times.
1109 if (header_ret < 0)
1269 continue;
1270
2/2
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
1109 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
1271
4/4
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 1037 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 36 times.
1109 if (!v->field_mode || v->second_field)
1272
2/2
✓ Branch 0 taken 597 times.
✓ Branch 1 taken 476 times.
1073 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1273 else {
1274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 if (i >= n_slices) {
1275 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
1276 continue;
1277 }
1278
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
36 s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
1279 }
1280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1109 times.
1109 if (s->end_mb_y <= s->start_mb_y) {
1281 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
1282 continue;
1283 }
1284
4/4
✓ Branch 0 taken 982 times.
✓ Branch 1 taken 127 times.
✓ Branch 2 taken 67 times.
✓ Branch 3 taken 915 times.
1109 if (((s->pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
1285
3/4
✓ Branch 0 taken 109 times.
✓ Branch 1 taken 85 times.
✓ Branch 2 taken 109 times.
✗ Branch 3 not taken.
194 (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)) &&
1286
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1024 times.
1024 !v->cbpcy_vlc) {
1287 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
1288 continue;
1289 }
1290 1109 ff_vc1_decode_blocks(v);
1291
2/2
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
1109 if (i != n_slices) {
1292 633 s->gb = slices[i].gb;
1293 }
1294 }
1295
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 440 times.
476 if (v->field_mode) {
1296 36 v->second_field = 0;
1297 36 s->current_picture.f->linesize[0] >>= 1;
1298 36 s->current_picture.f->linesize[1] >>= 1;
1299 36 s->current_picture.f->linesize[2] >>= 1;
1300 36 s->linesize >>= 1;
1301 36 s->uvlinesize >>= 1;
1302
3/4
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 18 times.
36 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
1303 18 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
1304 18 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
1305 }
1306 }
1307 ff_dlog(s->avctx, "Consumed %i/%i bits\n",
1308 get_bits_count(&s->gb), s->gb.size_in_bits);
1309 // if (get_bits_count(&s->gb) > buf_size * 8)
1310 // return -1;
1311
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
476 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
1312 ret = AVERROR_INVALIDDATA;
1313 goto err;
1314 }
1315
2/2
✓ Branch 0 taken 440 times.
✓ Branch 1 taken 36 times.
476 if ( !v->field_mode
1316
1/2
✓ Branch 0 taken 440 times.
✗ Branch 1 not taken.
440 && avctx->codec_id != AV_CODEC_ID_WMV3IMAGE
1317
1/2
✓ Branch 0 taken 440 times.
✗ Branch 1 not taken.
440 && avctx->codec_id != AV_CODEC_ID_VC1IMAGE)
1318 440 ff_er_frame_end(&s->er);
1319 }
1320
1321 476 ff_mpv_frame_end(s);
1322
1323
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 476 times.
476 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
1324 image:
1325 avctx->width = avctx->coded_width = v->output_width;
1326 avctx->height = avctx->coded_height = v->output_height;
1327 if (avctx->skip_frame >= AVDISCARD_NONREF)
1328 goto end;
1329 if (!v->sprite_output_frame &&
1330 !(v->sprite_output_frame = av_frame_alloc())) {
1331 ret = AVERROR(ENOMEM);
1332 goto err;
1333 }
1334 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
1335 if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
1336 goto err;
1337 #endif
1338 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
1339 goto err;
1340 *got_frame = 1;
1341 } else {
1342
4/4
✓ Branch 0 taken 385 times.
✓ Branch 1 taken 91 times.
✓ Branch 2 taken 154 times.
✓ Branch 3 taken 231 times.
476 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1343
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 245 times.
245 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
1344 goto err;
1345
2/2
✓ Branch 0 taken 227 times.
✓ Branch 1 taken 18 times.
245 if (!v->field_mode)
1346 227 ff_print_debug_info(s, s->current_picture_ptr, pict);
1347 245 *got_frame = 1;
1348
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 223 times.
231 } else if (s->last_picture_ptr) {
1349
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 223 times.
223 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
1350 goto err;
1351
2/2
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 17 times.
223 if (!v->field_mode)
1352 206 ff_print_debug_info(s, s->last_picture_ptr, pict);
1353 223 *got_frame = 1;
1354 }
1355 }
1356
1357 8 end:
1358 476 av_free(buf2);
1359
2/2
✓ Branch 0 taken 633 times.
✓ Branch 1 taken 476 times.
1109 for (i = 0; i < n_slices; i++)
1360 633 av_free(slices[i].buf);
1361 476 av_free(slices);
1362 476 return buf_size;
1363
1364 err:
1365 av_free(buf2);
1366 for (i = 0; i < n_slices; i++)
1367 av_free(slices[i].buf);
1368 av_free(slices);
1369 return ret;
1370 }
1371
1372
1373 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
1374 #if CONFIG_VC1_DXVA2_HWACCEL
1375 AV_PIX_FMT_DXVA2_VLD,
1376 #endif
1377 #if CONFIG_VC1_D3D11VA_HWACCEL
1378 AV_PIX_FMT_D3D11VA_VLD,
1379 AV_PIX_FMT_D3D11,
1380 #endif
1381 #if CONFIG_VC1_NVDEC_HWACCEL
1382 AV_PIX_FMT_CUDA,
1383 #endif
1384 #if CONFIG_VC1_VAAPI_HWACCEL
1385 AV_PIX_FMT_VAAPI,
1386 #endif
1387 #if CONFIG_VC1_VDPAU_HWACCEL
1388 AV_PIX_FMT_VDPAU,
1389 #endif
1390 AV_PIX_FMT_YUV420P,
1391 AV_PIX_FMT_NONE
1392 };
1393
1394 const FFCodec ff_vc1_decoder = {
1395 .p.name = "vc1",
1396 CODEC_LONG_NAME("SMPTE VC-1"),
1397 .p.type = AVMEDIA_TYPE_VIDEO,
1398 .p.id = AV_CODEC_ID_VC1,
1399 .priv_data_size = sizeof(VC1Context),
1400 .init = vc1_decode_init,
1401 .close = ff_vc1_decode_end,
1402 FF_CODEC_DECODE_CB(vc1_decode_frame),
1403 .flush = ff_mpeg_flush,
1404 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1405 .p.pix_fmts = vc1_hwaccel_pixfmt_list_420,
1406 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1407 #if CONFIG_VC1_DXVA2_HWACCEL
1408 HWACCEL_DXVA2(vc1),
1409 #endif
1410 #if CONFIG_VC1_D3D11VA_HWACCEL
1411 HWACCEL_D3D11VA(vc1),
1412 #endif
1413 #if CONFIG_VC1_D3D11VA2_HWACCEL
1414 HWACCEL_D3D11VA2(vc1),
1415 #endif
1416 #if CONFIG_VC1_NVDEC_HWACCEL
1417 HWACCEL_NVDEC(vc1),
1418 #endif
1419 #if CONFIG_VC1_VAAPI_HWACCEL
1420 HWACCEL_VAAPI(vc1),
1421 #endif
1422 #if CONFIG_VC1_VDPAU_HWACCEL
1423 HWACCEL_VDPAU(vc1),
1424 #endif
1425 NULL
1426 },
1427 .p.profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1428 };
1429
1430 #if CONFIG_WMV3_DECODER
1431 const FFCodec ff_wmv3_decoder = {
1432 .p.name = "wmv3",
1433 CODEC_LONG_NAME("Windows Media Video 9"),
1434 .p.type = AVMEDIA_TYPE_VIDEO,
1435 .p.id = AV_CODEC_ID_WMV3,
1436 .priv_data_size = sizeof(VC1Context),
1437 .init = vc1_decode_init,
1438 .close = ff_vc1_decode_end,
1439 FF_CODEC_DECODE_CB(vc1_decode_frame),
1440 .flush = ff_mpeg_flush,
1441 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1442 .p.pix_fmts = vc1_hwaccel_pixfmt_list_420,
1443 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1444 #if CONFIG_WMV3_DXVA2_HWACCEL
1445 HWACCEL_DXVA2(wmv3),
1446 #endif
1447 #if CONFIG_WMV3_D3D11VA_HWACCEL
1448 HWACCEL_D3D11VA(wmv3),
1449 #endif
1450 #if CONFIG_WMV3_D3D11VA2_HWACCEL
1451 HWACCEL_D3D11VA2(wmv3),
1452 #endif
1453 #if CONFIG_WMV3_NVDEC_HWACCEL
1454 HWACCEL_NVDEC(wmv3),
1455 #endif
1456 #if CONFIG_WMV3_VAAPI_HWACCEL
1457 HWACCEL_VAAPI(wmv3),
1458 #endif
1459 #if CONFIG_WMV3_VDPAU_HWACCEL
1460 HWACCEL_VDPAU(wmv3),
1461 #endif
1462 NULL
1463 },
1464 .p.profiles = NULL_IF_CONFIG_SMALL(ff_vc1_profiles)
1465 };
1466 #endif
1467
1468 #if CONFIG_WMV3IMAGE_DECODER
1469 const FFCodec ff_wmv3image_decoder = {
1470 .p.name = "wmv3image",
1471 CODEC_LONG_NAME("Windows Media Video 9 Image"),
1472 .p.type = AVMEDIA_TYPE_VIDEO,
1473 .p.id = AV_CODEC_ID_WMV3IMAGE,
1474 .priv_data_size = sizeof(VC1Context),
1475 .init = vc1_decode_init,
1476 .close = ff_vc1_decode_end,
1477 FF_CODEC_DECODE_CB(vc1_decode_frame),
1478 .p.capabilities = AV_CODEC_CAP_DR1,
1479 .flush = vc1_sprite_flush,
1480 .p.pix_fmts = (const enum AVPixelFormat[]) {
1481 AV_PIX_FMT_YUV420P,
1482 AV_PIX_FMT_NONE
1483 },
1484 };
1485 #endif
1486
1487 #if CONFIG_VC1IMAGE_DECODER
1488 const FFCodec ff_vc1image_decoder = {
1489 .p.name = "vc1image",
1490 CODEC_LONG_NAME("Windows Media Video 9 Image v2"),
1491 .p.type = AVMEDIA_TYPE_VIDEO,
1492 .p.id = AV_CODEC_ID_VC1IMAGE,
1493 .priv_data_size = sizeof(VC1Context),
1494 .init = vc1_decode_init,
1495 .close = ff_vc1_decode_end,
1496 FF_CODEC_DECODE_CB(vc1_decode_frame),
1497 .p.capabilities = AV_CODEC_CAP_DR1,
1498 .flush = vc1_sprite_flush,
1499 .p.pix_fmts = (const enum AVPixelFormat[]) {
1500 AV_PIX_FMT_YUV420P,
1501 AV_PIX_FMT_NONE
1502 },
1503 };
1504 #endif
1505