FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/ffv1dec.c
Date: 2026-08-28 18:35:09
Exec Total Coverage
Lines: 319 616 51.8%
Functions: 13 18 72.2%
Branches: 189 460 41.1%
Line Branch Exec Source
1 /*
2 * FFV1 decoder
3 *
4 * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 /**
24 * @file
25 * FF Video Codec 1 (a lossless codec) decoder
26 */
27
28 #include "libavutil/avassert.h"
29 #include "libavutil/crc.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/pixdesc.h"
33 #include "avcodec.h"
34 #include "codec_internal.h"
35 #include "get_bits.h"
36 #include "rangecoder.h"
37 #include "golomb.h"
38 #include "mathops.h"
39 #include "ffv1.h"
40 #include "progressframe.h"
41 #include "libavutil/refstruct.h"
42 #include "thread.h"
43 #include "decode.h"
44 #include "hwconfig.h"
45 #include "hwaccel_internal.h"
46 #include "config_components.h"
47
48 163659991 static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
49 int bits)
50 {
51 int k, i, v, ret;
52
53 163659991 i = state->count;
54 163659991 k = 0;
55
2/2
✓ Branch 0 taken 272532174 times.
✓ Branch 1 taken 163659991 times.
 436192165 while (i < state->error_sum) { // FIXME: optimize
56 272532174 k++;
57 272532174 i += i;
58 }
59
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 163659991 times.
 163659991 if (k > bits) {
60 ff_dlog(NULL, "k-overflow bias:%d error:%d drift:%d count:%d k:%d",
61 state->bias, state->error_sum, state->drift, state->count, k);
62 ✗ k = bits;
63 }
64
65 163659991 v = get_sr_golomb(gb, k, 12, bits);
66 ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
67 v, state->bias, state->error_sum, state->drift, state->count, k);
68
69 163659991 v ^= ((2 * state->drift + state->count) >> 31);
70
71 163659991 ret = fold(v + state->bias, bits);
72
73 163659991 update_vlc_state(state, v);
74
75 163659991 return ret;
76 }
77
78 4542400 static int is_input_end(RangeCoder *c, GetBitContext *gb, int ac)
79 {
80
2/2
✓ Branch 0 taken 2514800 times.
✓ Branch 1 taken 2027600 times.
 4542400 if (ac != AC_GOLOMB_RICE) {
81
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2514800 times.
 2514800 if (c->overread > MAX_OVERREAD)
82 ✗ return AVERROR_INVALIDDATA;
83 } else {
84
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2027600 times.
 2027600 if (get_bits_left(gb) < 1)
85 ✗ return AVERROR_INVALIDDATA;
86 }
87 4542400 return 0;
88 }
89
90 #define TYPE int16_t
91 #define RENAME(name) name
92 #include "ffv1dec_template.c"
93 #undef TYPE
94 #undef RENAME
95
96 #define TYPE int32_t
97 #define RENAME(name) name ## 32
98 #include "ffv1dec_template.c"
99
100 18300 static int decode_plane(FFV1Context *f, FFV1SliceContext *sc,
101 GetBitContext *gb,
102 uint8_t *src, int w, int h, int stride, int plane_index,
103 int remap_index, int pixel_stride, int ac)
104 {
105 int x, y;
106 int16_t *sample[2];
107 int bits;
108 unsigned mask;
109
110
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18300 times.
 18300 if (sc->remap) {
111 ✗ bits = av_ceil_log2(sc->remap_count[remap_index]);
112 ✗ mask = (1<<bits)-1;
113
114 ✗ av_assert0(sc->fltmap_size[remap_index] >= (mask + 1) * sizeof(*sc->fltmap[remap_index]));
115 } else {
116 18300 bits = f->avctx->bits_per_raw_sample;
117 }
118
119 18300 sample[0] = sc->sample_buffer + 3;
120 18300 sample[1] = sc->sample_buffer + w + 6 + 3;
121
122 18300 sc->run_index = 0;
123
124 18300 memset(sc->sample_buffer, 0, 2 * (w + 6) * sizeof(*sc->sample_buffer));
125
126
2/2
✓ Branch 0 taken 1732400 times.
✓ Branch 1 taken 18300 times.
 1750700 for (y = 0; y < h; y++) {
127 1732400 int16_t *temp = sample[0]; // FIXME: try a normal buffer
128
129 1732400 sample[0] = sample[1];
130 1732400 sample[1] = temp;
131
132 1732400 sample[1][-1] = sample[0][0];
133 1732400 sample[0][w] = sample[0][w - 1];
134
135
2/2
✓ Branch 0 taken 924200 times.
✓ Branch 1 taken 808200 times.
 1732400 if (f->avctx->bits_per_raw_sample <= 8) {
136 924200 int ret = decode_line(f, sc, gb, w, sample, plane_index, 8, ac);
137
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 924200 times.
 924200 if (ret < 0)
138 ✗ return ret;
139
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 924200 times.
 924200 if (sc->remap)
140 ✗ for (x = 0; x < w; x++)
141 ✗ sample[1][x] = sc->fltmap[remap_index][sample[1][x] & mask];
142
2/2
✓ Branch 0 taken 145253900 times.
✓ Branch 1 taken 924200 times.
 146178100 for (x = 0; x < w; x++)
143 145253900 src[x*pixel_stride + stride * y] = sample[1][x];
144 } else {
145 808200 int ret = decode_line(f, sc, gb, w, sample, plane_index, bits, ac);
146
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 808200 times.
 808200 if (ret < 0)
147 ✗ return ret;
148
149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 808200 times.
 808200 if (sc->remap) {
150 ✗ if (f->packed_at_lsb || f->avctx->bits_per_raw_sample == 16) {
151 ✗ for (x = 0; x < w; x++) {
152 ✗ ((uint16_t*)(src + stride*y))[x*pixel_stride] = sc->fltmap[remap_index][sample[1][x] & mask];
153 }
154 } else {
155 ✗ for (x = 0; x < w; x++) {
156 ✗ int v = sc->fltmap[remap_index][sample[1][x] & mask];
157 ✗ ((uint16_t*)(src + stride*y))[x*pixel_stride] = v << (16 - f->avctx->bits_per_raw_sample) | v >> (2 * f->avctx->bits_per_raw_sample - 16);
158 }
159 }
160 } else {
161
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 808200 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 808200 if (f->packed_at_lsb || f->avctx->bits_per_raw_sample == 16) {
162
2/2
✓ Branch 0 taken 106856200 times.
✓ Branch 1 taken 808200 times.
 107664400 for (x = 0; x < w; x++) {
163 106856200 ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
164 }
165 } else {
166 ✗ for (x = 0; x < w; x++) {
167 ✗ ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - f->avctx->bits_per_raw_sample) | ((uint16_t **)sample)[1][x] >> (2 * f->avctx->bits_per_raw_sample - 16);
168 }
169 }
170 }
171 }
172 }
173 18300 return 0;
174 }
175
176 6700 static int decode_slice_header(const FFV1Context *f,
177 FFV1SliceContext *sc, AVFrame *frame)
178 {
179 6700 RangeCoder *c = &sc->c;
180 uint8_t state[CONTEXT_SIZE];
181 unsigned ps, context_count;
182 int sx, sy, sw, sh;
183
184 6700 memset(state, 128, sizeof(state));
185 6700 sx = ff_ffv1_get_symbol(c, state, 0);
186 6700 sy = ff_ffv1_get_symbol(c, state, 0);
187 6700 sw = ff_ffv1_get_symbol(c, state, 0) + 1U;
188 6700 sh = ff_ffv1_get_symbol(c, state, 0) + 1U;
189
190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6700 times.
 6700 av_assert0(f->version > 2);
191
192
193
4/8
✓ Branch 0 taken 6700 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6700 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6700 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 6700 times.
 6700 if (sx < 0 || sy < 0 || sw <= 0 || sh <= 0)
194 ✗ return AVERROR_INVALIDDATA;
195
2/4
✓ Branch 0 taken 6700 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6700 times.
 6700 if (sx > f->num_h_slices - sw || sy > f->num_v_slices - sh)
196 ✗ return AVERROR_INVALIDDATA;
197
198 6700 sc->slice_x = ff_slice_coord(f, f->width , sx , f->num_h_slices, f->chroma_h_shift);
199 6700 sc->slice_y = ff_slice_coord(f, f->height, sy , f->num_v_slices, f->chroma_v_shift);
200 6700 sc->slice_width = ff_slice_coord(f, f->width , sx + sw, f->num_h_slices, f->chroma_h_shift) - sc->slice_x;
201 6700 sc->slice_height = ff_slice_coord(f, f->height, sy + sh, f->num_v_slices, f->chroma_v_shift) - sc->slice_y;
202
203
2/4
✓ Branch 0 taken 6700 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6700 times.
 6700 av_assert0((unsigned)sc->slice_width <= f->width &&
204 (unsigned)sc->slice_height <= f->height);
205
2/4
✓ Branch 0 taken 6700 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6700 times.
 6700 av_assert0 ( (unsigned)sc->slice_x + (uint64_t)sc->slice_width <= f->width
206 && (unsigned)sc->slice_y + (uint64_t)sc->slice_height <= f->height);
207
208
3/4
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 4000 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2700 times.
 6700 if (f->ac == AC_GOLOMB_RICE && sc->slice_width >= (1<<23))
209 ✗ return AVERROR_INVALIDDATA;
210
211
2/2
✓ Branch 0 taken 13400 times.
✓ Branch 1 taken 6700 times.
 20100 for (unsigned i = 0; i < f->plane_count; i++) {
212 13400 PlaneContext * const p = &sc->plane[i];
213 13400 int idx = ff_ffv1_get_symbol(c, state, 0);
214
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13400 times.
 13400 if (idx >= (unsigned)f->quant_table_count) {
215 ✗ av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
216 ✗ return -1;
217 }
218 13400 p->quant_table_index = idx;
219 13400 context_count = f->context_count[idx];
220
221
2/2
✓ Branch 0 taken 1344 times.
✓ Branch 1 taken 12056 times.
 13400 if (p->context_count < context_count) {
222 1344 av_freep(&p->state);
223 1344 av_freep(&p->vlc_state);
224 }
225 13400 p->context_count = context_count;
226 }
227
228 6700 ps = ff_ffv1_get_symbol(c, state, 0);
229
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6700 times.
 6700 if (ps == 1) {
230 ✗ frame->flags |= AV_FRAME_FLAG_INTERLACED;
231 ✗ frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
232
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6700 times.
 6700 } else if (ps == 2) {
233 ✗ frame->flags |= AV_FRAME_FLAG_INTERLACED;
234 ✗ frame->flags &= ~AV_FRAME_FLAG_TOP_FIELD_FIRST;
235
1/2
✓ Branch 0 taken 6700 times.
✗ Branch 1 not taken.
 6700 } else if (ps == 3) {
236 6700 frame->flags &= ~AV_FRAME_FLAG_INTERLACED;
237 }
238 6700 frame->sample_aspect_ratio.num = ff_ffv1_get_symbol(c, state, 0);
239 6700 frame->sample_aspect_ratio.den = ff_ffv1_get_symbol(c, state, 0);
240
241
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6700 times.
 6700 if (av_image_check_sar(f->width, f->height,
242 frame->sample_aspect_ratio) < 0) {
243 ✗ av_log(f->avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
244 frame->sample_aspect_ratio.num,
245 frame->sample_aspect_ratio.den);
246 ✗ frame->sample_aspect_ratio = (AVRational){ 0, 1 };
247 }
248
249
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6700 times.
 6700 if (f->version > 3) {
250 ✗ sc->slice_reset_contexts = get_rac(c, state);
251 ✗ sc->slice_coding_mode = ff_ffv1_get_symbol(c, state, 0);
252 ✗ if (sc->slice_coding_mode != 1 && f->colorspace != 0) {
253 ✗ sc->slice_rct_by_coef = ff_ffv1_get_symbol(c, state, 0);
254 ✗ sc->slice_rct_ry_coef = ff_ffv1_get_symbol(c, state, 0);
255 ✗ if ((uint64_t)sc->slice_rct_by_coef + (uint64_t)sc->slice_rct_ry_coef > 4) {
256 ✗ av_log(f->avctx, AV_LOG_ERROR, "slice_rct_y_coef out of range\n");
257 ✗ return AVERROR_INVALIDDATA;
258 }
259 }
260 ✗ if (f->combined_version >= 0x40004) {
261 ✗ sc->remap = ff_ffv1_get_symbol(c, state, 0);
262 ✗ if (sc->remap > 2U ||
263 ✗ sc->remap && !f->flt) {
264 ✗ av_log(f->avctx, AV_LOG_ERROR, "unsupported remap %d\n", sc->remap);
265 ✗ return AVERROR_INVALIDDATA;
266 }
267 }
268 }
269
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6700 times.
 6700 if (f->avctx->bits_per_raw_sample == 32) {
270 ✗ if (!sc->remap) {
271 ✗ av_log(f->avctx, AV_LOG_ERROR, "unsupported remap\n");
272 ✗ return AVERROR_INVALIDDATA;
273 }
274 }
275
276 6700 return 0;
277 }
278
279 ✗ static void slice_set_damaged(FFV1Context *f, FFV1SliceContext *sc)
280 {
281 ✗ sc->slice_damaged = 1;
282
283 // only set this for frame threading, as for slice threading its value is
284 // not used and setting it would be a race
285 ✗ if (f->avctx->active_thread_type & FF_THREAD_FRAME)
286 ✗ f->frame_damaged = 1;
287 ✗ }
288
289 ✗ static int decode_current_mul(RangeCoder *rc, uint8_t state[32], int *mul, int mul_count, int64_t i)
290 {
291 ✗ int ndx = (i * mul_count) >> 32;
292 av_assert2(ndx <= 4096U);
293
294 ✗ if (mul[ndx] < 0)
295 ✗ mul[ndx] = ff_ffv1_get_symbol(rc, state, 0) & 0x3FFFFFFF;
296
297 ✗ return mul[ndx];
298 }
299
300 ✗ static int decode_remap(FFV1Context *f, FFV1SliceContext *sc)
301 {
302 ✗ unsigned int end = (1LL<<f->avctx->bits_per_raw_sample) - 1;
303 ✗ int flip = sc->remap == 2 ? (end>>1) : 0;
304
305 ✗ for (int p = 0; p < 1 + 2*f->chroma_planes + f->transparency; p++) {
306 ✗ int j = 0;
307 ✗ int lu = 0;
308 uint8_t state[2][3][32];
309 int64_t i;
310 int mul[4096+1];
311 int mul_count;
312
313 ✗ const int is_chroma = (p == 1 || p == 2) && f->chroma_planes;
314 ✗ const int plane_width = AV_CEIL_RSHIFT(sc->slice_width , is_chroma ? f->chroma_h_shift : 0);
315 ✗ const int plane_height = AV_CEIL_RSHIFT(sc->slice_height, is_chroma ? f->chroma_v_shift : 0);
316 ✗ const int pixel_num = FFMIN(plane_width * plane_height, end + 1LL);
317 ✗ const size_t fltmap_ceil = 1ULL << av_ceil_log2(pixel_num);
318
319 ✗ if (f->avctx->bits_per_raw_sample == 32) {
320 ✗ av_fast_malloc(&sc->fltmap32[p], &sc->fltmap32_size[p], fltmap_ceil * sizeof(*sc->fltmap32[p]));
321 ✗ if (!sc->fltmap32[p])
322 ✗ return AVERROR(ENOMEM);
323 } else {
324 ✗ av_fast_malloc(&sc->fltmap[p] , &sc->fltmap_size[p] , fltmap_ceil * sizeof(*sc->fltmap[p]));
325 ✗ if (!sc->fltmap[p])
326 ✗ return AVERROR(ENOMEM);
327 }
328
329 ✗ memset(state, 128, sizeof(state));
330 ✗ mul_count = ff_ffv1_get_symbol(&sc->c, state[0][0], 0);
331
332 ✗ if (mul_count > 4096U)
333 ✗ return AVERROR_INVALIDDATA;
334 ✗ for (int i = 0; i<mul_count; i++) {
335 ✗ mul[i] = -1;
336
337 }
338 ✗ mul[mul_count] = 1;
339
340 ✗ memset(state, 128, sizeof(state));
341 ✗ int current_mul = 1;
342 ✗ for (i=0; i <= end ;) {
343 ✗ unsigned run = get_symbol_inline(&sc->c, state[lu][0], 0);
344 ✗ unsigned run0 = lu ? 0 : run;
345 ✗ unsigned run1 = lu ? run : 1;
346
347 ✗ i += run0 * current_mul;
348
349 ✗ while (run1--) {
350 ✗ if (current_mul > 1) {
351 ✗ int delta = get_symbol_inline(&sc->c, state[lu][1], 1);
352 ✗ if (delta <= -current_mul || delta > current_mul/2)
353 ✗ return AVERROR_INVALIDDATA; //not sure we should check this
354 ✗ i += current_mul - 1 + delta;
355 }
356 ✗ if (i - 1 >= end)
357 ✗ break;
358 ✗ if (j >= pixel_num)
359 ✗ return AVERROR_INVALIDDATA;
360 ✗ if (end <= 0xFFFF) {
361 ✗ sc->fltmap [p][j++] = i ^ ((i& 0x8000) ? 0 : flip);
362 } else
363 ✗ sc->fltmap32[p][j++] = i ^ ((i&0x80000000) ? 0 : flip);
364 ✗ i++;
365 ✗ current_mul = decode_current_mul(&sc->c, state[0][2], mul, mul_count, i);
366 }
367 ✗ if (lu) {
368 ✗ i += current_mul;
369 }
370 ✗ lu ^= !run;
371 }
372 ✗ if (!j)
373 ✗ return AVERROR_INVALIDDATA;
374 ✗ sc->remap_count[p] = j;
375 }
376 ✗ return 0;
377 }
378
379 ✗ static int decode_bayer_frame(FFV1Context *f, FFV1SliceContext *sc,
380 GetBitContext *gb,
381 uint8_t *src, int w, int h, int stride)
382 {
383 int x, y, p;
384 TYPE *sample[4][2];
385 ✗ int ac = f->ac;
386 unsigned mask[4];
387
388 int bits[4], offset;
389 ✗ ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, mask, f->avctx->bits_per_raw_sample);
390
391 ✗ w >>= 1;
392
393 ✗ if (sc->slice_coding_mode == 1)
394 ✗ ac = 1;
395
396 ✗ for (x = 0; x < 4; x++) {
397 ✗ sample[x][0] = RENAME(sc->sample_buffer) + x * 2 * (w + 6) + 3;
398 ✗ sample[x][1] = RENAME(sc->sample_buffer) + (x * 2 + 1) * (w + 6) + 3;
399 }
400
401 ✗ sc->run_index = 0;
402
403 ✗ memset(RENAME(sc->sample_buffer), 0, 8 * (w + 6) * sizeof(*RENAME(sc->sample_buffer)));
404
405 ✗ for (y = 0; y < h; y += 2) {
406 ✗ for (p = 0; p < 4; p++) {
407 int ret;
408 ✗ TYPE *temp = sample[p][0]; // FIXME: try a normal buffer
409
410 ✗ sample[p][0] = sample[p][1];
411 ✗ sample[p][1] = temp;
412
413 ✗ sample[p][1][-1]= sample[p][0][0 ];
414 ✗ sample[p][0][ w]= sample[p][0][w-1];
415 ✗ ret = RENAME(decode_line)(f, sc, gb, w, sample[p],
416 ✗ p == 1 ? 2 : (p > 1), bits[p], ac);
417 ✗ if (ret < 0)
418 ✗ return ret;
419 }
420
421 ✗ for (x = 0; x < w; x++) {
422 ✗ int g_r = sample[0][1][x];
423 ✗ int g_b = sample[1][1][x];
424 ✗ int b = sample[2][1][x];
425 ✗ int r = sample[3][1][x];
426
427 ✗ if (sc->slice_coding_mode != 1) {
428 ✗ b -= offset;
429 ✗ r -= offset;
430 ✗ g_r -= (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2;
431 ✗ b += g_r;
432 ✗ r += g_r;
433
434 /* Recover green pair: encoder stored gm = gb + (gd >> 1), gd = gr - gb */
435 ✗ int gd = g_b - offset;
436 ✗ g_b = g_r - (gd >> 1);
437 ✗ g_r = g_b + gd;
438 }
439
440 ✗ *((uint16_t*)(src + (x*2 + 0)*2 + stride*(y + 0))) = r;
441 ✗ *((uint16_t*)(src + (x*2 + 1)*2 + stride*(y + 0))) = g_r;
442 ✗ *((uint16_t*)(src + (x*2 + 0)*2 + stride*(y + 1))) = g_b;
443 ✗ *((uint16_t*)(src + (x*2 + 1)*2 + stride*(y + 1))) = b;
444 }
445 }
446 ✗ return 0;
447 }
448
449 7700 static int decode_slice(AVCodecContext *c, void *arg)
450 {
451 7700 FFV1Context *f = c->priv_data;
452 7700 FFV1SliceContext *sc = arg;
453 int width, height, x, y, ret;
454 7700 const int ps = av_pix_fmt_desc_get(f->pix_fmt)->comp[0].step;
455 7700 AVFrame * const p = f->picture.f;
456 7700 const int si = sc - f->slices;
457 GetBitContext gb;
458
3/4
✓ Branch 0 taken 3700 times.
✓ Branch 1 taken 4000 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3700 times.
 7700 int ac = f->ac || sc->slice_coding_mode == 1;
459
460
3/4
✓ Branch 0 taken 6928 times.
✓ Branch 1 taken 772 times.
✓ Branch 2 taken 6928 times.
✗ Branch 3 not taken.
 7700 if (!(p->flags & AV_FRAME_FLAG_KEY) && f->last_picture.f)
461 6928 ff_progress_frame_await(&f->last_picture, si);
462
463
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7700 times.
 7700 if (f->slice_damaged[si])
464 ✗ slice_set_damaged(f, sc);
465
466 7700 sc->slice_rct_by_coef = 1;
467 7700 sc->slice_rct_ry_coef = 1;
468
469
2/2
✓ Branch 0 taken 6700 times.
✓ Branch 1 taken 1000 times.
 7700 if (f->version > 2) {
470
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6700 times.
 6700 if (ff_ffv1_init_slice_state(f, sc) < 0)
471 ✗ return AVERROR(ENOMEM);
472
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6700 times.
 6700 if (decode_slice_header(f, sc, p) < 0) {
473 ✗ sc->slice_x = sc->slice_y = sc->slice_height = sc->slice_width = 0;
474 ✗ slice_set_damaged(f, sc);
475 ✗ return AVERROR_INVALIDDATA;
476 }
477 }
478
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7700 times.
 7700 if ((ret = ff_ffv1_init_slice_state(f, sc)) < 0)
479 ✗ return ret;
480
3/4
✓ Branch 0 taken 6928 times.
✓ Branch 1 taken 772 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6928 times.
 7700 if ((p->flags & AV_FRAME_FLAG_KEY) || sc->slice_reset_contexts) {
481 772 ff_ffv1_clear_slice_state(f, sc);
482
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6928 times.
 6928 } else if (sc->slice_damaged) {
483 ✗ return AVERROR_INVALIDDATA;
484 }
485
486 7700 width = sc->slice_width;
487 7700 height = sc->slice_height;
488 7700 x = sc->slice_x;
489 7700 y = sc->slice_y;
490
491
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7700 times.
 7700 if (sc->remap) {
492 ✗ ret = decode_remap(f, sc);
493 ✗ if (ret < 0) {
494 ✗ slice_set_damaged(f, sc);
495 ✗ return ret;
496 }
497 }
498
499
2/2
✓ Branch 0 taken 3700 times.
✓ Branch 1 taken 4000 times.
 7700 if (ac == AC_GOLOMB_RICE) {
500
2/2
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 1000 times.
 3700 if (f->combined_version >= 0x30002)
501 2700 get_rac(&sc->c, (uint8_t[]) { 129 });
502
6/6
✓ Branch 0 taken 1000 times.
✓ Branch 1 taken 2700 times.
✓ Branch 2 taken 600 times.
✓ Branch 3 taken 400 times.
✓ Branch 4 taken 400 times.
✓ Branch 5 taken 200 times.
 3700 sc->ac_byte_count = f->version > 2 || (!x && !y) ? sc->c.bytestream - sc->c.bytestream_start - 1 : 0;
503 3700 init_get_bits(&gb,
504 3700 sc->c.bytestream_start + sc->ac_byte_count,
505 3700 (sc->c.bytestream_end - sc->c.bytestream_start - sc->ac_byte_count) * 8);
506 }
507
508 av_assert1(width && height);
509
3/6
✓ Branch 0 taken 6100 times.
✓ Branch 1 taken 1600 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6100 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 13800 if (f->colorspace == 0 && (f->chroma_planes || !f->transparency)) {
510 6100 const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift);
511 6100 const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
512 6100 const int cx = x >> f->chroma_h_shift;
513 6100 const int cy = y >> f->chroma_v_shift;
514 6100 decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 0, 1, ac);
515
516
1/2
✓ Branch 0 taken 6100 times.
✗ Branch 1 not taken.
 6100 if (f->chroma_planes) {
517 6100 decode_plane(f, sc, &gb, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1, 1, ac);
518 6100 decode_plane(f, sc, &gb, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 2, 1, ac);
519 }
520
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6100 times.
 6100 if (f->transparency)
521 ✗ decode_plane(f, sc, &gb, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], (f->version >= 4 && !f->chroma_planes) ? 1 : 2,
522 ✗ (f->version >= 4 && !f->chroma_planes) ? 1 : 3, 1, ac);
523
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
 1600 } else if (f->colorspace == 0) {
524 ✗ decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0] , width, height, p->linesize[0], 0, 0, 2, ac);
525 ✗ decode_plane(f, sc, &gb, p->data[0] + ps*x + y*p->linesize[0] + (ps>>1), width, height, p->linesize[0], 1, 1, 2, ac);
526
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
 1600 } else if (f->bayer) {
527 ✗ decode_bayer_frame(f, sc, &gb, p->data[0] + ps * x + y * p->linesize[0],
528 width, height, p->linesize[0]);
529
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 800 times.
 1600 } else if (f->use32bit) {
530 800 uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
531 800 p->data[1] + ps * x + y * p->linesize[1],
532 800 p->data[2] + ps * x + y * p->linesize[2] };
533
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 800 times.
 800 if (f->transparency)
534 ✗ planes[3] = p->data[3] + ps * x + y * p->linesize[3];
535 800 decode_rgb_frame32(f, sc, &gb, planes, width, height, p->linesize);
536 } else {
537 800 uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0] };
538
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 800 times.
 800 if (f->avctx->bits_per_raw_sample > 8) {
539 ✗ planes[1] = p->data[1] + ps * x + y * p->linesize[1];
540 ✗ planes[2] = p->data[2] + ps * x + y * p->linesize[2];
541 ✗ if (f->transparency)
542 ✗ planes[3] = p->data[3] + ps * x + y * p->linesize[3];
543 }
544 800 decode_rgb_frame(f, sc, &gb, planes, width, height, p->linesize);
545 }
546
3/4
✓ Branch 0 taken 4000 times.
✓ Branch 1 taken 3700 times.
✓ Branch 2 taken 4000 times.
✗ Branch 3 not taken.
 7700 if (ac != AC_GOLOMB_RICE && f->version > 2) {
547 int v;
548 4000 get_rac(&sc->c, (uint8_t[]) { 129 });
549
1/2
✓ Branch 0 taken 4000 times.
✗ Branch 1 not taken.
 4000 v = sc->c.bytestream_end - sc->c.bytestream - 2 - 5*!!f->ec;
550
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4000 times.
 4000 if (v) {
551 ✗ av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v);
552 ✗ slice_set_damaged(f, sc);
553 }
554 }
555
556
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 7700 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 7700 if (sc->slice_damaged && (f->avctx->err_recognition & AV_EF_EXPLODE))
557 ✗ return AVERROR_INVALIDDATA;
558
559
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 7700 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 7700 if ((c->active_thread_type & FF_THREAD_FRAME) && !f->frame_damaged)
560 ✗ ff_progress_frame_report(&f->picture, si);
561
562 7700 return 0;
563 }
564
565 87 static enum AVPixelFormat get_pixel_format(FFV1Context *f)
566 {
567 87 enum AVPixelFormat pix_fmts[] = {
568 #if CONFIG_FFV1_VULKAN_HWACCEL
569 AV_PIX_FMT_VULKAN,
570 #endif
571 87 f->pix_fmt,
572 AV_PIX_FMT_NONE,
573 };
574
575 87 return ff_get_format(f->avctx, pix_fmts);
576 }
577
578 253 static int read_header(FFV1Context *f, RangeCoder *c)
579 {
580 uint8_t state[CONTEXT_SIZE];
581 253 int context_count = -1; //-1 to avoid warning
582 int ret;
583
584 253 memset(state, 128, sizeof(state));
585
586 253 ret = ff_ffv1_parse_header(f, c, state);
587
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 253 times.
 253 if (ret < 0)
588 ✗ return ret;
589
590
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 253 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 253 if (f->bayer && f->combined_version <= 0x40002) {
591 ✗ av_log(f->avctx, AV_LOG_ERROR,
592 "Bayer requires aligned slice coordinates (combined_version > 0x40002)\n");
593 ✗ return AVERROR_INVALIDDATA;
594 }
595
596
2/2
✓ Branch 0 taken 166 times.
✓ Branch 1 taken 87 times.
 253 if (f->configured_pix_fmt != f->pix_fmt ||
597
1/2
✓ Branch 0 taken 166 times.
✗ Branch 1 not taken.
 166 f->configured_width != f->width ||
598
1/2
✓ Branch 0 taken 166 times.
✗ Branch 1 not taken.
 166 f->configured_height != f->height ||
599
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 166 times.
 166 f->configured_ac != f->ac) {
600 87 f->avctx->pix_fmt = get_pixel_format(f);
601
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 87 times.
 87 if (f->avctx->pix_fmt < 0)
602 ✗ return AVERROR(EINVAL);
603 87 f->configured_pix_fmt = f->pix_fmt;
604 87 f->configured_width = f->width;
605 87 f->configured_height = f->height;
606 87 f->configured_ac = f->ac;
607 }
608
609 ff_dlog(f->avctx, "%d %d %d\n",
610 f->chroma_h_shift, f->chroma_v_shift, f->pix_fmt);
611
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 229 times.
 253 if (f->version < 2) {
612 24 context_count = ff_ffv1_read_quant_tables(c, f->quant_tables[0]);
613
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 if (context_count < 0) {
614 ✗ av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
615 ✗ return AVERROR_INVALIDDATA;
616 }
617 24 f->slice_count = f->max_slice_count;
618
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 205 times.
 229 } else if (f->version < 3) {
619 24 f->slice_count = ff_ffv1_get_symbol(c, state, 0);
620 } else {
621 205 const uint8_t *p = c->bytestream_end;
622 205 for (f->slice_count = 0;
623
4/6
✓ Branch 0 taken 1035 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1035 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 830 times.
✓ Branch 5 taken 205 times.
 1035 f->slice_count < MAX_SLICES && 3 + 5*!!f->ec < p - c->bytestream_start;
624 830 f->slice_count++) {
625
1/2
✓ Branch 0 taken 830 times.
✗ Branch 1 not taken.
 830 int trailer = 3 + 5*!!f->ec;
626 830 int size = AV_RB24(p-trailer);
627
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 830 times.
 830 if (size + trailer > p - c->bytestream_start)
628 ✗ break;
629 830 p -= size + trailer;
630 }
631 }
632
3/6
✓ Branch 0 taken 253 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 253 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 253 times.
 253 if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0 || f->slice_count > f->max_slice_count) {
633 ✗ av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid (max=%d)\n", f->slice_count, f->max_slice_count);
634 ✗ return AVERROR_INVALIDDATA;
635 }
636
637 253 av_refstruct_unref(&f->slice_damaged);
638 253 f->slice_damaged = av_refstruct_allocz(f->slice_count * sizeof(*f->slice_damaged));
639
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 253 times.
 253 if (!f->slice_damaged)
640 ✗ return AVERROR(ENOMEM);
641
642
2/2
✓ Branch 0 taken 950 times.
✓ Branch 1 taken 253 times.
 1203 for (int j = 0; j < f->slice_count; j++) {
643 950 FFV1SliceContext *sc = &f->slices[j];
644
645
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 854 times.
 950 if (f->version == 2) {
646 96 int sx = ff_ffv1_get_symbol(c, state, 0);
647 96 int sy = ff_ffv1_get_symbol(c, state, 0);
648 96 int sw = ff_ffv1_get_symbol(c, state, 0) + 1U;
649 96 int sh = ff_ffv1_get_symbol(c, state, 0) + 1U;
650
651
4/8
✓ Branch 0 taken 96 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 96 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 96 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 96 times.
 96 if (sx < 0 || sy < 0 || sw <= 0 || sh <= 0)
652 ✗ return AVERROR_INVALIDDATA;
653
2/4
✓ Branch 0 taken 96 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 96 times.
 96 if (sx > f->num_h_slices - sw || sy > f->num_v_slices - sh)
654 ✗ return AVERROR_INVALIDDATA;
655
656 96 sc->slice_x = sx * (int64_t)f->width / f->num_h_slices;
657 96 sc->slice_y = sy * (int64_t)f->height / f->num_v_slices;
658 96 sc->slice_width = (sx + sw) * (int64_t)f->width / f->num_h_slices - sc->slice_x;
659 96 sc->slice_height = (sy + sh) * (int64_t)f->height / f->num_v_slices - sc->slice_y;
660
661
2/4
✓ Branch 0 taken 96 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 96 times.
 96 av_assert0((unsigned)sc->slice_width <= f->width &&
662 (unsigned)sc->slice_height <= f->height);
663
2/4
✓ Branch 0 taken 96 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 96 times.
 96 av_assert0 ( (unsigned)sc->slice_x + (uint64_t)sc->slice_width <= f->width
664 && (unsigned)sc->slice_y + (uint64_t)sc->slice_height <= f->height);
665 }
666
667 950 av_refstruct_unref(&sc->plane);
668 950 sc->plane = ff_ffv1_planes_alloc();
669
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 950 times.
 950 if (!sc->plane)
670 ✗ return AVERROR(ENOMEM);
671
672
2/2
✓ Branch 0 taken 1900 times.
✓ Branch 1 taken 950 times.
 2850 for (int i = 0; i < f->plane_count; i++) {
673 1900 PlaneContext *const p = &sc->plane[i];
674
675
2/2
✓ Branch 0 taken 192 times.
✓ Branch 1 taken 1708 times.
 1900 if (f->version == 2) {
676 192 int idx = ff_ffv1_get_symbol(c, state, 0);
677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 192 times.
 192 if (idx >= (unsigned)f->quant_table_count) {
678 ✗ av_log(f->avctx, AV_LOG_ERROR,
679 "quant_table_index out of range\n");
680 ✗ return AVERROR_INVALIDDATA;
681 }
682 192 p->quant_table_index = idx;
683 192 context_count = f->context_count[idx];
684 }
685
686
2/2
✓ Branch 0 taken 240 times.
✓ Branch 1 taken 1660 times.
 1900 if (f->version <= 2) {
687
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 240 times.
 240 av_assert0(context_count >= 0);
688 240 p->context_count = context_count;
689 }
690 }
691 }
692 253 return 0;
693 }
694
695 88 static av_cold int decode_init(AVCodecContext *avctx)
696 {
697 88 FFV1Context *f = avctx->priv_data;
698 int ret;
699
700 88 f->pix_fmt = AV_PIX_FMT_NONE;
701 88 f->configured_pix_fmt = AV_PIX_FMT_NONE;
702
703
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
 88 if ((ret = ff_ffv1_common_init(avctx, f)) < 0)
704 ✗ return ret;
705
706
3/4
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 80 times.
 88 if (avctx->extradata_size > 0 && (ret = ff_ffv1_read_extra_header(f)) < 0)
707 ✗ return ret;
708
709
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.
 88 if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
710 ✗ return ret;
711
712 88 return 0;
713 }
714
715 7700 static int find_next_slice(AVCodecContext *avctx,
716 uint8_t *buf, uint8_t *buf_end, int idx,
717 uint8_t **pos, uint32_t *len)
718 {
719 7700 FFV1Context *f = avctx->priv_data;
720
721 /* Length field */
722 7700 uint32_t v = buf_end - buf;
723
4/4
✓ Branch 0 taken 2075 times.
✓ Branch 1 taken 5625 times.
✓ Branch 2 taken 1675 times.
✓ Branch 3 taken 400 times.
 7700 if (idx || f->version > 2) {
724 /* Three bytes of length, plus flush bit + CRC */
725
2/2
✓ Branch 0 taken 6700 times.
✓ Branch 1 taken 600 times.
 7300 uint32_t trailer = 3 + 5*!!f->ec;
726
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7300 times.
 7300 if (trailer > buf_end - buf)
727 ✗ v = INT_MAX;
728 else
729 7300 v = AV_RB24(buf_end - trailer) + trailer;
730 }
731
732
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7700 times.
 7700 if (buf_end - buf < v) {
733 ✗ av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
734 ✗ ff_progress_frame_report(&f->picture, INT_MAX);
735 ✗ return AVERROR_INVALIDDATA;
736 }
737
738 7700 *len = v;
739
2/2
✓ Branch 0 taken 5625 times.
✓ Branch 1 taken 2075 times.
 7700 if (idx)
740 5625 *pos = buf_end - v;
741 else
742 2075 *pos = buf;
743
744 7700 return 0;
745 }
746
747 2120 static int decode_header(AVCodecContext *avctx, RangeCoder *c,
748 uint8_t *buf, size_t buf_size)
749 {
750 int ret;
751 2120 FFV1Context *f = avctx->priv_data;
752
753 2120 uint8_t keystate = 128;
754 2120 ff_init_range_decoder(c, buf, buf_size);
755 2120 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
756
757
2/2
✓ Branch 1 taken 253 times.
✓ Branch 2 taken 1867 times.
 2120 if (get_rac(c, &keystate)) {
758 253 f->key_frame = AV_FRAME_FLAG_KEY;
759 253 f->key_frame_ok = 0;
760
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 253 times.
 253 if ((ret = read_header(f, c)) < 0)
761 ✗ return ret;
762 253 f->key_frame_ok = 1;
763 } else {
764
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1867 times.
 1867 if (!f->key_frame_ok) {
765 ✗ av_log(avctx, AV_LOG_ERROR,
766 "Cannot decode non-keyframe without valid keyframe\n");
767 ✗ return AVERROR_INVALIDDATA;
768 }
769 1867 f->key_frame = 0;
770 }
771
772
2/2
✓ Branch 0 taken 1022 times.
✓ Branch 1 taken 1098 times.
 2120 if (f->ac != AC_GOLOMB_RICE) {
773
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1022 times.
 1022 if (buf_size < avctx->width * avctx->height / (128*8))
774 ✗ return AVERROR_INVALIDDATA;
775 } else {
776 1098 int w = avctx->width;
777 1098 int s = 1 + w / (1<<23);
778 int i;
779
780 1098 w /= s;
781
782
2/2
✓ Branch 0 taken 25232 times.
✓ Branch 1 taken 1098 times.
 26330 for (i = 0; w > (1<<ff_log2_run[i]); i++)
783 25232 w -= ff_log2_run[i];
784
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1098 times.
 1098 if (buf_size < (avctx->height + i + 6) / 8 * s)
785 ✗ return AVERROR_INVALIDDATA;
786 }
787
788 2120 return 0;
789 }
790
791 2075 static int decode_slices(AVCodecContext *avctx, RangeCoder c,
792 AVPacket *avpkt)
793 {
794 2075 FFV1Context *f = avctx->priv_data;
795 2075 AVFrame *p = f->picture.f;
796
797 2075 uint8_t *buf = avpkt->data;
798 2075 size_t buf_size = avpkt->size;
799 2075 uint8_t *buf_end = buf + buf_size;
800
801
2/2
✓ Branch 0 taken 7700 times.
✓ Branch 1 taken 2075 times.
 9775 for (int i = f->slice_count - 1; i >= 0; i--) {
802 7700 FFV1SliceContext *sc = &f->slices[i];
803
804 uint8_t *pos;
805 uint32_t len;
806 7700 int err = find_next_slice(avctx, buf, buf_end, i,
807 &pos, &len);
808
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7700 times.
 7700 if (err < 0)
809 ✗ return err;
810
811 7700 buf_end -= len;
812
813 7700 sc->slice_damaged = 0;
814
815
2/2
✓ Branch 0 taken 6700 times.
✓ Branch 1 taken 1000 times.
 7700 if (f->ec) {
816 6700 unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref, pos, len);
817
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6700 times.
 6700 if (crc != f->crcref) {
818 ✗ int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts;
819 ✗ av_log(f->avctx, AV_LOG_ERROR, "slice CRC mismatch %X!", crc);
820 ✗ if (ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) {
821 ✗ av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n", ts*av_q2d(avctx->pkt_timebase));
822 ✗ } else if (ts != AV_NOPTS_VALUE) {
823 ✗ av_log(f->avctx, AV_LOG_ERROR, "at %"PRId64"\n", ts);
824 } else {
825 ✗ av_log(f->avctx, AV_LOG_ERROR, "\n");
826 }
827 ✗ slice_set_damaged(f, sc);
828 }
829
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6700 times.
 6700 if (avctx->debug & FF_DEBUG_PICT_INFO) {
830 ✗ av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08"PRIX32"\n", i, AV_RB32(pos + len - 4));
831 }
832 }
833
834
2/2
✓ Branch 0 taken 5625 times.
✓ Branch 1 taken 2075 times.
 7700 if (i) {
835 5625 ff_init_range_decoder(&sc->c, pos, len);
836 5625 ff_build_rac_states(&sc->c, 0.05 * (1LL << 32), 256 - 8);
837 } else {
838 2075 sc->c = c;
839 2075 sc->c.bytestream_end = pos + len;
840 }
841 }
842
843 2075 avctx->execute(avctx,
844 decode_slice,
845 2075 f->slices,
846 NULL,
847 f->slice_count,
848 sizeof(*f->slices));
849
850
2/2
✓ Branch 0 taken 7700 times.
✓ Branch 1 taken 2075 times.
 9775 for (int i = f->slice_count - 1; i >= 0; i--) {
851 7700 FFV1SliceContext *sc = &f->slices[i];
852
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 7700 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 7700 if (sc->slice_damaged && f->last_picture.f) {
853 ✗ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(f->pix_fmt);
854 const uint8_t *src[4];
855 uint8_t *dst[4];
856 ✗ ff_progress_frame_await(&f->last_picture, INT_MAX);
857 ✗ for (int j = 0; j < desc->nb_components; j++) {
858 ✗ int pixshift = desc->comp[j].depth > 8;
859 ✗ int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
860 ✗ int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
861 ✗ dst[j] = p->data[j] + p->linesize[j] *
862 ✗ (sc->slice_y >> sv) + ((sc->slice_x >> sh) << pixshift);
863 ✗ src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
864 ✗ (sc->slice_y >> sv) + ((sc->slice_x >> sh) << pixshift);
865
866 }
867
868 ✗ av_image_copy(dst, p->linesize, src,
869 ✗ f->last_picture.f->linesize,
870 f->pix_fmt,
871 sc->slice_width,
872 sc->slice_height);
873
874 ✗ f->slice_damaged[i] = 1;
875 }
876 }
877
878 2075 return 0;
879 }
880
881 2120 static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,
882 int *got_frame, AVPacket *avpkt)
883 {
884 2120 FFV1Context *f = avctx->priv_data;
885 int ret;
886 AVFrame *p;
887 2120 const FFHWAccel *hwaccel = NULL;
888
889 /* This is copied onto the first slice's range coder context */
890 RangeCoder c;
891
892 2120 ff_progress_frame_unref(&f->last_picture);
893 2120 av_refstruct_unref(&f->hwaccel_last_picture_private);
894
895 2120 FFSWAP(ProgressFrame, f->picture, f->last_picture);
896 2120 FFSWAP(void *, f->hwaccel_picture_private, f->hwaccel_last_picture_private);
897
898 2120 f->avctx = avctx;
899 2120 f->frame_damaged = 0;
900
901 2120 ret = decode_header(avctx, &c, avpkt->data, avpkt->size);
902
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2120 times.
 2120 if (ret < 0)
903 ✗ return ret;
904
905
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2120 times.
 2120 if (avctx->debug & FF_DEBUG_PICT_INFO)
906 ✗ av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n",
907 ✗ f->version, !!f->key_frame, f->ac, f->ec, f->slice_count, f->avctx->bits_per_raw_sample);
908
909
2/2
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 2075 times.
 2120 if (avctx->skip_frame >= AVDISCARD_ALL)
910 45 return avpkt->size;
911
912
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2075 times.
 2075 if (avctx->hwaccel)
913 ✗ hwaccel = ffhwaccel(avctx->hwaccel);
914
915 2075 ret = ff_progress_frame_get_buffer(avctx, &f->picture,
916 AV_GET_BUFFER_FLAG_REF);
917
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2075 times.
 2075 if (ret < 0)
918 ✗ return ret;
919
920 2075 ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);
921
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2075 times.
 2075 if (ret < 0)
922 ✗ return ret;
923
924 2075 p = f->picture.f;
925
926 2075 p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
927 2075 p->flags = (p->flags & ~AV_FRAME_FLAG_KEY) | f->key_frame;
928
929
3/4
✓ Branch 0 taken 400 times.
✓ Branch 1 taken 1675 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 400 times.
 2075 if (f->version < 3 && avctx->field_order > AV_FIELD_PROGRESSIVE) {
930 /* we have interlaced material flagged in container */
931 ✗ p->flags |= AV_FRAME_FLAG_INTERLACED;
932 ✗ if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
933 ✗ p->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
934 }
935
936 /* Start */
937
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2075 times.
 2075 if (hwaccel) {
938 ✗ ret = hwaccel->start_frame(avctx, avpkt->buf, avpkt->data, avpkt->size);
939 ✗ if (ret < 0)
940 ✗ return ret;
941 }
942
943 2075 ff_thread_finish_setup(avctx);
944
945 /* Decode slices */
946
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2075 times.
 2075 if (hwaccel) {
947 ✗ uint8_t *buf_end = avpkt->data + avpkt->size;
948
949 ✗ if (!(p->flags & AV_FRAME_FLAG_KEY) && f->last_picture.f)
950 ✗ ff_progress_frame_await(&f->last_picture, f->slice_count - 1);
951
952 ✗ for (int i = f->slice_count - 1; i >= 0; i--) {
953 uint8_t *pos;
954 uint32_t len;
955 ✗ ret = find_next_slice(avctx, avpkt->data, buf_end, i,
956 &pos, &len);
957 ✗ if (ret < 0)
958 ✗ return ret;
959
960 ✗ buf_end -= len;
961
962 ✗ ret = hwaccel->decode_slice(avctx, pos, len);
963 ✗ if (ret < 0)
964 ✗ return ret;
965 }
966 } else {
967 2075 ret = decode_slices(avctx, c, avpkt);
968
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2075 times.
 2075 if (ret < 0)
969 ✗ return ret;
970 }
971
972 /* Finalize */
973
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2075 times.
 2075 if (hwaccel) {
974 ✗ ret = hwaccel->end_frame(avctx);
975 ✗ if (ret < 0)
976 ✗ return ret;
977 }
978
979 2075 ff_progress_frame_report(&f->picture, INT_MAX);
980
981 2075 ff_progress_frame_unref(&f->last_picture);
982 2075 av_refstruct_unref(&f->hwaccel_last_picture_private);
983
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2075 times.
 2075 if ((ret = av_frame_ref(rframe, f->picture.f)) < 0)
984 ✗ return ret;
985
986 2075 *got_frame = 1;
987
988 2075 return avpkt->size;
989 }
990
991 #if HAVE_THREADS
992 ✗ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
993 {
994 ✗ FFV1Context *fsrc = src->priv_data;
995 ✗ FFV1Context *fdst = dst->priv_data;
996
997 ✗ if (dst == src)
998 ✗ return 0;
999
1000 ✗ fdst->version = fsrc->version;
1001 ✗ fdst->micro_version = fsrc->micro_version;
1002 ✗ fdst->combined_version = fsrc->combined_version;
1003 ✗ fdst->chroma_planes = fsrc->chroma_planes;
1004 ✗ fdst->chroma_h_shift = fsrc->chroma_h_shift;
1005 ✗ fdst->chroma_v_shift = fsrc->chroma_v_shift;
1006 ✗ fdst->transparency = fsrc->transparency;
1007 ✗ fdst->plane_count = fsrc->plane_count;
1008 ✗ fdst->ac = fsrc->ac;
1009 ✗ fdst->colorspace = fsrc->colorspace;
1010 ✗ fdst->pix_fmt = fsrc->pix_fmt;
1011 ✗ fdst->configured_pix_fmt = fsrc->configured_pix_fmt;
1012 ✗ fdst->configured_ac = fsrc->configured_ac;
1013 ✗ fdst->configured_width = fsrc->configured_width;
1014 ✗ fdst->configured_height = fsrc->configured_height;
1015
1016 ✗ fdst->ec = fsrc->ec;
1017 ✗ fdst->intra = fsrc->intra;
1018 ✗ fdst->key_frame_ok = fsrc->key_frame_ok;
1019
1020 ✗ fdst->packed_at_lsb = fsrc->packed_at_lsb;
1021 ✗ fdst->slice_count = fsrc->slice_count;
1022 ✗ fdst->use32bit = fsrc->use32bit;
1023 ✗ memcpy(fdst->state_transition, fsrc->state_transition,
1024 sizeof(fdst->state_transition));
1025
1026 // in version 1 there is a single per-keyframe quant table, so
1027 // we need to propagate it between threads
1028 ✗ if (fsrc->version < 2)
1029 ✗ memcpy(fdst->quant_tables[0], fsrc->quant_tables[0], sizeof(fsrc->quant_tables[0]));
1030
1031 ✗ for (int i = 0; i < fdst->num_h_slices * fdst->num_v_slices; i++) {
1032 ✗ FFV1SliceContext *sc = &fdst->slices[i];
1033 ✗ const FFV1SliceContext *sc0 = &fsrc->slices[i];
1034
1035 ✗ av_refstruct_replace(&sc->plane, sc0->plane);
1036
1037 ✗ if (fsrc->version < 3) {
1038 ✗ sc->slice_x = sc0->slice_x;
1039 ✗ sc->slice_y = sc0->slice_y;
1040 ✗ sc->slice_width = sc0->slice_width;
1041 ✗ sc->slice_height = sc0->slice_height;
1042 }
1043 }
1044
1045 ✗ av_refstruct_replace(&fdst->slice_damaged, fsrc->slice_damaged);
1046
1047 av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
1048
1049 ✗ ff_progress_frame_replace(&fdst->picture, &fsrc->picture);
1050 ✗ av_refstruct_replace(&fdst->hwaccel_picture_private,
1051 ✗ fsrc->hwaccel_picture_private);
1052
1053 ✗ return 0;
1054 }
1055 #endif
1056
1057 88 static av_cold int ffv1_decode_close(AVCodecContext *avctx)
1058 {
1059 88 FFV1Context *const s = avctx->priv_data;
1060
1061 88 ff_progress_frame_unref(&s->picture);
1062 88 av_refstruct_unref(&s->hwaccel_picture_private);
1063
1064 88 ff_progress_frame_unref(&s->last_picture);
1065 88 av_refstruct_unref(&s->hwaccel_last_picture_private);
1066
1067 88 ff_ffv1_close(s);
1068
1069 88 return 0;
1070 }
1071
1072 const FFCodec ff_ffv1_decoder = {
1073 .p.name = "ffv1",
1074 CODEC_LONG_NAME("FFmpeg video codec #1"),
1075 .p.type = AVMEDIA_TYPE_VIDEO,
1076 .p.id = AV_CODEC_ID_FFV1,
1077 .priv_data_size = sizeof(FFV1Context),
1078 .init = decode_init,
1079 .close = ffv1_decode_close,
1080 FF_CODEC_DECODE_CB(decode_frame),
1081 UPDATE_THREAD_CONTEXT(update_thread_context),
1082 .p.capabilities = AV_CODEC_CAP_DR1 |
1083 AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1084 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
1085 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
1086 FF_CODEC_CAP_USES_PROGRESSFRAMES,
1087 .hw_configs = (const AVCodecHWConfigInternal *const []) {
1088 #if CONFIG_FFV1_VULKAN_HWACCEL
1089 HWACCEL_VULKAN(ffv1),
1090 #endif
1091 NULL
1092 },
1093 };
1094