FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/avfilter.c
Date: 2025-01-20 09:27:23
Exec Total Coverage
Lines: 647 829 78.0%
Functions: 58 67 86.6%
Branches: 337 484 69.6%
Line Branch Exec Source
1 /*
2 * filter layer
3 * Copyright (c) 2007 Bobby Bingham
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "libavutil/avassert.h"
23 #include "libavutil/avstring.h"
24 #include "libavutil/bprint.h"
25 #include "libavutil/buffer.h"
26 #include "libavutil/channel_layout.h"
27 #include "libavutil/common.h"
28 #include "libavutil/eval.h"
29 #include "libavutil/frame.h"
30 #include "libavutil/hwcontext.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/rational.h"
36 #include "libavutil/samplefmt.h"
37
38 #include "audio.h"
39 #include "avfilter.h"
40 #include "avfilter_internal.h"
41 #include "filters.h"
42 #include "formats.h"
43 #include "framequeue.h"
44 #include "framepool.h"
45 #include "video.h"
46
47 1423890 static void tlog_ref(void *ctx, AVFrame *ref, int end)
48 {
49 #ifdef TRACE
50 ff_tlog(ctx,
51 "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64,
52 ref, ref->buf, ref->data[0],
53 ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
54 ref->pts);
55
56 if (ref->width) {
57 ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
58 ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den,
59 ref->width, ref->height,
60 !(ref->flags & AV_FRAME_FLAG_INTERLACED) ? 'P' : /* Progressive */
61 (ref->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 'T' : 'B', /* Top / Bottom */
62 !!(ref->flags & AV_FRAME_FLAG_KEY),
63 av_get_picture_type_char(ref->pict_type));
64 }
65 if (ref->nb_samples) {
66 AVBPrint bprint;
67
68 av_bprint_init(&bprint, 1, AV_BPRINT_SIZE_UNLIMITED);
69 av_channel_layout_describe_bprint(&ref->ch_layout, &bprint);
70 ff_tlog(ctx, " cl:%s n:%d r:%d",
71 bprint.str,
72 ref->nb_samples,
73 ref->sample_rate);
74 av_bprint_finalize(&bprint, NULL);
75 }
76
77 ff_tlog(ctx, "]%s", end ? "\n" : "");
78 #endif
79 1423890 }
80
81 ✗ static void command_queue_pop(AVFilterContext *filter)
82 {
83 ✗ FFFilterContext *ctxi = fffilterctx(filter);
84 ✗ AVFilterCommand *c = ctxi->command_queue;
85 ✗ av_freep(&c->arg);
86 ✗ av_freep(&c->command);
87 ✗ ctxi->command_queue = c->next;
88 ✗ av_free(c);
89 ✗ }
90
91 /**
92 * Append a new pad.
93 *
94 * @param count Pointer to the number of pads in the list
95 * @param pads Pointer to the pointer to the beginning of the list of pads
96 * @param links Pointer to the pointer to the beginning of the list of links
97 * @param newpad The new pad to add. A copy is made when adding.
98 * @return >= 0 in case of success, a negative AVERROR code on error
99 */
100 501 static int append_pad(unsigned *count, AVFilterPad **pads,
101 AVFilterLink ***links, AVFilterPad *newpad)
102 {
103 AVFilterLink **newlinks;
104 AVFilterPad *newpads;
105 501 unsigned idx = *count;
106
107 501 newpads = av_realloc_array(*pads, idx + 1, sizeof(*newpads));
108 501 newlinks = av_realloc_array(*links, idx + 1, sizeof(*newlinks));
109
1/2
✓ Branch 0 taken 501 times.
✗ Branch 1 not taken.
 501 if (newpads)
110 501 *pads = newpads;
111
1/2
✓ Branch 0 taken 501 times.
✗ Branch 1 not taken.
 501 if (newlinks)
112 501 *links = newlinks;
113
2/4
✓ Branch 0 taken 501 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 501 times.
 501 if (!newpads || !newlinks) {
114 ✗ if (newpad->flags & AVFILTERPAD_FLAG_FREE_NAME)
115 ✗ av_freep(&newpad->name);
116 ✗ return AVERROR(ENOMEM);
117 }
118
119 501 memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
120 501 (*links)[idx] = NULL;
121
122 501 (*count)++;
123
124 501 return 0;
125 }
126
127 229 int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
128 {
129 229 return append_pad(&f->nb_inputs, &f->input_pads, &f->inputs, p);
130 }
131
132 210 int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
133 {
134 210 p->flags |= AVFILTERPAD_FLAG_FREE_NAME;
135 210 return ff_append_inpad(f, p);
136 }
137
138 272 int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
139 {
140 272 return append_pad(&f->nb_outputs, &f->output_pads, &f->outputs, p);
141 }
142
143 131 int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
144 {
145 131 p->flags |= AVFILTERPAD_FLAG_FREE_NAME;
146 131 return ff_append_outpad(f, p);
147 }
148
149 42699 int avfilter_link(AVFilterContext *src, unsigned srcpad,
150 AVFilterContext *dst, unsigned dstpad)
151 {
152 FilterLinkInternal *li;
153 AVFilterLink *link;
154
155
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42699 times.
 42699 av_assert0(src->graph);
156
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42699 times.
 42699 av_assert0(dst->graph);
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42699 times.
 42699 av_assert0(src->graph == dst->graph);
158
159
2/4
✓ Branch 0 taken 42699 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 42699 times.
✗ Branch 3 not taken.
 42699 if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
160
2/4
✓ Branch 0 taken 42699 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 42699 times.
 42699 src->outputs[srcpad] || dst->inputs[dstpad])
161 ✗ return AVERROR(EINVAL);
162
163
1/2
✓ Branch 1 taken 42699 times.
✗ Branch 2 not taken.
 42699 if (!(fffilterctx(src)->state_flags & AV_CLASS_STATE_INITIALIZED) ||
164
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 42699 times.
 42699 !(fffilterctx(dst)->state_flags & AV_CLASS_STATE_INITIALIZED)) {
165 ✗ av_log(src, AV_LOG_ERROR, "Filters must be initialized before linking.\n");
166 ✗ return AVERROR(EINVAL);
167 }
168
169
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42699 times.
 42699 if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
170 ✗ av_log(src, AV_LOG_ERROR,
171 "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
172 ✗ src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
173 ✗ dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
174 ✗ return AVERROR(EINVAL);
175 }
176
177 42699 li = av_mallocz(sizeof(*li));
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42699 times.
 42699 if (!li)
179 ✗ return AVERROR(ENOMEM);
180 42699 link = &li->l.pub;
181
182 42699 src->outputs[srcpad] = dst->inputs[dstpad] = link;
183
184 42699 link->src = src;
185 42699 link->dst = dst;
186 42699 link->srcpad = &src->output_pads[srcpad];
187 42699 link->dstpad = &dst->input_pads[dstpad];
188 42699 link->type = src->output_pads[srcpad].type;
189 42699 li->l.graph = src->graph;
190 av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
191 42699 link->format = -1;
192 42699 link->colorspace = AVCOL_SPC_UNSPECIFIED;
193 42699 ff_framequeue_init(&li->fifo, &fffiltergraph(src->graph)->frame_queues);
194
195 42699 return 0;
196 }
197
198 42831 static void link_free(AVFilterLink **link)
199 {
200 FilterLinkInternal *li;
201
202
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42831 times.
 42831 if (!*link)
203 ✗ return;
204 42831 li = ff_link_internal(*link);
205
206 42831 ff_framequeue_free(&li->fifo);
207 42831 ff_frame_pool_uninit(&li->frame_pool);
208 42831 av_channel_layout_uninit(&(*link)->ch_layout);
209
210 42831 av_buffer_unref(&li->l.hw_frames_ctx);
211
212 42831 av_freep(link);
213 }
214
215 #if FF_API_LINK_PUBLIC
216 ✗ void avfilter_link_free(AVFilterLink **link)
217 {
218 ✗ link_free(link);
219 ✗ }
220 ✗ int avfilter_config_links(AVFilterContext *filter)
221 {
222 ✗ return ff_filter_config_links(filter);
223 }
224 #endif
225
226 1437675 static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
227 {
228 1437675 AVFilterLink *const link = &li->l.pub;
229
230
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1437670 times.
 1437675 if (pts == AV_NOPTS_VALUE)
231 5 return;
232 1437670 li->l.current_pts = pts;
233 1437670 li->l.current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
234 /* TODO use duration */
235
3/4
✓ Branch 0 taken 1437670 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 399972 times.
✓ Branch 3 taken 1037698 times.
 1437670 if (li->l.graph && li->age_index >= 0)
236 399972 ff_avfilter_graph_update_heap(li->l.graph, li);
237 }
238
239 3540576 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
240 {
241 3540576 FFFilterContext *ctxi = fffilterctx(filter);
242 3540576 ctxi->ready = FFMAX(ctxi->ready, priority);
243 3540576 }
244
245 /**
246 * Clear frame_blocked_in on all outputs.
247 * This is necessary whenever something changes on input.
248 */
249 2122707 static void filter_unblock(AVFilterContext *filter)
250 {
251 unsigned i;
252
253
2/2
✓ Branch 0 taken 1724619 times.
✓ Branch 1 taken 2122707 times.
 3847326 for (i = 0; i < filter->nb_outputs; i++) {
254 1724619 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
255 1724619 li->frame_blocked_in = 0;
256 }
257 2122707 }
258
259
260 17130 void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
261 {
262 17130 FilterLinkInternal * const li = ff_link_internal(link);
263
264
2/2
✓ Branch 0 taken 3810 times.
✓ Branch 1 taken 13320 times.
 17130 if (li->status_in == status)
265 3810 return;
266
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13320 times.
 13320 av_assert0(!li->status_in);
267 13320 li->status_in = status;
268 13320 li->status_in_pts = pts;
269 13320 li->frame_wanted_out = 0;
270 13320 li->frame_blocked_in = 0;
271 13320 filter_unblock(link->dst);
272 13320 ff_filter_set_ready(link->dst, 200);
273 }
274
275 /**
276 * Set the status field of a link from the destination filter.
277 * The pts should probably be left unset (AV_NOPTS_VALUE).
278 */
279 7986 static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
280 {
281 7986 FilterLinkInternal * const li = ff_link_internal(link);
282
283
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7986 times.
 7986 av_assert0(!li->frame_wanted_out);
284
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7986 times.
 7986 av_assert0(!li->status_out);
285 7986 li->status_out = status;
286
2/2
✓ Branch 0 taken 5883 times.
✓ Branch 1 taken 2103 times.
 7986 if (pts != AV_NOPTS_VALUE)
287 5883 update_link_current_pts(li, pts);
288 7986 filter_unblock(link->dst);
289 7986 ff_filter_set_ready(link->src, 200);
290 7986 }
291
292 1248 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
293 unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
294 {
295 int ret;
296 1248 unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
297
298 1248 av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
299 "between the filter '%s' and the filter '%s'\n",
300 1248 filt->name, link->src->name, link->dst->name);
301
302 1248 link->dst->inputs[dstpad_idx] = NULL;
303
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1248 times.
 1248 if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
304 /* failed to link output filter to new filter */
305 ✗ link->dst->inputs[dstpad_idx] = link;
306 ✗ return ret;
307 }
308
309 /* re-hookup the link to the new destination filter we inserted */
310 1248 link->dst = filt;
311 1248 link->dstpad = &filt->input_pads[filt_srcpad_idx];
312 1248 filt->inputs[filt_srcpad_idx] = link;
313
314 /* if any information on supported media formats already exists on the
315 * link, we need to preserve that */
316
1/2
✓ Branch 0 taken 1248 times.
✗ Branch 1 not taken.
 1248 if (link->outcfg.formats)
317 1248 ff_formats_changeref(&link->outcfg.formats,
318 1248 &filt->outputs[filt_dstpad_idx]->outcfg.formats);
319
2/2
✓ Branch 0 taken 616 times.
✓ Branch 1 taken 632 times.
 1248 if (link->outcfg.color_spaces)
320 616 ff_formats_changeref(&link->outcfg.color_spaces,
321 616 &filt->outputs[filt_dstpad_idx]->outcfg.color_spaces);
322
2/2
✓ Branch 0 taken 616 times.
✓ Branch 1 taken 632 times.
 1248 if (link->outcfg.color_ranges)
323 616 ff_formats_changeref(&link->outcfg.color_ranges,
324 616 &filt->outputs[filt_dstpad_idx]->outcfg.color_ranges);
325
2/2
✓ Branch 0 taken 632 times.
✓ Branch 1 taken 616 times.
 1248 if (link->outcfg.samplerates)
326 632 ff_formats_changeref(&link->outcfg.samplerates,
327 632 &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
328
2/2
✓ Branch 0 taken 632 times.
✓ Branch 1 taken 616 times.
 1248 if (link->outcfg.channel_layouts)
329 632 ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
330 632 &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
331
332 1248 return 0;
333 }
334
335 41399 int ff_filter_config_links(AVFilterContext *filter)
336 {
337 int (*config_link)(AVFilterLink *);
338 unsigned i;
339 int ret;
340
341
2/2
✓ Branch 0 taken 33742 times.
✓ Branch 1 taken 41399 times.
 75141 for (i = 0; i < filter->nb_inputs; i ++) {
342 33742 AVFilterLink *link = filter->inputs[i];
343 AVFilterLink *inlink;
344 33742 FilterLinkInternal *li = ff_link_internal(link);
345 FilterLinkInternal *li_in;
346
347
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33742 times.
 33742 if (!link) continue;
348
2/4
✓ Branch 0 taken 33742 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33742 times.
 33742 if (!link->src || !link->dst) {
349 ✗ av_log(filter, AV_LOG_ERROR,
350 "Not all input and output are properly linked (%d).\n", i);
351 ✗ return AVERROR(EINVAL);
352 }
353
354
2/2
✓ Branch 0 taken 25909 times.
✓ Branch 1 taken 7833 times.
 33742 inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
355
2/2
✓ Branch 0 taken 25909 times.
✓ Branch 1 taken 7833 times.
 33742 li_in = inlink ? ff_link_internal(inlink) : NULL;
356 33742 li->l.current_pts =
357 33742 li->l.current_pts_us = AV_NOPTS_VALUE;
358
359
2/4
✓ Branch 0 taken 105 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33637 times.
✗ Branch 3 not taken.
 33742 switch (li->init_state) {
360 105 case AVLINK_INIT:
361 105 continue;
362 ✗ case AVLINK_STARTINIT:
363 ✗ av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
364 ✗ return 0;
365 33637 case AVLINK_UNINIT:
366 33637 li->init_state = AVLINK_STARTINIT;
367
368
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33637 times.
 33637 if ((ret = ff_filter_config_links(link->src)) < 0)
369 ✗ return ret;
370
371
2/2
✓ Branch 0 taken 17526 times.
✓ Branch 1 taken 16111 times.
 33637 if (!(config_link = link->srcpad->config_props)) {
372
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17526 times.
 17526 if (link->src->nb_inputs != 1) {
373 ✗ av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
374 "with more than one input "
375 "must set config_props() "
376 "callbacks on all outputs\n");
377 ✗ return AVERROR(EINVAL);
378 }
379
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16111 times.
 16111 } else if ((ret = config_link(link)) < 0) {
380 ✗ av_log(link->src, AV_LOG_ERROR,
381 "Failed to configure output pad on %s\n",
382 ✗ link->src->name);
383 ✗ return ret;
384 }
385
386
2/3
✓ Branch 0 taken 27740 times.
✓ Branch 1 taken 5897 times.
✗ Branch 2 not taken.
 33637 switch (link->type) {
387 27740 case AVMEDIA_TYPE_VIDEO:
388
3/4
✓ Branch 0 taken 21044 times.
✓ Branch 1 taken 6696 times.
✓ Branch 2 taken 21044 times.
✗ Branch 3 not taken.
 27740 if (!link->time_base.num && !link->time_base.den)
389
1/2
✓ Branch 0 taken 21044 times.
✗ Branch 1 not taken.
 21044 link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
390
391
4/4
✓ Branch 0 taken 24349 times.
✓ Branch 1 taken 3391 times.
✓ Branch 2 taken 15054 times.
✓ Branch 3 taken 9295 times.
 27740 if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
392 15054 link->sample_aspect_ratio = inlink ?
393
2/2
✓ Branch 0 taken 15040 times.
✓ Branch 1 taken 14 times.
 15054 inlink->sample_aspect_ratio : (AVRational){1,1};
394
395
2/2
✓ Branch 0 taken 21297 times.
✓ Branch 1 taken 6443 times.
 27740 if (inlink) {
396
3/4
✓ Branch 0 taken 21086 times.
✓ Branch 1 taken 211 times.
✓ Branch 2 taken 21086 times.
✗ Branch 3 not taken.
 21297 if (!li->l.frame_rate.num && !li->l.frame_rate.den)
397 21086 li->l.frame_rate = li_in->l.frame_rate;
398
2/2
✓ Branch 0 taken 14573 times.
✓ Branch 1 taken 6724 times.
 21297 if (!link->w)
399 14573 link->w = inlink->w;
400
2/2
✓ Branch 0 taken 14573 times.
✓ Branch 1 taken 6724 times.
 21297 if (!link->h)
401 14573 link->h = inlink->h;
402
2/4
✓ Branch 0 taken 6443 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6443 times.
 6443 } else if (!link->w || !link->h) {
403 ✗ av_log(link->src, AV_LOG_ERROR,
404 "Video source filters must set their output link's "
405 "width and height\n");
406 ✗ return AVERROR(EINVAL);
407 }
408 27740 break;
409
410 5897 case AVMEDIA_TYPE_AUDIO:
411
2/2
✓ Branch 0 taken 4536 times.
✓ Branch 1 taken 1361 times.
 5897 if (inlink) {
412
3/4
✓ Branch 0 taken 3041 times.
✓ Branch 1 taken 1495 times.
✓ Branch 2 taken 3041 times.
✗ Branch 3 not taken.
 4536 if (!link->time_base.num && !link->time_base.den)
413 3041 link->time_base = inlink->time_base;
414 }
415
416
3/4
✓ Branch 0 taken 81 times.
✓ Branch 1 taken 5816 times.
✓ Branch 2 taken 81 times.
✗ Branch 3 not taken.
 5897 if (!link->time_base.num && !link->time_base.den)
417 81 link->time_base = (AVRational) {1, link->sample_rate};
418 }
419
420
2/2
✓ Branch 0 taken 25833 times.
✓ Branch 1 taken 7804 times.
 33637 if (link->src->nb_inputs &&
421
1/2
✓ Branch 1 taken 25833 times.
✗ Branch 2 not taken.
 25833 !(fffilter(link->src->filter)->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
422 25833 FilterLink *l0 = ff_filter_link(link->src->inputs[0]);
423
424
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25833 times.
 25833 av_assert0(!li->l.hw_frames_ctx &&
425 "should not be set by non-hwframe-aware filter");
426
427
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25833 times.
 25833 if (l0->hw_frames_ctx) {
428 ✗ li->l.hw_frames_ctx = av_buffer_ref(l0->hw_frames_ctx);
429 ✗ if (!li->l.hw_frames_ctx)
430 ✗ return AVERROR(ENOMEM);
431 }
432 }
433
434
2/2
✓ Branch 0 taken 4462 times.
✓ Branch 1 taken 29175 times.
 33637 if ((config_link = link->dstpad->config_props))
435
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4462 times.
 4462 if ((ret = config_link(link)) < 0) {
436 ✗ av_log(link->dst, AV_LOG_ERROR,
437 "Failed to configure input pad on %s\n",
438 ✗ link->dst->name);
439 ✗ return ret;
440 }
441
442 33637 li->init_state = AVLINK_INIT;
443 }
444 }
445
446 41399 return 0;
447 }
448
449 #ifdef TRACE
450 void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
451 {
452 if (link->type == AVMEDIA_TYPE_VIDEO) {
453 ff_tlog(ctx,
454 "link[%p s:%dx%d fmt:%s %s->%s]%s",
455 link, link->w, link->h,
456 av_get_pix_fmt_name(link->format),
457 link->src ? link->src->filter->name : "",
458 link->dst ? link->dst->filter->name : "",
459 end ? "\n" : "");
460 } else {
461 char buf[128];
462 av_channel_layout_describe(&link->ch_layout, buf, sizeof(buf));
463
464 ff_tlog(ctx,
465 "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
466 link, (int)link->sample_rate, buf,
467 av_get_sample_fmt_name(link->format),
468 link->src ? link->src->filter->name : "",
469 link->dst ? link->dst->filter->name : "",
470 end ? "\n" : "");
471 }
472 }
473 #endif
474
475 673193 int ff_request_frame(AVFilterLink *link)
476 {
477 673193 FilterLinkInternal * const li = ff_link_internal(link);
478
479 FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
480
481 av_assert1(!fffilter(link->dst->filter)->activate);
482
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 673184 times.
 673193 if (li->status_out)
483 9 return li->status_out;
484
2/2
✓ Branch 0 taken 5884 times.
✓ Branch 1 taken 667300 times.
 673184 if (li->status_in) {
485
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5884 times.
 5884 if (ff_framequeue_queued_frames(&li->fifo)) {
486 av_assert1(!li->frame_wanted_out);
487 av_assert1(fffilterctx(link->dst)->ready >= 300);
488 ✗ return 0;
489 } else {
490 /* Acknowledge status change. Filters using ff_request_frame() will
491 handle the change automatically. Filters can also check the
492 status directly but none do yet. */
493 5884 link_set_out_status(link, li->status_in, li->status_in_pts);
494 5884 return li->status_out;
495 }
496 }
497 667300 li->frame_wanted_out = 1;
498 667300 ff_filter_set_ready(link->src, 100);
499 667300 return 0;
500 }
501
502 5885 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
503 {
504 unsigned i;
505 5885 int64_t r = INT64_MAX;
506
507
2/2
✓ Branch 0 taken 5884 times.
✓ Branch 1 taken 5885 times.
 11769 for (i = 0; i < ctx->nb_inputs; i++) {
508 5884 FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
509
1/2
✓ Branch 0 taken 5884 times.
✗ Branch 1 not taken.
 5884 if (li->status_out == status)
510 5884 r = FFMIN(r, av_rescale_q(li->l.current_pts, ctx->inputs[i]->time_base, link_time_base));
511 }
512
2/2
✓ Branch 0 taken 5884 times.
✓ Branch 1 taken 1 times.
 5885 if (r < INT64_MAX)
513 5884 return r;
514 1 av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n");
515
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 for (i = 0; i < ctx->nb_inputs; i++) {
516 ✗ FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
517 ✗ r = FFMIN(r, av_rescale_q(li->status_in_pts, ctx->inputs[i]->time_base, link_time_base));
518 }
519
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (r < INT64_MAX)
520 ✗ return r;
521 1 return AV_NOPTS_VALUE;
522 }
523
524 673533 static int request_frame_to_filter(AVFilterLink *link)
525 {
526 673533 FilterLinkInternal * const li = ff_link_internal(link);
527 673533 int ret = -1;
528
529 FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);
530 /* Assume the filter is blocked, let the method clear it if not */
531 673533 li->frame_blocked_in = 1;
532
2/2
✓ Branch 0 taken 2861 times.
✓ Branch 1 taken 670672 times.
 673533 if (link->srcpad->request_frame)
533 2861 ret = link->srcpad->request_frame(link);
534
1/2
✓ Branch 0 taken 670672 times.
✗ Branch 1 not taken.
 670672 else if (link->src->inputs[0])
535 670672 ret = ff_request_frame(link->src->inputs[0]);
536
2/2
✓ Branch 0 taken 5885 times.
✓ Branch 1 taken 667648 times.
 673533 if (ret < 0) {
537
2/4
✓ Branch 0 taken 5885 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5885 times.
✗ Branch 3 not taken.
 5885 if (ret != AVERROR(EAGAIN) && ret != li->status_in)
538 5885 ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
539
1/2
✓ Branch 0 taken 5885 times.
✗ Branch 1 not taken.
 5885 if (ret == AVERROR_EOF)
540 5885 ret = 0;
541 }
542 673533 return ret;
543 }
544
545 static const char *const var_names[] = {
546 "t",
547 "n",
548 #if FF_API_FRAME_PKT
549 "pos",
550 #endif
551 "w",
552 "h",
553 NULL
554 };
555
556 enum {
557 VAR_T,
558 VAR_N,
559 #if FF_API_FRAME_PKT
560 VAR_POS,
561 #endif
562 VAR_W,
563 VAR_H,
564 VAR_VARS_NB
565 };
566
567 6 static int set_enable_expr(FFFilterContext *ctxi, const char *expr)
568 {
569 6 AVFilterContext *ctx = &ctxi->p;
570 int ret;
571 char *expr_dup;
572 6 AVExpr *old = ctxi->enable;
573
574
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
575 ✗ av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
576 ✗ "with filter '%s'\n", ctx->filter->name);
577 ✗ return AVERROR_PATCHWELCOME;
578 }
579
580 6 expr_dup = av_strdup(expr);
581
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!expr_dup)
582 ✗ return AVERROR(ENOMEM);
583
584
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (!ctxi->var_values) {
585 6 ctxi->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctxi->var_values));
586
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!ctxi->var_values) {
587 ✗ av_free(expr_dup);
588 ✗ return AVERROR(ENOMEM);
589 }
590 }
591
592 6 ret = av_expr_parse(&ctxi->enable, expr_dup, var_names,
593 NULL, NULL, NULL, NULL, 0, ctx->priv);
594
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (ret < 0) {
595 ✗ av_log(ctx->priv, AV_LOG_ERROR,
596 "Error when evaluating the expression '%s' for enable\n",
597 expr_dup);
598 ✗ av_free(expr_dup);
599 ✗ return ret;
600 }
601
602 6 av_expr_free(old);
603 6 av_free(ctx->enable_str);
604 6 ctx->enable_str = expr_dup;
605 6 return 0;
606 }
607
608 ✗ int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
609 {
610 ✗ if(!strcmp(cmd, "ping")){
611 ✗ char local_res[256] = {0};
612
613 ✗ if (!res) {
614 ✗ res = local_res;
615 ✗ res_len = sizeof(local_res);
616 }
617 ✗ av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
618 ✗ if (res == local_res)
619 ✗ av_log(filter, AV_LOG_INFO, "%s", res);
620 ✗ return 0;
621 ✗ }else if(!strcmp(cmd, "enable")) {
622 ✗ return set_enable_expr(fffilterctx(filter), arg);
623 ✗ }else if (fffilter(filter->filter)->process_command) {
624 ✗ return fffilter(filter->filter)->process_command(filter, cmd, arg, res, res_len, flags);
625 }
626 ✗ return AVERROR(ENOSYS);
627 }
628
629 14136 unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
630 {
631
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14136 times.
 14136 return is_output ? fffilter(filter)->nb_outputs : fffilter(filter)->nb_inputs;
632 }
633
634 555 static const char *default_filter_name(void *filter_ctx)
635 {
636 555 AVFilterContext *ctx = filter_ctx;
637
1/2
✓ Branch 0 taken 555 times.
✗ Branch 1 not taken.
 555 return ctx->name ? ctx->name : ctx->filter->name;
638 }
639
640 50272 static void *filter_child_next(void *obj, void *prev)
641 {
642 50272 AVFilterContext *ctx = obj;
643
5/8
✓ Branch 0 taken 50266 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 50266 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 50266 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 50266 times.
✗ Branch 7 not taken.
 50272 if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
644 50266 return ctx->priv;
645 6 return NULL;
646 }
647
648 ✗ static const AVClass *filter_child_class_iterate(void **iter)
649 {
650 const AVFilter *f;
651
652 ✗ while ((f = av_filter_iterate(iter)))
653 ✗ if (f->priv_class)
654 ✗ return f->priv_class;
655
656 ✗ return NULL;
657 }
658
659 #define OFFSET(x) offsetof(AVFilterContext, x)
660 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
661 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
662 static const AVOption avfilter_options[] = {
663 { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
664 { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, .unit = "thread_type" },
665 { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
666 { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = TFLAGS },
667 { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
668 { .i64 = 0 }, 0, INT_MAX, FLAGS, .unit = "threads" },
669 {"auto", "autodetect a suitable number of threads to use", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, .flags = FLAGS, .unit = "threads"},
670 { "extra_hw_frames", "Number of extra hardware frames to allocate for the user",
671 OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
672 { NULL },
673 };
674
675 static const AVClass avfilter_class = {
676 .class_name = "AVFilter",
677 .item_name = default_filter_name,
678 .version = LIBAVUTIL_VERSION_INT,
679 .category = AV_CLASS_CATEGORY_FILTER,
680 .child_next = filter_child_next,
681 .child_class_iterate = filter_child_class_iterate,
682 .option = avfilter_options,
683 .state_flags_offset = offsetof(FFFilterContext, state_flags),
684 };
685
686 728 static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg,
687 int *ret, int nb_jobs)
688 {
689 int i;
690
691
2/2
✓ Branch 0 taken 728 times.
✓ Branch 1 taken 728 times.
 1456 for (i = 0; i < nb_jobs; i++) {
692 728 int r = func(ctx, arg, i, nb_jobs);
693
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 728 times.
 728 if (ret)
694 ✗ ret[i] = r;
695 }
696 728 return 0;
697 }
698
699 58008 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
700 {
701 FFFilterContext *ctx;
702 AVFilterContext *ret;
703 58008 const FFFilter *const fi = fffilter(filter);
704 58008 int preinited = 0;
705
706
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58008 times.
 58008 if (!filter)
707 ✗ return NULL;
708
709 58008 ctx = av_mallocz(sizeof(*ctx));
710
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58008 times.
 58008 if (!ctx)
711 ✗ return NULL;
712 58008 ret = &ctx->p;
713
714 58008 ret->av_class = &avfilter_class;
715 58008 ret->filter = filter;
716
1/2
✓ Branch 0 taken 58008 times.
✗ Branch 1 not taken.
 58008 ret->name = inst_name ? av_strdup(inst_name) : NULL;
717
2/2
✓ Branch 0 taken 51351 times.
✓ Branch 1 taken 6657 times.
 58008 if (fi->priv_size) {
718 51351 ret->priv = av_mallocz(fi->priv_size);
719
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 51351 times.
 51351 if (!ret->priv)
720 ✗ goto err;
721 }
722
2/2
✓ Branch 0 taken 12318 times.
✓ Branch 1 taken 45690 times.
 58008 if (fi->preinit) {
723
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12318 times.
 12318 if (fi->preinit(ret) < 0)
724 ✗ goto err;
725 12318 preinited = 1;
726 }
727
728 58008 av_opt_set_defaults(ret);
729
2/2
✓ Branch 0 taken 50154 times.
✓ Branch 1 taken 7854 times.
 58008 if (filter->priv_class) {
730 50154 *(const AVClass**)ret->priv = filter->priv_class;
731 50154 av_opt_set_defaults(ret->priv);
732 }
733
734 58008 ctx->execute = default_execute;
735
736 58008 ret->nb_inputs = fi->nb_inputs;
737
2/2
✓ Branch 0 taken 49228 times.
✓ Branch 1 taken 8780 times.
 58008 if (ret->nb_inputs ) {
738 49228 ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs));
739
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 49228 times.
 49228 if (!ret->input_pads)
740 ✗ goto err;
741 49228 ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs));
742
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 49228 times.
 49228 if (!ret->inputs)
743 ✗ goto err;
744 }
745
746 58008 ret->nb_outputs = fi->nb_outputs;
747
2/2
✓ Branch 0 taken 50164 times.
✓ Branch 1 taken 7844 times.
 58008 if (ret->nb_outputs) {
748 50164 ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
749
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50164 times.
 50164 if (!ret->output_pads)
750 ✗ goto err;
751 50164 ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs));
752
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50164 times.
 50164 if (!ret->outputs)
753 ✗ goto err;
754 }
755
756 58008 return ret;
757
758 ✗ err:
759 ✗ if (preinited)
760 ✗ fi->uninit(ret);
761 ✗ av_freep(&ret->inputs);
762 ✗ av_freep(&ret->input_pads);
763 ✗ ret->nb_inputs = 0;
764 ✗ av_freep(&ret->outputs);
765 ✗ av_freep(&ret->output_pads);
766 ✗ ret->nb_outputs = 0;
767 ✗ av_freep(&ret->priv);
768 ✗ av_free(ret);
769 ✗ return NULL;
770 }
771
772 99987 static void free_link(AVFilterLink *link)
773 {
774
2/2
✓ Branch 0 taken 57156 times.
✓ Branch 1 taken 42831 times.
 99987 if (!link)
775 57156 return;
776
777
2/2
✓ Branch 0 taken 42699 times.
✓ Branch 1 taken 132 times.
 42831 if (link->src)
778 42699 link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
779
2/2
✓ Branch 0 taken 42699 times.
✓ Branch 1 taken 132 times.
 42831 if (link->dst)
780 42699 link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
781
782 42831 ff_formats_unref(&link->incfg.formats);
783 42831 ff_formats_unref(&link->outcfg.formats);
784 42831 ff_formats_unref(&link->incfg.color_spaces);
785 42831 ff_formats_unref(&link->outcfg.color_spaces);
786 42831 ff_formats_unref(&link->incfg.color_ranges);
787 42831 ff_formats_unref(&link->outcfg.color_ranges);
788 42831 ff_formats_unref(&link->incfg.samplerates);
789 42831 ff_formats_unref(&link->outcfg.samplerates);
790 42831 ff_channel_layouts_unref(&link->incfg.channel_layouts);
791 42831 ff_channel_layouts_unref(&link->outcfg.channel_layouts);
792 42831 link_free(&link);
793 }
794
795 58008 void avfilter_free(AVFilterContext *filter)
796 {
797 FFFilterContext *ctxi;
798 int i;
799
800
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58008 times.
 58008 if (!filter)
801 ✗ return;
802 58008 ctxi = fffilterctx(filter);
803
804
1/2
✓ Branch 0 taken 58008 times.
✗ Branch 1 not taken.
 58008 if (filter->graph)
805 58008 ff_filter_graph_remove_filter(filter->graph, filter);
806
807
2/2
✓ Branch 1 taken 44569 times.
✓ Branch 2 taken 13439 times.
 58008 if (fffilter(filter->filter)->uninit)
808 44569 fffilter(filter->filter)->uninit(filter);
809
810
2/2
✓ Branch 0 taken 49551 times.
✓ Branch 1 taken 58008 times.
 107559 for (i = 0; i < filter->nb_inputs; i++) {
811 49551 free_link(filter->inputs[i]);
812
2/2
✓ Branch 0 taken 210 times.
✓ Branch 1 taken 49341 times.
 49551 if (filter->input_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
813 210 av_freep(&filter->input_pads[i].name);
814 }
815
2/2
✓ Branch 0 taken 50436 times.
✓ Branch 1 taken 58008 times.
 108444 for (i = 0; i < filter->nb_outputs; i++) {
816 50436 free_link(filter->outputs[i]);
817
2/2
✓ Branch 0 taken 267 times.
✓ Branch 1 taken 50169 times.
 50436 if (filter->output_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
818 267 av_freep(&filter->output_pads[i].name);
819 }
820
821
2/2
✓ Branch 0 taken 50154 times.
✓ Branch 1 taken 7854 times.
 58008 if (filter->filter->priv_class)
822 50154 av_opt_free(filter->priv);
823
824 58008 av_buffer_unref(&filter->hw_device_ctx);
825
826 58008 av_freep(&filter->name);
827 58008 av_freep(&filter->input_pads);
828 58008 av_freep(&filter->output_pads);
829 58008 av_freep(&filter->inputs);
830 58008 av_freep(&filter->outputs);
831 58008 av_freep(&filter->priv);
832
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58008 times.
 58008 while (ctxi->command_queue)
833 ✗ command_queue_pop(filter);
834 58008 av_opt_free(filter);
835 58008 av_expr_free(ctxi->enable);
836 58008 ctxi->enable = NULL;
837 58008 av_freep(&ctxi->var_values);
838 58008 av_free(filter);
839 }
840
841 16347 int ff_filter_get_nb_threads(AVFilterContext *ctx)
842 {
843
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16347 times.
 16347 if (ctx->nb_threads > 0)
844 ✗ return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
845 16347 return ctx->graph->nb_threads;
846 }
847
848 29972 int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
849 AVDictionary **options, const char *args)
850 {
851 29972 const AVOption *o = NULL;
852 int ret;
853 29972 int offset= -1;
854
855
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 29972 times.
 29972 if (!args)
856 ✗ return 0;
857
858
2/2
✓ Branch 0 taken 51777 times.
✓ Branch 1 taken 29972 times.
 81749 while (*args) {
859 char *parsed_key, *value;
860 const char *key;
861 51777 const char *shorthand = NULL;
862 51777 int additional_flags = 0;
863
864
4/4
✓ Branch 0 taken 40023 times.
✓ Branch 1 taken 11754 times.
✓ Branch 3 taken 38741 times.
✓ Branch 4 taken 1282 times.
 51777 if (priv_class && (o = av_opt_next(&priv_class, o))) {
865
4/4
✓ Branch 0 taken 36971 times.
✓ Branch 1 taken 1770 times.
✓ Branch 2 taken 3802 times.
✓ Branch 3 taken 33169 times.
 38741 if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
866 5572 continue;
867 33169 offset = o->offset;
868 33169 shorthand = o->name;
869 }
870
871 46205 ret = av_opt_get_key_value(&args, "=", ":",
872 shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
873 &parsed_key, &value);
874
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46205 times.
 46205 if (ret < 0) {
875 ✗ if (ret == AVERROR(EINVAL))
876 ✗ av_log(logctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
877 else
878 ✗ av_log(logctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
879 ✗ av_err2str(ret));
880 ✗ return ret;
881 }
882
2/2
✓ Branch 0 taken 24565 times.
✓ Branch 1 taken 21640 times.
 46205 if (*args)
883 24565 args++;
884
2/2
✓ Branch 0 taken 27741 times.
✓ Branch 1 taken 18464 times.
 46205 if (parsed_key) {
885 27741 key = parsed_key;
886 27741 additional_flags = AV_DICT_DONT_STRDUP_KEY;
887 27741 priv_class = NULL; /* reject all remaining shorthand */
888 } else {
889 18464 key = shorthand;
890 }
891
892 46205 av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
893
894 46205 av_dict_set(options, key, value,
895 additional_flags | AV_DICT_DONT_STRDUP_VAL | AV_DICT_MULTIKEY);
896 }
897
898 29972 return 0;
899 }
900
901 ✗ int ff_filter_process_command(AVFilterContext *ctx, const char *cmd,
902 const char *arg, char *res, int res_len, int flags)
903 {
904 const AVOption *o;
905
906 ✗ if (!ctx->filter->priv_class)
907 ✗ return 0;
908 ✗ o = av_opt_find2(ctx->priv, cmd, NULL, AV_OPT_FLAG_RUNTIME_PARAM | AV_OPT_FLAG_FILTERING_PARAM, AV_OPT_SEARCH_CHILDREN, NULL);
909 ✗ if (!o)
910 ✗ return AVERROR(ENOSYS);
911 ✗ return av_opt_set(ctx->priv, cmd, arg, 0);
912 }
913
914 58008 int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
915 {
916 58008 FFFilterContext *ctxi = fffilterctx(ctx);
917 58008 int ret = 0;
918
919
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58008 times.
 58008 if (ctxi->state_flags & AV_CLASS_STATE_INITIALIZED) {
920 ✗ av_log(ctx, AV_LOG_ERROR, "Filter already initialized\n");
921 ✗ return AVERROR(EINVAL);
922 }
923
924 58008 ret = av_opt_set_dict2(ctx, options, AV_OPT_SEARCH_CHILDREN);
925
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58008 times.
 58008 if (ret < 0) {
926 ✗ av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
927 ✗ return ret;
928 }
929
930
2/2
✓ Branch 0 taken 1190 times.
✓ Branch 1 taken 56818 times.
 58008 if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
931
2/2
✓ Branch 0 taken 147 times.
✓ Branch 1 taken 1043 times.
 1190 ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
932
1/2
✓ Branch 1 taken 147 times.
✗ Branch 2 not taken.
 147 fffiltergraph(ctx->graph)->thread_execute) {
933 147 ctx->thread_type = AVFILTER_THREAD_SLICE;
934 147 ctxi->execute = fffiltergraph(ctx->graph)->thread_execute;
935 } else {
936 57861 ctx->thread_type = 0;
937 }
938
939
2/2
✓ Branch 1 taken 45029 times.
✓ Branch 2 taken 12979 times.
 58008 if (fffilter(ctx->filter)->init)
940 45029 ret = fffilter(ctx->filter)->init(ctx);
941
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58008 times.
 58008 if (ret < 0)
942 ✗ return ret;
943
944
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 58002 times.
 58008 if (ctx->enable_str) {
945 6 ret = set_enable_expr(ctxi, ctx->enable_str);
946
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (ret < 0)
947 ✗ return ret;
948 }
949
950 58008 ctxi->state_flags |= AV_CLASS_STATE_INITIALIZED;
951
952 58008 return 0;
953 }
954
955 18987 int avfilter_init_str(AVFilterContext *filter, const char *args)
956 {
957 18987 AVDictionary *options = NULL;
958 const AVDictionaryEntry *e;
959 18987 int ret = 0;
960
961
3/4
✓ Branch 0 taken 9489 times.
✓ Branch 1 taken 9498 times.
✓ Branch 2 taken 9489 times.
✗ Branch 3 not taken.
 18987 if (args && *args) {
962 9489 ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args);
963
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9489 times.
 9489 if (ret < 0)
964 ✗ goto fail;
965 }
966
967 18987 ret = avfilter_init_dict(filter, &options);
968
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18987 times.
 18987 if (ret < 0)
969 ✗ goto fail;
970
971
1/2
✓ Branch 1 taken 18987 times.
✗ Branch 2 not taken.
 18987 if ((e = av_dict_iterate(options, NULL))) {
972 ✗ av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
973 ✗ ret = AVERROR_OPTION_NOT_FOUND;
974 ✗ goto fail;
975 }
976
977 18987 fail:
978 18987 av_dict_free(&options);
979
980 18987 return ret;
981 }
982
983 14455 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
984 {
985 14455 return pads[pad_idx].name;
986 }
987
988 29183 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
989 {
990 29183 return pads[pad_idx].type;
991 }
992
993 659495 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
994 {
995 659495 return ff_filter_frame(link->dst->outputs[0], frame);
996 }
997
998 /**
999 * Evaluate the timeline expression of the link for the time and properties
1000 * of the frame.
1001 * @return >0 if enabled, 0 if disabled
1002 * @note It does not update link->dst->is_disabled.
1003 */
1004 2099493 static int evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1005 {
1006 2099493 FilterLink *l = ff_filter_link(link);
1007 2099493 AVFilterContext *dstctx = link->dst;
1008 2099493 FFFilterContext *dsti = fffilterctx(dstctx);
1009 2099493 int64_t pts = frame->pts;
1010 #if FF_API_FRAME_PKT
1011 FF_DISABLE_DEPRECATION_WARNINGS
1012 2099493 int64_t pos = frame->pkt_pos;
1013 FF_ENABLE_DEPRECATION_WARNINGS
1014 #endif
1015
1016
2/2
✓ Branch 0 taken 2099297 times.
✓ Branch 1 taken 196 times.
 2099493 if (!dstctx->enable_str)
1017 2099297 return 1;
1018
1019 196 dsti->var_values[VAR_N] = l->frame_count_out;
1020
1/2
✓ Branch 0 taken 196 times.
✗ Branch 1 not taken.
 196 dsti->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1021 196 dsti->var_values[VAR_W] = link->w;
1022 196 dsti->var_values[VAR_H] = link->h;
1023 #if FF_API_FRAME_PKT
1024
1/2
✓ Branch 0 taken 196 times.
✗ Branch 1 not taken.
 196 dsti->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1025 #endif
1026
1027 196 return fabs(av_expr_eval(dsti->enable, dsti->var_values, NULL)) >= 0.5;
1028 }
1029
1030 677511 static int filter_frame_framed(AVFilterLink *link, AVFrame *frame)
1031 {
1032 677511 FilterLink *l = ff_filter_link(link);
1033 int (*filter_frame)(AVFilterLink *, AVFrame *);
1034 677511 AVFilterContext *dstctx = link->dst;
1035 677511 AVFilterPad *dst = link->dstpad;
1036 int ret;
1037
1038
2/2
✓ Branch 0 taken 659486 times.
✓ Branch 1 taken 18025 times.
 677511 if (!(filter_frame = dst->filter_frame))
1039 659486 filter_frame = default_filter_frame;
1040
1041
2/2
✓ Branch 0 taken 2486 times.
✓ Branch 1 taken 675025 times.
 677511 if (dst->flags & AVFILTERPAD_FLAG_NEEDS_WRITABLE) {
1042 2486 ret = ff_inlink_make_frame_writable(link, &frame);
1043
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2486 times.
 2486 if (ret < 0)
1044 ✗ goto fail;
1045 }
1046
1047 677511 ff_inlink_process_commands(link, frame);
1048 677511 dstctx->is_disabled = !evaluate_timeline_at_frame(link, frame);
1049
1050
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 677492 times.
 677511 if (dstctx->is_disabled &&
1051
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 10 times.
 19 (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
1052 9 filter_frame = default_filter_frame;
1053 677511 ret = filter_frame(link, frame);
1054 677511 l->frame_count_out++;
1055 677511 return ret;
1056
1057 ✗ fail:
1058 ✗ av_frame_free(&frame);
1059 ✗ return ret;
1060 }
1061
1062 1423890 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1063 {
1064 1423890 FilterLinkInternal * const li = ff_link_internal(link);
1065 int ret;
1066 1423890 FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); tlog_ref(NULL, frame, 1);
1067
1068 /* Consistency checks */
1069
2/2
✓ Branch 0 taken 494599 times.
✓ Branch 1 taken 929291 times.
 1423890 if (link->type == AVMEDIA_TYPE_VIDEO) {
1070
2/2
✓ Branch 0 taken 361795 times.
✓ Branch 1 taken 132804 times.
 494599 if (strcmp(link->dst->filter->name, "buffersink") &&
1071
2/2
✓ Branch 0 taken 221697 times.
✓ Branch 1 taken 140098 times.
 361795 strcmp(link->dst->filter->name, "format") &&
1072
2/2
✓ Branch 0 taken 221671 times.
✓ Branch 1 taken 26 times.
 221697 strcmp(link->dst->filter->name, "idet") &&
1073
2/2
✓ Branch 0 taken 132904 times.
✓ Branch 1 taken 88767 times.
 221671 strcmp(link->dst->filter->name, "null") &&
1074 132904 strcmp(link->dst->filter->name, "scale")) {
1075 av_assert1(frame->format == link->format);
1076 av_assert1(frame->width == link->w);
1077 av_assert1(frame->height == link->h);
1078 }
1079
1080 494599 frame->sample_aspect_ratio = link->sample_aspect_ratio;
1081 } else {
1082
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 929291 times.
 929291 if (frame->format != link->format) {
1083 ✗ av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1084 ✗ goto error;
1085 }
1086
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 929291 times.
 929291 if (av_channel_layout_compare(&frame->ch_layout, &link->ch_layout)) {
1087 ✗ av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1088 ✗ goto error;
1089 }
1090
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 929291 times.
 929291 if (frame->sample_rate != link->sample_rate) {
1091 ✗ av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1092 ✗ goto error;
1093 }
1094
1095 929291 frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1096 link->time_base);
1097 }
1098
1099 1423890 li->frame_blocked_in = li->frame_wanted_out = 0;
1100 1423890 li->l.frame_count_in++;
1101 1423890 li->l.sample_count_in += frame->nb_samples;
1102 1423890 filter_unblock(link->dst);
1103 1423890 ret = ff_framequeue_add(&li->fifo, frame);
1104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1423890 times.
 1423890 if (ret < 0) {
1105 ✗ av_frame_free(&frame);
1106 ✗ return ret;
1107 }
1108 1423890 ff_filter_set_ready(link->dst, 300);
1109 1423890 return 0;
1110
1111 ✗ error:
1112 ✗ av_frame_free(&frame);
1113 ✗ return AVERROR_PATCHWELCOME;
1114 }
1115
1116 2023451 static int samples_ready(FilterLinkInternal *link, unsigned min)
1117 {
1118
2/2
✓ Branch 1 taken 677614 times.
✓ Branch 2 taken 1345837 times.
 2701065 return ff_framequeue_queued_frames(&link->fifo) &&
1119
2/2
✓ Branch 1 taken 104 times.
✓ Branch 2 taken 677510 times.
 677614 (ff_framequeue_queued_samples(&link->fifo) >= min ||
1120
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 103 times.
 104 link->status_in);
1121 }
1122
1123 2482 static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max,
1124 AVFrame **rframe)
1125 {
1126 2482 FilterLink *l = &li->l;
1127 2482 AVFilterLink *link = &l->pub;
1128 AVFrame *frame0, *frame, *buf;
1129 unsigned nb_samples, nb_frames, i, p;
1130 int ret;
1131
1132 /* Note: this function relies on no format changes and must only be
1133 called with enough samples. */
1134 av_assert1(samples_ready(li, l->min_samples));
1135 2482 frame0 = frame = ff_framequeue_peek(&li->fifo, 0);
1136
6/6
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 1556 times.
✓ Branch 2 taken 813 times.
✓ Branch 3 taken 113 times.
✓ Branch 4 taken 541 times.
✓ Branch 5 taken 272 times.
 2482 if (!li->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1137 541 *rframe = ff_framequeue_take(&li->fifo);
1138 541 return 0;
1139 }
1140 1941 nb_frames = 0;
1141 1941 nb_samples = 0;
1142 while (1) {
1143
2/2
✓ Branch 0 taken 1558 times.
✓ Branch 1 taken 1465 times.
 3023 if (nb_samples + frame->nb_samples > max) {
1144
2/2
✓ Branch 0 taken 1556 times.
✓ Branch 1 taken 2 times.
 1558 if (nb_samples < min)
1145 1556 nb_samples = max;
1146 1558 break;
1147 }
1148 1465 nb_samples += frame->nb_samples;
1149 1465 nb_frames++;
1150
2/2
✓ Branch 1 taken 383 times.
✓ Branch 2 taken 1082 times.
 1465 if (nb_frames == ff_framequeue_queued_frames(&li->fifo))
1151 383 break;
1152 1082 frame = ff_framequeue_peek(&li->fifo, nb_frames);
1153 }
1154
1155 1941 buf = ff_get_audio_buffer(link, nb_samples);
1156
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1941 times.
 1941 if (!buf)
1157 ✗ return AVERROR(ENOMEM);
1158 1941 ret = av_frame_copy_props(buf, frame0);
1159
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1941 times.
 1941 if (ret < 0) {
1160 ✗ av_frame_free(&buf);
1161 ✗ return ret;
1162 }
1163
1164 1941 p = 0;
1165
2/2
✓ Branch 0 taken 1465 times.
✓ Branch 1 taken 1941 times.
 3406 for (i = 0; i < nb_frames; i++) {
1166 1465 frame = ff_framequeue_take(&li->fifo);
1167 1465 av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1168 1465 frame->nb_samples, link->ch_layout.nb_channels, link->format);
1169 1465 p += frame->nb_samples;
1170 1465 av_frame_free(&frame);
1171 }
1172
2/2
✓ Branch 0 taken 1556 times.
✓ Branch 1 taken 385 times.
 1941 if (p < nb_samples) {
1173 1556 unsigned n = nb_samples - p;
1174 1556 frame = ff_framequeue_peek(&li->fifo, 0);
1175 1556 av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1176 1556 link->ch_layout.nb_channels, link->format);
1177 1556 ff_framequeue_skip_samples(&li->fifo, n, link->time_base);
1178 }
1179
1180 1941 *rframe = buf;
1181 1941 return 0;
1182 }
1183
1184 677511 static int filter_frame_to_filter(AVFilterLink *link)
1185 {
1186 677511 FilterLinkInternal * const li = ff_link_internal(link);
1187 677511 AVFrame *frame = NULL;
1188 677511 AVFilterContext *dst = link->dst;
1189 int ret;
1190
1191 av_assert1(ff_framequeue_queued_frames(&li->fifo));
1192 1355022 ret = li->l.min_samples ?
1193
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 677475 times.
 677511 ff_inlink_consume_samples(link, li->l.min_samples, li->l.max_samples, &frame) :
1194 677475 ff_inlink_consume_frame(link, &frame);
1195 av_assert1(ret);
1196
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 677511 times.
 677511 if (ret < 0) {
1197 av_assert1(!frame);
1198 ✗ return ret;
1199 }
1200 /* The filter will soon have received a new frame, that may allow it to
1201 produce one or more: unblock its outputs. */
1202 677511 filter_unblock(dst);
1203 /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1204 before the frame; filter_frame_framed() will re-increment it. */
1205 677511 li->l.frame_count_out--;
1206 677511 ret = filter_frame_framed(link, frame);
1207
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 677511 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 677511 if (ret < 0 && ret != li->status_out) {
1208 ✗ link_set_out_status(link, ret, AV_NOPTS_VALUE);
1209 } else {
1210 /* Run once again, to see if several frames were available, or if
1211 the input status has also changed, or any other reason. */
1212 677511 ff_filter_set_ready(dst, 300);
1213 }
1214 677511 return ret;
1215 }
1216
1217 5884 static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
1218 {
1219 5884 AVFilterLink *in = &li_in->l.pub;
1220 5884 unsigned out = 0, progress = 0;
1221 int ret;
1222
1223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5884 times.
 5884 av_assert0(!li_in->status_out);
1224
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5884 times.
 5884 if (!filter->nb_outputs) {
1225 /* not necessary with the current API and sinks */
1226 ✗ return 0;
1227 }
1228
2/2
✓ Branch 0 taken 5884 times.
✓ Branch 1 taken 5884 times.
 11768 while (!li_in->status_out) {
1229 5884 FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1230
1231
1/2
✓ Branch 0 taken 5884 times.
✗ Branch 1 not taken.
 5884 if (!li_out->status_in) {
1232 5884 progress++;
1233 5884 ret = request_frame_to_filter(filter->outputs[out]);
1234
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5884 times.
 5884 if (ret < 0)
1235 ✗ return ret;
1236 }
1237
1/2
✓ Branch 0 taken 5884 times.
✗ Branch 1 not taken.
 5884 if (++out == filter->nb_outputs) {
1238
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5884 times.
 5884 if (!progress) {
1239 /* Every output already closed: input no longer interesting
1240 (example: overlay in shortest mode, other input closed). */
1241 ✗ link_set_out_status(in, li_in->status_in, li_in->status_in_pts);
1242 ✗ return 0;
1243 }
1244 5884 progress = 0;
1245 5884 out = 0;
1246 }
1247 }
1248 5884 ff_filter_set_ready(filter, 200);
1249 5884 return 0;
1250 }
1251
1252 2030433 static int filter_activate_default(AVFilterContext *filter)
1253 {
1254 unsigned i;
1255
1256
2/2
✓ Branch 0 taken 2030433 times.
✓ Branch 1 taken 2023729 times.
 4054162 for (i = 0; i < filter->nb_outputs; i++) {
1257 2030433 FilterLinkInternal *li = ff_link_internal(filter->outputs[i]);
1258 2030433 int ret = li->status_in;
1259
1260
2/2
✓ Branch 0 taken 6704 times.
✓ Branch 1 taken 2023729 times.
 2030433 if (ret) {
1261
2/2
✓ Branch 0 taken 6704 times.
✓ Branch 1 taken 6704 times.
 13408 for (int j = 0; j < filter->nb_inputs; j++)
1262 6704 ff_inlink_set_status(filter->inputs[j], ret);
1263 6704 return 0;
1264 }
1265 }
1266
1267
2/2
✓ Branch 0 taken 2023451 times.
✓ Branch 1 taken 1346218 times.
 3369669 for (i = 0; i < filter->nb_inputs; i++) {
1268 2023451 FilterLinkInternal *li = ff_link_internal(filter->inputs[i]);
1269
2/2
✓ Branch 1 taken 677511 times.
✓ Branch 2 taken 1345940 times.
 2023451 if (samples_ready(li, li->l.min_samples)) {
1270 677511 return filter_frame_to_filter(filter->inputs[i]);
1271 }
1272 }
1273
2/2
✓ Branch 0 taken 1345940 times.
✓ Branch 1 taken 1340334 times.
 2686274 for (i = 0; i < filter->nb_inputs; i++) {
1274 1345940 FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1275
4/4
✓ Branch 0 taken 5908 times.
✓ Branch 1 taken 1340032 times.
✓ Branch 2 taken 5884 times.
✓ Branch 3 taken 24 times.
 1345940 if (li->status_in && !li->status_out) {
1276 av_assert1(!ff_framequeue_queued_frames(&li->fifo));
1277 5884 return forward_status_change(filter, li);
1278 }
1279 }
1280
2/2
✓ Branch 0 taken 1340334 times.
✓ Branch 1 taken 672685 times.
 2013019 for (i = 0; i < filter->nb_outputs; i++) {
1281 1340334 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1282
2/2
✓ Branch 0 taken 667799 times.
✓ Branch 1 taken 672535 times.
 1340334 if (li->frame_wanted_out &&
1283
2/2
✓ Branch 0 taken 667649 times.
✓ Branch 1 taken 150 times.
 667799 !li->frame_blocked_in) {
1284 667649 return request_frame_to_filter(filter->outputs[i]);
1285 }
1286 }
1287 672685 return FFERROR_NOT_READY;
1288 }
1289
1290 /*
1291 Filter scheduling and activation
1292
1293 When a filter is activated, it must:
1294 - if possible, output a frame;
1295 - else, if relevant, forward the input status change;
1296 - else, check outputs for wanted frames and forward the requests.
1297
1298 The following AVFilterLink fields are used for activation:
1299
1300 - frame_wanted_out:
1301
1302 This field indicates if a frame is needed on this input of the
1303 destination filter. A positive value indicates that a frame is needed
1304 to process queued frames or internal data or to satisfy the
1305 application; a zero value indicates that a frame is not especially
1306 needed but could be processed anyway; a negative value indicates that a
1307 frame would just be queued.
1308
1309 It is set by filters using ff_request_frame() or ff_request_no_frame(),
1310 when requested by the application through a specific API or when it is
1311 set on one of the outputs.
1312
1313 It is cleared when a frame is sent from the source using
1314 ff_filter_frame().
1315
1316 It is also cleared when a status change is sent from the source using
1317 ff_avfilter_link_set_in_status().
1318
1319 - frame_blocked_in:
1320
1321 This field means that the source filter can not generate a frame as is.
1322 Its goal is to avoid repeatedly calling the request_frame() method on
1323 the same link.
1324
1325 It is set by the framework on all outputs of a filter before activating it.
1326
1327 It is automatically cleared by ff_filter_frame().
1328
1329 It is also automatically cleared by ff_avfilter_link_set_in_status().
1330
1331 It is also cleared on all outputs (using filter_unblock()) when
1332 something happens on an input: processing a frame or changing the
1333 status.
1334
1335 - fifo:
1336
1337 Contains the frames queued on a filter input. If it contains frames and
1338 frame_wanted_out is not set, then the filter can be activated. If that
1339 result in the filter not able to use these frames, the filter must set
1340 frame_wanted_out to ask for more frames.
1341
1342 - status_in and status_in_pts:
1343
1344 Status (EOF or error code) of the link and timestamp of the status
1345 change (in link time base, same as frames) as seen from the input of
1346 the link. The status change is considered happening after the frames
1347 queued in fifo.
1348
1349 It is set by the source filter using ff_avfilter_link_set_in_status().
1350
1351 - status_out:
1352
1353 Status of the link as seen from the output of the link. The status
1354 change is considered having already happened.
1355
1356 It is set by the destination filter using
1357 link_set_out_status().
1358
1359 Filters are activated according to the ready field, set using the
1360 ff_filter_set_ready(). Eventually, a priority queue will be used.
1361 ff_filter_set_ready() is called whenever anything could cause progress to
1362 be possible. Marking a filter ready when it is not is not a problem,
1363 except for the small overhead it causes.
1364
1365 Conditions that cause a filter to be marked ready are:
1366
1367 - frames added on an input link;
1368
1369 - changes in the input or output status of an input link;
1370
1371 - requests for a frame on an output link;
1372
1373 - after any actual processing using the legacy methods (filter_frame(),
1374 and request_frame() to acknowledge status changes), to run once more
1375 and check if enough input was present for several frames.
1376
1377 Examples of scenarios to consider:
1378
1379 - buffersrc: activate if frame_wanted_out to notify the application;
1380 activate when the application adds a frame to push it immediately.
1381
1382 - testsrc: activate only if frame_wanted_out to produce and push a frame.
1383
1384 - concat (not at stitch points): can process a frame on any output.
1385 Activate if frame_wanted_out on output to forward on the corresponding
1386 input. Activate when a frame is present on input to process it
1387 immediately.
1388
1389 - framesync: needs at least one frame on each input; extra frames on the
1390 wrong input will accumulate. When a frame is first added on one input,
1391 set frame_wanted_out<0 on it to avoid getting more (would trigger
1392 testsrc) and frame_wanted_out>0 on the other to allow processing it.
1393
1394 Activation of old filters:
1395
1396 In order to activate a filter implementing the legacy filter_frame() and
1397 request_frame() methods, perform the first possible of the following
1398 actions:
1399
1400 - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1401 frame and call filter_frame().
1402
1403 Rationale: filter frames as soon as possible instead of leaving them
1404 queued; frame_wanted_out < 0 is not possible since the old API does not
1405 set it nor provides any similar feedback; frame_wanted_out > 0 happens
1406 when min_samples > 0 and there are not enough samples queued.
1407
1408 - If an input has status_in set but not status_out, try to call
1409 request_frame() on one of the outputs in the hope that it will trigger
1410 request_frame() on the input with status_in and acknowledge it. This is
1411 awkward and fragile, filters with several inputs or outputs should be
1412 updated to direct activation as soon as possible.
1413
1414 - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1415 request_frame().
1416
1417 Rationale: checking frame_blocked_in is necessary to avoid requesting
1418 repeatedly on a blocked input if another is not blocked (example:
1419 [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1420 */
1421
1422 3528567 int ff_filter_activate(AVFilterContext *filter)
1423 {
1424 3528567 FFFilterContext *ctxi = fffilterctx(filter);
1425 3528567 const FFFilter *const fi = fffilter(filter->filter);
1426 int ret;
1427
1428 /* Generic timeline support is not yet implemented but should be easy */
1429 av_assert1(!(fi->p.flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
1430 fi->activate));
1431 3528567 ctxi->ready = 0;
1432
2/2
✓ Branch 0 taken 1498134 times.
✓ Branch 1 taken 2030433 times.
 3528567 ret = fi->activate ? fi->activate(filter) : filter_activate_default(filter);
1433
2/2
✓ Branch 0 taken 1033720 times.
✓ Branch 1 taken 2494847 times.
 3528567 if (ret == FFERROR_NOT_READY)
1434 1033720 ret = 0;
1435 3528567 return ret;
1436 }
1437
1438 3144363 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1439 {
1440 3144363 FilterLinkInternal * const li = ff_link_internal(link);
1441 3144363 *rpts = li->l.current_pts;
1442
2/2
✓ Branch 1 taken 1945 times.
✓ Branch 2 taken 3142418 times.
 3144363 if (ff_framequeue_queued_frames(&li->fifo))
1443 1945 return *rstatus = 0;
1444
2/2
✓ Branch 0 taken 1902 times.
✓ Branch 1 taken 3140516 times.
 3142418 if (li->status_out)
1445 1902 return *rstatus = li->status_out;
1446
2/2
✓ Branch 0 taken 3133081 times.
✓ Branch 1 taken 7435 times.
 3140516 if (!li->status_in)
1447 3133081 return *rstatus = 0;
1448 7435 *rstatus = li->status_out = li->status_in;
1449 7435 update_link_current_pts(li, li->status_in_pts);
1450 7435 *rpts = li->l.current_pts;
1451 7435 return 1;
1452 }
1453
1454 497375 size_t ff_inlink_queued_frames(AVFilterLink *link)
1455 {
1456 497375 FilterLinkInternal * const li = ff_link_internal(link);
1457 497375 return ff_framequeue_queued_frames(&li->fifo);
1458 }
1459
1460 4312345 int ff_inlink_check_available_frame(AVFilterLink *link)
1461 {
1462 4312345 FilterLinkInternal * const li = ff_link_internal(link);
1463 4312345 return ff_framequeue_queued_frames(&li->fifo) > 0;
1464 }
1465
1466 2075 int ff_inlink_queued_samples(AVFilterLink *link)
1467 {
1468 2075 FilterLinkInternal * const li = ff_link_internal(link);
1469 2075 return ff_framequeue_queued_samples(&li->fifo);
1470 }
1471
1472 4369 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1473 {
1474 4369 FilterLinkInternal * const li = ff_link_internal(link);
1475 4369 uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1476 av_assert1(min);
1477
6/6
✓ Branch 0 taken 1893 times.
✓ Branch 1 taken 2476 times.
✓ Branch 2 taken 66 times.
✓ Branch 3 taken 1827 times.
✓ Branch 4 taken 7 times.
✓ Branch 5 taken 59 times.
 4369 return samples >= min || (li->status_in && samples);
1478 }
1479
1480 1424357 static void consume_update(FilterLinkInternal *li, const AVFrame *frame)
1481 {
1482 1424357 AVFilterLink *const link = &li->l.pub;
1483 1424357 update_link_current_pts(li, frame->pts);
1484 1424357 ff_inlink_process_commands(link, frame);
1485
2/2
✓ Branch 0 taken 1421982 times.
✓ Branch 1 taken 2375 times.
 1424357 if (link == link->dst->inputs[0])
1486 1421982 link->dst->is_disabled = !evaluate_timeline_at_frame(link, frame);
1487 1424357 li->l.frame_count_out++;
1488 1424357 li->l.sample_count_out += frame->nb_samples;
1489 1424357 }
1490
1491 4310460 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1492 {
1493 4310460 FilterLinkInternal * const li = ff_link_internal(link);
1494 AVFrame *frame;
1495
1496 4310460 *rframe = NULL;
1497
2/2
✓ Branch 1 taken 2888582 times.
✓ Branch 2 taken 1421878 times.
 4310460 if (!ff_inlink_check_available_frame(link))
1498 2888582 return 0;
1499
1500
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1421875 times.
 1421878 if (li->fifo.samples_skipped) {
1501 3 frame = ff_framequeue_peek(&li->fifo, 0);
1502 3 return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1503 }
1504
1505 1421875 frame = ff_framequeue_take(&li->fifo);
1506 1421875 consume_update(li, frame);
1507 1421875 *rframe = frame;
1508 1421875 return 1;
1509 }
1510
1511 4217 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1512 AVFrame **rframe)
1513 {
1514 4217 FilterLinkInternal * const li = ff_link_internal(link);
1515 AVFrame *frame;
1516 int ret;
1517
1518 av_assert1(min);
1519 4217 *rframe = NULL;
1520
2/2
✓ Branch 1 taken 1735 times.
✓ Branch 2 taken 2482 times.
 4217 if (!ff_inlink_check_available_samples(link, min))
1521 1735 return 0;
1522
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 2463 times.
 2482 if (li->status_in)
1523
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 13 times.
 19 min = FFMIN(min, ff_framequeue_queued_samples(&li->fifo));
1524 2482 ret = take_samples(li, min, max, &frame);
1525
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2482 times.
 2482 if (ret < 0)
1526 ✗ return ret;
1527 2482 consume_update(li, frame);
1528 2482 *rframe = frame;
1529 2482 return 1;
1530 }
1531
1532 ✗ AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
1533 {
1534 ✗ FilterLinkInternal * const li = ff_link_internal(link);
1535 ✗ return ff_framequeue_peek(&li->fifo, idx);
1536 }
1537
1538 4627 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1539 {
1540 4627 AVFrame *frame = *rframe;
1541 AVFrame *out;
1542 int ret;
1543
1544
2/2
✓ Branch 1 taken 2146 times.
✓ Branch 2 taken 2481 times.
 4627 if (av_frame_is_writable(frame))
1545 2146 return 0;
1546 2481 av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1547
1548
1/3
✓ Branch 0 taken 2481 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 2481 switch (link->type) {
1549 2481 case AVMEDIA_TYPE_VIDEO:
1550 2481 out = ff_get_video_buffer(link, link->w, link->h);
1551 2481 break;
1552 ✗ case AVMEDIA_TYPE_AUDIO:
1553 ✗ out = ff_get_audio_buffer(link, frame->nb_samples);
1554 ✗ break;
1555 ✗ default:
1556 ✗ return AVERROR(EINVAL);
1557 }
1558
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2481 times.
 2481 if (!out)
1559 ✗ return AVERROR(ENOMEM);
1560
1561 2481 ret = av_frame_copy_props(out, frame);
1562
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2481 times.
 2481 if (ret < 0) {
1563 ✗ av_frame_free(&out);
1564 ✗ return ret;
1565 }
1566
1567 2481 ret = av_frame_copy(out, frame);
1568
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2481 times.
 2481 if (ret < 0) {
1569 ✗ av_frame_free(&out);
1570 ✗ return ret;
1571 }
1572
1573 2481 av_frame_free(&frame);
1574 2481 *rframe = out;
1575 2481 return 0;
1576 }
1577
1578 2101868 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1579 {
1580 2101868 FFFilterContext *ctxi = fffilterctx(link->dst);
1581 2101868 AVFilterCommand *cmd = ctxi->command_queue;
1582
1583
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2101868 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 2101868 while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1584 ✗ av_log(link->dst, AV_LOG_DEBUG,
1585 "Processing command time:%f command:%s arg:%s\n",
1586 cmd->time, cmd->command, cmd->arg);
1587 ✗ avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1588 ✗ command_queue_pop(link->dst);
1589 ✗ cmd = ctxi->command_queue;
1590 }
1591 2101868 return 0;
1592 }
1593
1594 738575 void ff_inlink_request_frame(AVFilterLink *link)
1595 {
1596 738575 av_unused FilterLinkInternal *li = ff_link_internal(link);
1597 av_assert1(!li->status_in);
1598 av_assert1(!li->status_out);
1599 738575 li->frame_wanted_out = 1;
1600 738575 ff_filter_set_ready(link->src, 100);
1601 738575 }
1602
1603 10384 void ff_inlink_set_status(AVFilterLink *link, int status)
1604 {
1605 10384 FilterLinkInternal * const li = ff_link_internal(link);
1606
2/2
✓ Branch 0 taken 8282 times.
✓ Branch 1 taken 2102 times.
 10384 if (li->status_out)
1607 8282 return;
1608 2102 li->frame_wanted_out = 0;
1609 2102 li->frame_blocked_in = 0;
1610 2102 link_set_out_status(link, status, AV_NOPTS_VALUE);
1611
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2102 times.
 2102 while (ff_framequeue_queued_frames(&li->fifo)) {
1612 ✗ AVFrame *frame = ff_framequeue_take(&li->fifo);
1613 ✗ av_frame_free(&frame);
1614 }
1615
2/2
✓ Branch 0 taken 2101 times.
✓ Branch 1 taken 1 times.
 2102 if (!li->status_in)
1616 2101 li->status_in = status;
1617 }
1618
1619 1069727 int ff_outlink_get_status(AVFilterLink *link)
1620 {
1621 1069727 FilterLinkInternal * const li = ff_link_internal(link);
1622 1069727 return li->status_in;
1623 }
1624
1625 1478 int ff_inoutlink_check_flow(AVFilterLink *inlink, AVFilterLink *outlink)
1626 {
1627 1478 FilterLinkInternal * const li_in = ff_link_internal(inlink);
1628
1/2
✓ Branch 1 taken 887 times.
✗ Branch 2 not taken.
 2365 return ff_outlink_frame_wanted(outlink) ||
1629
2/2
✓ Branch 0 taken 887 times.
✓ Branch 1 taken 591 times.
 2365 ff_inlink_check_available_frame(inlink) ||
1630
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 860 times.
 887 li_in->status_out;
1631 }
1632
1633
1634 ✗ const AVClass *avfilter_get_class(void)
1635 {
1636 ✗ return &avfilter_class;
1637 }
1638
1639 ✗ int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link,
1640 int default_pool_size)
1641 {
1642 ✗ FilterLink *l = ff_filter_link(link);
1643 AVHWFramesContext *frames;
1644
1645 // Must already be set by caller.
1646 ✗ av_assert0(l->hw_frames_ctx);
1647
1648 ✗ frames = (AVHWFramesContext*)l->hw_frames_ctx->data;
1649
1650 ✗ if (frames->initial_pool_size == 0) {
1651 // Dynamic allocation is necessarily supported.
1652 ✗ } else if (avctx->extra_hw_frames >= 0) {
1653 ✗ frames->initial_pool_size += avctx->extra_hw_frames;
1654 } else {
1655 ✗ frames->initial_pool_size = default_pool_size;
1656 }
1657
1658 ✗ return 0;
1659 }
1660
1661 387148 int ff_outlink_frame_wanted(AVFilterLink *link)
1662 {
1663 387148 FilterLinkInternal * const li = ff_link_internal(link);
1664 387148 return li->frame_wanted_out;
1665 }
1666
1667 4180 int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func,
1668 void *arg, int *ret, int nb_jobs)
1669 {
1670 4180 return fffilterctx(ctx)->execute(ctx, func, arg, ret, nb_jobs);
1671 }
1672