FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/f_loop.c
Date: 2026-04-19 05:16:53
Exec Total Coverage
Lines: 118 233 50.6%
Functions: 8 14 57.1%
Branches: 51 156 32.7%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2016 Paul B Mahol
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "config_components.h"
22
23 #include "libavutil/audio_fifo.h"
24 #include "libavutil/avassert.h"
25 #include "libavutil/internal.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/opt.h"
28 #include "avfilter.h"
29 #include "audio.h"
30 #include "filters.h"
31 #include "video.h"
32
33 typedef struct LoopContext {
34 const AVClass *class;
35
36 AVAudioFifo *fifo;
37 AVAudioFifo *left;
38 AVFrame **frames;
39 int nb_frames;
40 int current_frame;
41 int64_t time_pts;
42 int64_t duration;
43 int64_t current_sample;
44 int64_t nb_samples;
45 int64_t ignored_samples;
46
47 int loop;
48 int eof;
49 int64_t size;
50 int64_t start;
51 int64_t time;
52 int64_t pts;
53 int64_t pts_offset;
54 int64_t eof_pts;
55 } LoopContext;
56
57 #define AFLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
58 #define VFLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
59 #define OFFSET(x) offsetof(LoopContext, x)
60
61 1 static void check_size(AVFilterContext *ctx)
62 {
63 1 LoopContext *s = ctx->priv;
64
65
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!s->size)
66 ✗ av_log(ctx, AV_LOG_WARNING, "Number of %s to loop is not set!\n",
67 ✗ ctx->input_pads[0].type == AVMEDIA_TYPE_VIDEO ? "frames" : "samples");
68 1 }
69
70 567 static void update_time(AVFilterContext *ctx, AVRational tb)
71 {
72 567 LoopContext *s = ctx->priv;
73
74
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 567 times.
 567 if (s->time != INT64_MAX) {
75 ✗ int64_t time_pts = av_rescale_q(s->time, AV_TIME_BASE_Q, tb);
76 ✗ if (s->time_pts == AV_NOPTS_VALUE || time_pts < s->time_pts)
77 ✗ s->time_pts = time_pts;
78 }
79 567 }
80
81 #if CONFIG_ALOOP_FILTER
82
83 1 static int aconfig_input(AVFilterLink *inlink)
84 {
85 1 AVFilterContext *ctx = inlink->dst;
86 1 LoopContext *s = ctx->priv;
87
88 1 s->time_pts = AV_NOPTS_VALUE;
89
90 1 s->fifo = av_audio_fifo_alloc(inlink->format, inlink->ch_layout.nb_channels, 8192);
91 1 s->left = av_audio_fifo_alloc(inlink->format, inlink->ch_layout.nb_channels, 8192);
92
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (!s->fifo || !s->left)
93 ✗ return AVERROR(ENOMEM);
94
95 1 check_size(ctx);
96
97 1 return 0;
98 }
99
100 2 static av_cold void auninit(AVFilterContext *ctx)
101 {
102 2 LoopContext *s = ctx->priv;
103
104 2 av_audio_fifo_free(s->fifo);
105 2 av_audio_fifo_free(s->left);
106 2 }
107
108 188 static int push_samples(AVFilterContext *ctx, int nb_samples, AVFrame **frame)
109 {
110 188 AVFilterLink *outlink = ctx->outputs[0];
111 188 LoopContext *s = ctx->priv;
112 AVFrame *out;
113 188 int ret = 0, i = 0;
114
115
2/4
✓ Branch 0 taken 188 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 188 times.
✗ Branch 3 not taken.
 188 while (s->loop != 0 && i < nb_samples) {
116 188 out = ff_get_audio_buffer(outlink, FFMIN(nb_samples, s->nb_samples - s->current_sample));
117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 188 times.
 188 if (!out)
118 ✗ return AVERROR(ENOMEM);
119 188 ret = av_audio_fifo_peek_at(s->fifo, (void **)out->extended_data, out->nb_samples, s->current_sample);
120
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 188 times.
 188 if (ret < 0) {
121 ✗ av_frame_free(&out);
122 ✗ return ret;
123 }
124 188 out->pts = s->pts;
125 188 out->nb_samples = ret;
126 188 s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
127 188 i += out->nb_samples;
128 188 s->current_sample += out->nb_samples;
129
130 188 *frame = out;
131
132
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 184 times.
 188 if (s->current_sample >= s->nb_samples) {
133 4 s->current_sample = 0;
134
135
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 if (s->loop > 0)
136 4 s->loop--;
137 }
138
139 188 return 0;
140 }
141
142 ✗ return ret;
143 }
144
145 188 static int afilter_frame(AVFilterLink *inlink, AVFrame *frame)
146 {
147 188 FilterLink *inl = ff_filter_link(inlink);
148 188 AVFilterContext *ctx = inlink->dst;
149 188 AVFilterLink *outlink = ctx->outputs[0];
150 188 LoopContext *s = ctx->priv;
151 188 int ret = 0;
152
153
3/4
✓ Branch 0 taken 188 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46 times.
✓ Branch 3 taken 142 times.
 188 if (((s->start >= 0 && s->ignored_samples + frame->nb_samples > s->start) ||
154
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.
 46 (s->time_pts != AV_NOPTS_VALUE &&
155 ✗ frame->pts >= s->time_pts)) &&
156
3/4
✓ Branch 0 taken 142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 48 times.
✓ Branch 3 taken 94 times.
 142 s->size > 0 && s->loop != 0) {
157
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 48 if (s->nb_samples < s->size) {
158 48 int written = FFMIN(frame->nb_samples, s->size - s->nb_samples);
159 48 int drain = 0;
160
161
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
 48 if (s->start < 0)
162 ✗ s->start = inl->sample_count_out - written;
163
164 48 ret = av_audio_fifo_write(s->fifo, (void **)frame->extended_data, written);
165
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
 48 if (ret < 0)
166 ✗ return ret;
167
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 47 times.
 48 if (!s->nb_samples) {
168 1 drain = FFMAX(0, s->start - s->ignored_samples);
169 1 s->pts = frame->pts;
170 1 av_audio_fifo_drain(s->fifo, drain);
171 1 s->pts += av_rescale_q(s->start - s->ignored_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
172 }
173 48 s->nb_samples += ret - drain;
174
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 47 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 48 if (s->nb_samples == s->size && frame->nb_samples > written) {
175 int ret2;
176
177 1 ret2 = av_audio_fifo_write(s->left, (void **)frame->extended_data, frame->nb_samples);
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret2 < 0)
179 ✗ return ret2;
180 1 av_audio_fifo_drain(s->left, written);
181 }
182 48 frame->nb_samples = ret;
183 48 s->pts += av_rescale_q(ret, (AVRational){1, outlink->sample_rate}, outlink->time_base);
184 48 ret = ff_filter_frame(outlink, frame);
185 } else {
186 ✗ av_assert0(0);
187 }
188 } else {
189 140 s->ignored_samples += frame->nb_samples;
190 140 frame->pts = s->pts;
191 140 s->pts += av_rescale_q(frame->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
192 140 ret = ff_filter_frame(outlink, frame);
193 }
194
195 188 return ret;
196 }
197
198 568 static int arequest_frame(AVFilterLink *outlink, AVFrame **frame)
199 {
200 568 AVFilterContext *ctx = outlink->src;
201 568 LoopContext *s = ctx->priv;
202 568 int ret = 0;
203
204
1/2
✓ Branch 0 taken 568 times.
✗ Branch 1 not taken.
 568 if ((!s->size) ||
205
2/2
✓ Branch 0 taken 380 times.
✓ Branch 1 taken 188 times.
 568 (s->nb_samples < s->size) ||
206
3/4
✓ Branch 0 taken 380 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 192 times.
✓ Branch 3 taken 188 times.
 380 (s->nb_samples >= s->size && s->loop == 0)) {
207 380 int nb_samples = av_audio_fifo_size(s->left);
208
209
4/4
✓ Branch 0 taken 192 times.
✓ Branch 1 taken 188 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 191 times.
 380 if (s->loop == 0 && nb_samples > 0) {
210 AVFrame *out;
211
212 1 out = ff_get_audio_buffer(outlink, nb_samples);
213
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!out)
214 ✗ return AVERROR(ENOMEM);
215 1 av_audio_fifo_read(s->left, (void **)out->extended_data, nb_samples);
216 1 out->pts = s->pts;
217 1 s->pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
218 1 *frame = out;
219 }
220 380 return 0;
221 } else {
222 188 ret = push_samples(ctx, 1024, frame);
223 }
224
225 188 return ret;
226 }
227
228 567 static int aactivate(AVFilterContext *ctx)
229 {
230 567 AVFilterLink *inlink = ctx->inputs[0];
231 567 AVFilterLink *outlink = ctx->outputs[0];
232 567 LoopContext *s = ctx->priv;
233 567 AVFrame *frame = NULL;
234 int ret, status;
235
236
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 567 times.
 567 FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
237
238 567 update_time(ctx, inlink->time_base);
239
240 568 retry:
241 568 ret = arequest_frame(outlink, &frame);
242
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 568 times.
 568 if (ret < 0)
243 ✗ return ret;
244
2/2
✓ Branch 0 taken 189 times.
✓ Branch 1 taken 379 times.
 568 if (frame)
245 189 return ff_filter_frame(outlink, frame);
246
247 379 ret = ff_inlink_consume_frame(inlink, &frame);
248
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379 times.
 379 if (ret < 0)
249 ✗ return ret;
250
2/2
✓ Branch 0 taken 188 times.
✓ Branch 1 taken 191 times.
 379 if (ret > 0)
251 188 return afilter_frame(inlink, frame);
252
253 191 ret = ff_inlink_acknowledge_status(inlink, &status, &s->eof_pts);
254
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 189 times.
 191 if (ret) {
255
3/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
 2 if (status == AVERROR_EOF && !s->eof) {
256 1 s->size = s->nb_samples;
257 1 s->eof = 1;
258 1 goto retry;
259 }
260 1 ff_outlink_set_status(outlink, status, s->eof_pts);
261 1 return 0;
262 }
263
264
1/2
✓ Branch 1 taken 189 times.
✗ Branch 2 not taken.
 189 FF_FILTER_FORWARD_WANTED(outlink, inlink);
265
266 ✗ return FFERROR_NOT_READY;
267 }
268
269 static const AVOption aloop_options[] = {
270 { "loop", "number of loops", OFFSET(loop), AV_OPT_TYPE_INT, {.i64 = 0 }, -1, INT_MAX, AFLAGS },
271 { "size", "max number of samples to loop", OFFSET(size), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0, INT32_MAX, AFLAGS },
272 { "start", "set the loop start sample", OFFSET(start), AV_OPT_TYPE_INT64, {.i64 = 0 }, -1, INT64_MAX, AFLAGS },
273 { "time", "set the loop start time", OFFSET(time), AV_OPT_TYPE_DURATION, {.i64=INT64_MAX}, INT64_MIN, INT64_MAX, AFLAGS },
274 { NULL }
275 };
276
277 AVFILTER_DEFINE_CLASS(aloop);
278
279 static const AVFilterPad ainputs[] = {
280 {
281 .name = "default",
282 .type = AVMEDIA_TYPE_AUDIO,
283 .config_props = aconfig_input,
284 },
285 };
286
287 const FFFilter ff_af_aloop = {
288 .p.name = "aloop",
289 .p.description = NULL_IF_CONFIG_SMALL("Loop audio samples."),
290 .p.priv_class = &aloop_class,
291 .priv_size = sizeof(LoopContext),
292 .activate = aactivate,
293 .uninit = auninit,
294 FILTER_INPUTS(ainputs),
295 FILTER_OUTPUTS(ff_audio_default_filterpad),
296 };
297 #endif /* CONFIG_ALOOP_FILTER */
298
299 #if CONFIG_LOOP_FILTER
300
301 ✗ static av_cold int init(AVFilterContext *ctx)
302 {
303 ✗ LoopContext *s = ctx->priv;
304
305 ✗ s->time_pts = AV_NOPTS_VALUE;
306
307 ✗ s->frames = av_calloc(s->size, sizeof(*s->frames));
308 ✗ if (!s->frames)
309 ✗ return AVERROR(ENOMEM);
310
311 ✗ check_size(ctx);
312
313 ✗ return 0;
314 }
315
316 ✗ static void free_frames(AVFilterContext *ctx)
317 {
318 ✗ LoopContext *s = ctx->priv;
319
320 ✗ for (int i = 0; i < s->nb_frames; i++)
321 ✗ av_frame_free(&s->frames[i]);
322 ✗ }
323
324 ✗ static av_cold void uninit(AVFilterContext *ctx)
325 {
326 ✗ LoopContext *s = ctx->priv;
327
328 ✗ free_frames(ctx);
329 ✗ av_freep(&s->frames);
330 ✗ s->nb_frames = 0;
331 ✗ }
332
333 ✗ static int push_frame(AVFilterContext *ctx)
334 {
335 ✗ AVFilterLink *outlink = ctx->outputs[0];
336 ✗ LoopContext *s = ctx->priv;
337 AVFrame *out;
338 int ret;
339
340 ✗ out = av_frame_clone(s->frames[s->current_frame]);
341 ✗ if (!out)
342 ✗ return AVERROR(ENOMEM);
343 ✗ out->pts += s->pts_offset;
344 ✗ ret = ff_filter_frame(outlink, out);
345 ✗ s->current_frame++;
346
347 ✗ if (s->current_frame >= s->nb_frames) {
348 ✗ s->current_frame = 0;
349
350 ✗ s->pts_offset += s->duration;
351 ✗ if (s->loop > 0)
352 ✗ s->loop--;
353 ✗ if (s->loop == 0)
354 ✗ free_frames(ctx);
355 }
356
357 ✗ return ret;
358 }
359
360 ✗ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
361 {
362 ✗ FilterLink *inl = ff_filter_link(inlink);
363 ✗ AVFilterContext *ctx = inlink->dst;
364 ✗ AVFilterLink *outlink = ctx->outputs[0];
365 ✗ FilterLink *outl = ff_filter_link(outlink);
366 ✗ LoopContext *s = ctx->priv;
367 int64_t duration;
368 ✗ int ret = 0;
369
370 ✗ if (((s->start >= 0 && inl->frame_count_out >= s->start) ||
371 ✗ (s->time_pts != AV_NOPTS_VALUE &&
372 ✗ frame->pts >= s->time_pts)) &&
373 ✗ s->size > 0 && s->loop != 0) {
374 ✗ if (s->nb_frames < s->size) {
375 ✗ s->frames[s->nb_frames] = av_frame_clone(frame);
376 ✗ if (!s->frames[s->nb_frames]) {
377 ✗ av_frame_free(&frame);
378 ✗ return AVERROR(ENOMEM);
379 }
380 ✗ s->nb_frames++;
381 ✗ if (frame->duration)
382 ✗ duration = frame->duration;
383 else
384 ✗ duration = av_rescale_q(1, av_inv_q(outl->frame_rate), outlink->time_base);
385 ✗ s->duration += duration;
386 ✗ s->pts_offset = s->duration;
387 ✗ ret = ff_filter_frame(outlink, frame);
388 } else {
389 ✗ av_frame_free(&frame);
390 ✗ ret = push_frame(ctx);
391 }
392 } else {
393 ✗ frame->pts += s->pts_offset - s->duration;
394 ✗ ret = ff_filter_frame(outlink, frame);
395 }
396
397 ✗ return ret;
398 }
399
400 ✗ static int activate(AVFilterContext *ctx)
401 {
402 ✗ AVFilterLink *inlink = ctx->inputs[0];
403 ✗ AVFilterLink *outlink = ctx->outputs[0];
404 ✗ LoopContext *s = ctx->priv;
405 ✗ AVFrame *frame = NULL;
406 int ret, status;
407
408 ✗ ret = ff_outlink_get_status(outlink);
409 ✗ if (ret) {
410 ✗ ff_inlink_set_status(inlink, ret);
411 ✗ free_frames(ctx);
412 ✗ return 0;
413 }
414
415 ✗ update_time(ctx, inlink->time_base);
416
417 ✗ if (!s->eof && (s->nb_frames < s->size || !s->loop || !s->size)) {
418 ✗ ret = ff_inlink_consume_frame(inlink, &frame);
419 ✗ if (ret < 0)
420 ✗ return ret;
421 ✗ if (ret > 0)
422 ✗ return filter_frame(inlink, frame);
423 }
424
425 ✗ if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &s->eof_pts)) {
426 ✗ if (status == AVERROR_EOF) {
427 ✗ s->size = s->nb_frames;
428 ✗ s->eof = 1;
429 }
430 }
431
432 ✗ if (s->eof && (!s->loop || !s->size)) {
433 ✗ ff_outlink_set_status(outlink, AVERROR_EOF, s->eof_pts + s->pts_offset);
434 ✗ free_frames(ctx);
435 ✗ return 0;
436 }
437
438 ✗ if (!s->eof && (!s->size ||
439 ✗ (s->nb_frames < s->size) ||
440 ✗ (s->nb_frames >= s->size && s->loop == 0))) {
441 ✗ FF_FILTER_FORWARD_WANTED(outlink, inlink);
442 ✗ } else if (s->loop && s->nb_frames == s->size) {
443 ✗ return push_frame(ctx);
444 }
445
446 ✗ return FFERROR_NOT_READY;
447 }
448
449 static const AVOption loop_options[] = {
450 { "loop", "number of loops", OFFSET(loop), AV_OPT_TYPE_INT, {.i64 = 0 }, -1, INT_MAX, VFLAGS },
451 { "size", "max number of frames to loop", OFFSET(size), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0, INT16_MAX, VFLAGS },
452 { "start", "set the loop start frame", OFFSET(start), AV_OPT_TYPE_INT64, {.i64 = 0 }, -1, INT64_MAX, VFLAGS },
453 { "time", "set the loop start time", OFFSET(time), AV_OPT_TYPE_DURATION, {.i64=INT64_MAX}, INT64_MIN, INT64_MAX, VFLAGS },
454 { NULL }
455 };
456
457 AVFILTER_DEFINE_CLASS(loop);
458
459 const FFFilter ff_vf_loop = {
460 .p.name = "loop",
461 .p.description = NULL_IF_CONFIG_SMALL("Loop video frames."),
462 .p.priv_class = &loop_class,
463 .priv_size = sizeof(LoopContext),
464 .init = init,
465 .uninit = uninit,
466 .activate = activate,
467 FILTER_INPUTS(ff_video_default_filterpad),
468 FILTER_OUTPUTS(ff_video_default_filterpad),
469 };
470 #endif /* CONFIG_LOOP_FILTER */
471