FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/avfilter.c
Date: 2026-05-01 22:15:40
Exec Total Coverage
Lines: 677 848 79.8%
Functions: 59 66 89.4%
Branches: 364 510 71.4%
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 1690247 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 1690247 }
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 570 static int append_pad(unsigned *count, AVFilterPad **pads,
101 AVFilterLink ***links, AVFilterPad *newpad)
102 {
103 AVFilterLink **newlinks;
104 AVFilterPad *newpads;
105 570 unsigned idx = *count;
106
107 570 newpads = av_realloc_array(*pads, idx + 1, sizeof(*newpads));
108 570 newlinks = av_realloc_array(*links, idx + 1, sizeof(*newlinks));
109
1/2
✓ Branch 0 taken 570 times.
✗ Branch 1 not taken.
 570 if (newpads)
110 570 *pads = newpads;
111
1/2
✓ Branch 0 taken 570 times.
✗ Branch 1 not taken.
 570 if (newlinks)
112 570 *links = newlinks;
113
2/4
✓ Branch 0 taken 570 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 570 times.
 570 if (!newpads || !newlinks) {
114 ✗ if (newpad->flags & AVFILTERPAD_FLAG_FREE_NAME)
115 ✗ av_freep(&newpad->name);
116 ✗ return AVERROR(ENOMEM);
117 }
118
119 570 memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
120 570 (*links)[idx] = NULL;
121
122 570 (*count)++;
123
124 570 return 0;
125 }
126
127 283 int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
128 {
129 283 return append_pad(&f->nb_inputs, &f->input_pads, &f->inputs, p);
130 }
131
132 264 int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
133 {
134 264 p->flags |= AVFILTERPAD_FLAG_FREE_NAME;
135 264 return ff_append_inpad(f, p);
136 }
137
138 287 int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
139 {
140 287 return append_pad(&f->nb_outputs, &f->output_pads, &f->outputs, p);
141 }
142
143 146 int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
144 {
145 146 p->flags |= AVFILTERPAD_FLAG_FREE_NAME;
146 146 return ff_append_outpad(f, p);
147 }
148
149 47414 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 47414 times.
 47414 av_assert0(src->graph);
156
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47414 times.
 47414 av_assert0(dst->graph);
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47414 times.
 47414 av_assert0(src->graph == dst->graph);
158
159
2/4
✓ Branch 0 taken 47414 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 47414 times.
✗ Branch 3 not taken.
 47414 if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
160
2/4
✓ Branch 0 taken 47414 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 47414 times.
 47414 src->outputs[srcpad] || dst->inputs[dstpad])
161 ✗ return AVERROR(EINVAL);
162
163
1/2
✓ Branch 1 taken 47414 times.
✗ Branch 2 not taken.
 47414 if (!(fffilterctx(src)->state_flags & AV_CLASS_STATE_INITIALIZED) ||
164
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47414 times.
 47414 !(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 47414 times.
 47414 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 47414 li = av_mallocz(sizeof(*li));
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47414 times.
 47414 if (!li)
179 ✗ return AVERROR(ENOMEM);
180 47414 link = &li->l.pub;
181
182 47414 src->outputs[srcpad] = dst->inputs[dstpad] = link;
183
184 47414 link->src = src;
185 47414 link->dst = dst;
186 47414 link->srcpad = &src->output_pads[srcpad];
187 47414 link->dstpad = &dst->input_pads[dstpad];
188 47414 link->type = src->output_pads[srcpad].type;
189 47414 li->l.graph = src->graph;
190 av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
191 47414 link->format = -1;
192 47414 link->colorspace = AVCOL_SPC_UNSPECIFIED;
193 47414 ff_framequeue_init(&li->fifo, &fffiltergraph(src->graph)->frame_queues);
194
195 47414 return 0;
196 }
197
198 47546 static void link_free(AVFilterLink **link)
199 {
200 FilterLinkInternal *li;
201
202
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47546 times.
 47546 if (!*link)
203 ✗ return;
204 47546 li = ff_link_internal(*link);
205
206 47546 ff_framequeue_free(&li->fifo);
207 47546 ff_frame_pool_uninit(&li->frame_pool);
208 47546 av_channel_layout_uninit(&(*link)->ch_layout);
209 47546 av_frame_side_data_free(&(*link)->side_data, &(*link)->nb_side_data);
210
211 47546 av_buffer_unref(&li->l.hw_frames_ctx);
212
213 47546 av_freep(link);
214 }
215
216 1701785 static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
217 {
218 1701785 AVFilterLink *const link = &li->l.pub;
219
220
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1701780 times.
 1701785 if (pts == AV_NOPTS_VALUE)
221 5 return;
222 1701780 li->l.current_pts = pts;
223 1701780 li->l.current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
224 /* TODO use duration */
225
3/4
✓ Branch 0 taken 1701780 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 458944 times.
✓ Branch 3 taken 1242836 times.
 1701780 if (li->l.graph && li->age_index >= 0)
226 458944 ff_avfilter_graph_update_heap(li->l.graph, li);
227 }
228
229 4219439 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
230 {
231 4219439 FFFilterContext *ctxi = fffilterctx(filter);
232 4219439 ctxi->ready = FFMAX(ctxi->ready, priority);
233 4219439 }
234
235 /**
236 * Clear frame_blocked_in on all outputs.
237 * This is necessary whenever something changes on input.
238 */
239 2518234 static void filter_unblock(AVFilterContext *filter)
240 {
241 unsigned i;
242
243
2/2
✓ Branch 0 taken 2059398 times.
✓ Branch 1 taken 2518234 times.
 4577632 for (i = 0; i < filter->nb_outputs; i++) {
244 2059398 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
245 2059398 li->frame_blocked_in = 0;
246 }
247 2518234 }
248
249
250 19702 void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
251 {
252 19702 FilterLinkInternal * const li = ff_link_internal(link);
253
254
2/2
✓ Branch 0 taken 5623 times.
✓ Branch 1 taken 14079 times.
 19702 if (li->status_in == status)
255 5623 return;
256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14079 times.
 14079 av_assert0(!li->status_in);
257 14079 li->status_in = status;
258 14079 li->status_in_pts = pts;
259 14079 li->frame_wanted_out = 0;
260 14079 li->frame_blocked_in = 0;
261 14079 filter_unblock(link->dst);
262 14079 ff_filter_set_ready(link->dst, 200);
263 }
264
265 /**
266 * Set the status field of a link from the destination filter.
267 * The pts should probably be left unset (AV_NOPTS_VALUE).
268 */
269 8588 static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
270 {
271 8588 FilterLinkInternal * const li = ff_link_internal(link);
272
273
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8588 times.
 8588 av_assert0(!li->frame_wanted_out);
274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8588 times.
 8588 av_assert0(!li->status_out);
275 8588 li->status_out = status;
276
2/2
✓ Branch 0 taken 6073 times.
✓ Branch 1 taken 2515 times.
 8588 if (pts != AV_NOPTS_VALUE)
277 6073 update_link_current_pts(li, pts);
278 8588 filter_unblock(link->dst);
279 8588 ff_filter_set_ready(link->src, 200);
280 8588 }
281
282 1280 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
283 unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
284 {
285 int ret;
286 1280 unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
287
288 1280 av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
289 "between the filter '%s' and the filter '%s'\n",
290 1280 filt->name, link->src->name, link->dst->name);
291
292 1280 link->dst->inputs[dstpad_idx] = NULL;
293
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1280 times.
 1280 if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
294 /* failed to link output filter to new filter */
295 ✗ link->dst->inputs[dstpad_idx] = link;
296 ✗ return ret;
297 }
298
299 /* re-hookup the link to the new destination filter we inserted */
300 1280 link->dst = filt;
301 1280 link->dstpad = &filt->input_pads[filt_srcpad_idx];
302 1280 filt->inputs[filt_srcpad_idx] = link;
303
304 /* if any information on supported media formats already exists on the
305 * link, we need to preserve that */
306
1/2
✓ Branch 0 taken 1280 times.
✗ Branch 1 not taken.
 1280 if (link->outcfg.formats)
307 1280 ff_formats_changeref(&link->outcfg.formats,
308 1280 &filt->outputs[filt_dstpad_idx]->outcfg.formats);
309
2/2
✓ Branch 0 taken 632 times.
✓ Branch 1 taken 648 times.
 1280 if (link->outcfg.color_spaces)
310 632 ff_formats_changeref(&link->outcfg.color_spaces,
311 632 &filt->outputs[filt_dstpad_idx]->outcfg.color_spaces);
312
2/2
✓ Branch 0 taken 632 times.
✓ Branch 1 taken 648 times.
 1280 if (link->outcfg.color_ranges)
313 632 ff_formats_changeref(&link->outcfg.color_ranges,
314 632 &filt->outputs[filt_dstpad_idx]->outcfg.color_ranges);
315
2/2
✓ Branch 0 taken 632 times.
✓ Branch 1 taken 648 times.
 1280 if (link->outcfg.alpha_modes)
316 632 ff_formats_changeref(&link->outcfg.alpha_modes,
317 632 &filt->outputs[filt_dstpad_idx]->outcfg.alpha_modes);
318
2/2
✓ Branch 0 taken 648 times.
✓ Branch 1 taken 632 times.
 1280 if (link->outcfg.samplerates)
319 648 ff_formats_changeref(&link->outcfg.samplerates,
320 648 &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
321
2/2
✓ Branch 0 taken 648 times.
✓ Branch 1 taken 632 times.
 1280 if (link->outcfg.channel_layouts)
322 648 ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
323 648 &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
324
325 1280 return 0;
326 }
327
328 45424 int ff_filter_config_links(AVFilterContext *filter)
329 {
330 int (*config_link)(AVFilterLink *);
331 unsigned i;
332 int ret;
333
334
2/2
✓ Branch 0 taken 37177 times.
✓ Branch 1 taken 45420 times.
 82597 for (i = 0; i < filter->nb_inputs; i ++) {
335 37177 AVFilterLink *link = filter->inputs[i];
336 AVFilterLink *inlink;
337 37177 FilterLinkInternal *li = ff_link_internal(link);
338 FilterLinkInternal *li_in;
339
340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37177 times.
 37177 if (!link) continue;
341
2/4
✓ Branch 0 taken 37177 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 37177 times.
 37177 if (!link->src || !link->dst) {
342 ✗ av_log(filter, AV_LOG_ERROR,
343 "Not all input and output are properly linked (%d).\n", i);
344 ✗ return AVERROR(EINVAL);
345 }
346
347
2/2
✓ Branch 0 taken 28730 times.
✓ Branch 1 taken 8447 times.
 37177 inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
348
2/2
✓ Branch 0 taken 28730 times.
✓ Branch 1 taken 8447 times.
 37177 li_in = inlink ? ff_link_internal(inlink) : NULL;
349 37177 li->l.current_pts =
350 37177 li->l.current_pts_us = AV_NOPTS_VALUE;
351
352
3/4
✓ Branch 0 taken 111 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 37064 times.
✗ Branch 3 not taken.
 37177 switch (li->init_state) {
353 111 case AVLINK_INIT:
354 111 continue;
355 2 case AVLINK_STARTINIT:
356 2 av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
357 2 return 0;
358 37064 case AVLINK_UNINIT:
359 37064 li->init_state = AVLINK_STARTINIT;
360
361
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 37063 times.
 37064 if ((ret = ff_filter_config_links(link->src)) < 0)
362 1 return ret;
363
364
2/2
✓ Branch 0 taken 19422 times.
✓ Branch 1 taken 17641 times.
 37063 if (!(config_link = link->srcpad->config_props)) {
365
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19422 times.
 19422 if (link->src->nb_inputs != 1) {
366 ✗ av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
367 "with more than one input "
368 "must set config_props() "
369 "callbacks on all outputs\n");
370 ✗ return AVERROR(EINVAL);
371 }
372 }
373
374 /* Copy side data before link->srcpad->config_props() is called, so the filter
375 * may remove it for the next filter in the chain */
376
5/6
✓ Branch 0 taken 28650 times.
✓ Branch 1 taken 8413 times.
✓ Branch 2 taken 261 times.
✓ Branch 3 taken 28389 times.
✓ Branch 4 taken 261 times.
✗ Branch 5 not taken.
 37063 if (inlink && inlink->nb_side_data && !link->nb_side_data) {
377
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 261 times.
 531 for (int j = 0; j < inlink->nb_side_data; j++) {
378 270 ret = av_frame_side_data_clone(&link->side_data, &link->nb_side_data,
379 270 inlink->side_data[j], 0);
380
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 270 times.
 270 if (ret < 0) {
381 ✗ av_frame_side_data_free(&link->side_data, &link->nb_side_data);
382 ✗ return ret;
383 }
384 }
385 }
386
387
4/4
✓ Branch 0 taken 17641 times.
✓ Branch 1 taken 19422 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 17640 times.
 37063 if (config_link && (ret = config_link(link)) < 0) {
388 1 av_log(link->src, AV_LOG_ERROR,
389 "Failed to configure output pad on %s\n",
390 1 link->src->name);
391 1 return ret;
392 }
393
394
2/3
✓ Branch 0 taken 30993 times.
✓ Branch 1 taken 6069 times.
✗ Branch 2 not taken.
 37062 switch (link->type) {
395 30993 case AVMEDIA_TYPE_VIDEO:
396
3/4
✓ Branch 0 taken 23728 times.
✓ Branch 1 taken 7265 times.
✓ Branch 2 taken 23728 times.
✗ Branch 3 not taken.
 30993 if (!link->time_base.num && !link->time_base.den)
397
1/2
✓ Branch 0 taken 23728 times.
✗ Branch 1 not taken.
 23728 link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
398
399
4/4
✓ Branch 0 taken 26527 times.
✓ Branch 1 taken 4466 times.
✓ Branch 2 taken 16878 times.
✓ Branch 3 taken 9649 times.
 30993 if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
400 16878 link->sample_aspect_ratio = inlink ?
401
2/2
✓ Branch 0 taken 16863 times.
✓ Branch 1 taken 15 times.
 16878 inlink->sample_aspect_ratio : (AVRational){1,1};
402
403
2/2
✓ Branch 0 taken 23990 times.
✓ Branch 1 taken 7003 times.
 30993 if (inlink) {
404
3/4
✓ Branch 0 taken 23771 times.
✓ Branch 1 taken 219 times.
✓ Branch 2 taken 23771 times.
✗ Branch 3 not taken.
 23990 if (!li->l.frame_rate.num && !li->l.frame_rate.den)
405 23771 li->l.frame_rate = li_in->l.frame_rate;
406
2/2
✓ Branch 0 taken 16375 times.
✓ Branch 1 taken 7615 times.
 23990 if (!link->w)
407 16375 link->w = inlink->w;
408
2/2
✓ Branch 0 taken 16375 times.
✓ Branch 1 taken 7615 times.
 23990 if (!link->h)
409 16375 link->h = inlink->h;
410
2/4
✓ Branch 0 taken 7003 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7003 times.
 7003 } else if (!link->w || !link->h) {
411 ✗ av_log(link->src, AV_LOG_ERROR,
412 "Video source filters must set their output link's "
413 "width and height\n");
414 ✗ return AVERROR(EINVAL);
415 }
416 30993 break;
417
418 6069 case AVMEDIA_TYPE_AUDIO:
419
2/2
✓ Branch 0 taken 4659 times.
✓ Branch 1 taken 1410 times.
 6069 if (inlink) {
420
3/4
✓ Branch 0 taken 3138 times.
✓ Branch 1 taken 1521 times.
✓ Branch 2 taken 3138 times.
✗ Branch 3 not taken.
 4659 if (!link->time_base.num && !link->time_base.den)
421 3138 link->time_base = inlink->time_base;
422 }
423
424
3/4
✓ Branch 0 taken 83 times.
✓ Branch 1 taken 5986 times.
✓ Branch 2 taken 83 times.
✗ Branch 3 not taken.
 6069 if (!link->time_base.num && !link->time_base.den)
425 83 link->time_base = (AVRational) {1, link->sample_rate};
426 }
427
428
2/2
✓ Branch 0 taken 28649 times.
✓ Branch 1 taken 8413 times.
 37062 if (link->src->nb_inputs &&
429
1/2
✓ Branch 1 taken 28649 times.
✗ Branch 2 not taken.
 28649 !(fffilter(link->src->filter)->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
430 28649 FilterLink *l0 = ff_filter_link(link->src->inputs[0]);
431
432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28649 times.
 28649 av_assert0(!li->l.hw_frames_ctx &&
433 "should not be set by non-hwframe-aware filter");
434
435
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28649 times.
 28649 if (l0->hw_frames_ctx) {
436 ✗ li->l.hw_frames_ctx = av_buffer_ref(l0->hw_frames_ctx);
437 ✗ if (!li->l.hw_frames_ctx)
438 ✗ return AVERROR(ENOMEM);
439 }
440 }
441
442
2/2
✓ Branch 0 taken 4953 times.
✓ Branch 1 taken 32109 times.
 37062 if ((config_link = link->dstpad->config_props))
443
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4953 times.
 4953 if ((ret = config_link(link)) < 0) {
444 ✗ av_log(link->dst, AV_LOG_ERROR,
445 "Failed to configure input pad on %s\n",
446 ✗ link->dst->name);
447 ✗ return ret;
448 }
449
450 37062 li->init_state = AVLINK_INIT;
451 }
452 }
453
454 45420 return 0;
455 }
456
457 #ifdef TRACE
458 void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
459 {
460 if (link->type == AVMEDIA_TYPE_VIDEO) {
461 ff_tlog(ctx,
462 "link[%p s:%dx%d fmt:%s %s->%s]%s",
463 link, link->w, link->h,
464 av_get_pix_fmt_name(link->format),
465 link->src ? link->src->filter->name : "",
466 link->dst ? link->dst->filter->name : "",
467 end ? "\n" : "");
468 } else {
469 char buf[128];
470 av_channel_layout_describe(&link->ch_layout, buf, sizeof(buf));
471
472 ff_tlog(ctx,
473 "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
474 link, (int)link->sample_rate, buf,
475 av_get_sample_fmt_name(link->format),
476 link->src ? link->src->filter->name : "",
477 link->dst ? link->dst->filter->name : "",
478 end ? "\n" : "");
479 }
480 }
481 #endif
482
483 805893 int ff_request_frame(AVFilterLink *link)
484 {
485 805893 FilterLinkInternal * const li = ff_link_internal(link);
486
487 FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
488
489 av_assert1(!fffilter(link->dst->filter)->activate);
490
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 805884 times.
 805893 if (li->status_out)
491 9 return li->status_out;
492
2/2
✓ Branch 0 taken 6074 times.
✓ Branch 1 taken 799810 times.
 805884 if (li->status_in) {
493
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6074 times.
 6074 if (ff_framequeue_queued_frames(&li->fifo)) {
494 av_assert1(!li->frame_wanted_out);
495 av_assert1(fffilterctx(link->dst)->ready >= 300);
496 ✗ return 0;
497 } else {
498 /* Acknowledge status change. Filters using ff_request_frame() will
499 handle the change automatically. Filters can also check the
500 status directly but none do yet. */
501 6074 link_set_out_status(link, li->status_in, li->status_in_pts);
502 6074 return li->status_out;
503 }
504 }
505 799810 li->frame_wanted_out = 1;
506 799810 ff_filter_set_ready(link->src, 100);
507 799810 return 0;
508 }
509
510 6068 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
511 {
512 unsigned i;
513 6068 int64_t r = INT64_MAX;
514
515
2/2
✓ Branch 0 taken 6067 times.
✓ Branch 1 taken 6068 times.
 12135 for (i = 0; i < ctx->nb_inputs; i++) {
516 6067 FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
517
1/2
✓ Branch 0 taken 6067 times.
✗ Branch 1 not taken.
 6067 if (li->status_out == status)
518 6067 r = FFMIN(r, av_rescale_q(li->l.current_pts, ctx->inputs[i]->time_base, link_time_base));
519 }
520
2/2
✓ Branch 0 taken 6067 times.
✓ Branch 1 taken 1 times.
 6068 if (r < INT64_MAX)
521 6067 return r;
522 1 av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n");
523
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 for (i = 0; i < ctx->nb_inputs; i++) {
524 ✗ FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
525 ✗ r = FFMIN(r, av_rescale_q(li->status_in_pts, ctx->inputs[i]->time_base, link_time_base));
526 }
527
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (r < INT64_MAX)
528 ✗ return r;
529 1 return AV_NOPTS_VALUE;
530 }
531
532 806210 static int request_frame_to_filter(AVFilterLink *link)
533 {
534 806210 FilterLinkInternal * const li = ff_link_internal(link);
535 806210 int ret = -1;
536
537 FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);
538 /* Assume the filter is blocked, let the method clear it if not */
539 806210 li->frame_blocked_in = 1;
540
2/2
✓ Branch 0 taken 2047 times.
✓ Branch 1 taken 804163 times.
 806210 if (link->srcpad->request_frame)
541 2047 ret = link->srcpad->request_frame(link);
542
1/2
✓ Branch 0 taken 804163 times.
✗ Branch 1 not taken.
 804163 else if (link->src->inputs[0])
543 804163 ret = ff_request_frame(link->src->inputs[0]);
544
2/2
✓ Branch 0 taken 6068 times.
✓ Branch 1 taken 800142 times.
 806210 if (ret < 0) {
545
2/4
✓ Branch 0 taken 6068 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6068 times.
✗ Branch 3 not taken.
 6068 if (ret != AVERROR(EAGAIN) && ret != li->status_in)
546 6068 ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
547
1/2
✓ Branch 0 taken 6068 times.
✗ Branch 1 not taken.
 6068 if (ret == AVERROR_EOF)
548 6068 ret = 0;
549 }
550 806210 return ret;
551 }
552
553 static const char *const var_names[] = {
554 "t",
555 "n",
556 "w",
557 "h",
558 NULL
559 };
560
561 enum {
562 VAR_T,
563 VAR_N,
564 VAR_W,
565 VAR_H,
566 VAR_VARS_NB
567 };
568
569 6 static int set_enable_expr(FFFilterContext *ctxi, const char *expr)
570 {
571 6 AVFilterContext *ctx = &ctxi->p;
572 int ret;
573 char *expr_dup;
574 6 AVExpr *old = ctxi->enable;
575
576
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
577 ✗ av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
578 ✗ "with filter '%s'\n", ctx->filter->name);
579 ✗ return AVERROR_PATCHWELCOME;
580 }
581
582 6 expr_dup = av_strdup(expr);
583
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!expr_dup)
584 ✗ return AVERROR(ENOMEM);
585
586
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (!ctxi->var_values) {
587 6 ctxi->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctxi->var_values));
588
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!ctxi->var_values) {
589 ✗ av_free(expr_dup);
590 ✗ return AVERROR(ENOMEM);
591 }
592 }
593
594 6 ret = av_expr_parse(&ctxi->enable, expr_dup, var_names,
595 NULL, NULL, NULL, NULL, 0, ctx->priv);
596
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (ret < 0) {
597 ✗ av_log(ctx->priv, AV_LOG_ERROR,
598 "Error when evaluating the expression '%s' for enable\n",
599 expr_dup);
600 ✗ av_free(expr_dup);
601 ✗ return ret;
602 }
603
604 6 av_expr_free(old);
605 6 av_free(ctx->enable_str);
606 6 ctx->enable_str = expr_dup;
607 6 return 0;
608 }
609
610 ✗ int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
611 {
612 ✗ if(!strcmp(cmd, "ping")){
613 ✗ char local_res[256] = {0};
614
615 ✗ if (!res) {
616 ✗ res = local_res;
617 ✗ res_len = sizeof(local_res);
618 }
619 ✗ av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
620 ✗ if (res == local_res)
621 ✗ av_log(filter, AV_LOG_INFO, "%s", res);
622 ✗ return 0;
623 ✗ }else if(!strcmp(cmd, "enable")) {
624 ✗ return set_enable_expr(fffilterctx(filter), arg);
625 ✗ }else if (fffilter(filter->filter)->process_command) {
626 ✗ return fffilter(filter->filter)->process_command(filter, cmd, arg, res, res_len, flags);
627 }
628 ✗ return AVERROR(ENOSYS);
629 }
630
631 14974 unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
632 {
633
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14974 times.
 14974 return is_output ? fffilter(filter)->nb_outputs : fffilter(filter)->nb_inputs;
634 }
635
636 552 static const char *default_filter_name(void *filter_ctx)
637 {
638 552 AVFilterContext *ctx = filter_ctx;
639
1/2
✓ Branch 0 taken 552 times.
✗ Branch 1 not taken.
 552 return ctx->name ? ctx->name : ctx->filter->name;
640 }
641
642 57102 static void *filter_child_next(void *obj, void *prev)
643 {
644 57102 AVFilterContext *ctx = obj;
645
5/8
✓ Branch 0 taken 57096 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 57096 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 57096 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 57096 times.
✗ Branch 7 not taken.
 57102 if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
646 57096 return ctx->priv;
647 6 return NULL;
648 }
649
650 ✗ static const AVClass *filter_child_class_iterate(void **iter)
651 {
652 const AVFilter *f;
653
654 ✗ while ((f = av_filter_iterate(iter)))
655 ✗ if (f->priv_class)
656 ✗ return f->priv_class;
657
658 ✗ return NULL;
659 }
660
661 #define OFFSET(x) offsetof(AVFilterContext, x)
662 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
663 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
664 static const AVOption avfilter_options[] = {
665 { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
666 { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, .unit = "thread_type" },
667 { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
668 { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = TFLAGS },
669 { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
670 { .i64 = 0 }, 0, INT_MAX, FLAGS, .unit = "threads" },
671 {"auto", "autodetect a suitable number of threads to use", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, .flags = FLAGS, .unit = "threads"},
672 { "extra_hw_frames", "Number of extra hardware frames to allocate for the user",
673 OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
674 { NULL },
675 };
676
677 static const AVClass avfilter_class = {
678 .class_name = "AVFilter",
679 .item_name = default_filter_name,
680 .version = LIBAVUTIL_VERSION_INT,
681 .category = AV_CLASS_CATEGORY_FILTER,
682 .child_next = filter_child_next,
683 .child_class_iterate = filter_child_class_iterate,
684 .option = avfilter_options,
685 .state_flags_offset = offsetof(FFFilterContext, state_flags),
686 };
687
688 1277 static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg,
689 int *ret, int nb_jobs)
690 {
691 int i;
692
693
2/2
✓ Branch 0 taken 1277 times.
✓ Branch 1 taken 1277 times.
 2554 for (i = 0; i < nb_jobs; i++) {
694 1277 int r = func(ctx, arg, i, nb_jobs);
695
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1277 times.
 1277 if (ret)
696 ✗ ret[i] = r;
697 }
698 1277 return 0;
699 }
700
701 63893 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
702 {
703 FFFilterContext *ctx;
704 AVFilterContext *ret;
705 63893 const FFFilter *const fi = fffilter(filter);
706 63893 int preinited = 0;
707
708
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 63893 times.
 63893 if (!filter)
709 ✗ return NULL;
710
711 63893 ctx = av_mallocz(sizeof(*ctx));
712
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 63893 times.
 63893 if (!ctx)
713 ✗ return NULL;
714 63893 ret = &ctx->p;
715
716 63893 ret->av_class = &avfilter_class;
717 63893 ret->filter = filter;
718
1/2
✓ Branch 0 taken 63893 times.
✗ Branch 1 not taken.
 63893 ret->name = inst_name ? av_strdup(inst_name) : NULL;
719
2/2
✓ Branch 0 taken 57036 times.
✓ Branch 1 taken 6857 times.
 63893 if (fi->priv_size) {
720 57036 ret->priv = av_mallocz(fi->priv_size);
721
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 57036 times.
 57036 if (!ret->priv)
722 ✗ goto err;
723 }
724
2/2
✓ Branch 0 taken 13676 times.
✓ Branch 1 taken 50217 times.
 63893 if (fi->preinit) {
725
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13676 times.
 13676 if (fi->preinit(ret) < 0)
726 ✗ goto err;
727 13676 preinited = 1;
728 }
729
730 63893 av_opt_set_defaults(ret);
731
2/2
✓ Branch 0 taken 55777 times.
✓ Branch 1 taken 8116 times.
 63893 if (filter->priv_class) {
732 55777 *(const AVClass**)ret->priv = filter->priv_class;
733 55777 av_opt_set_defaults(ret->priv);
734 }
735
736 63893 ctx->execute = default_execute;
737
738 63893 ret->nb_inputs = fi->nb_inputs;
739
2/2
✓ Branch 0 taken 54139 times.
✓ Branch 1 taken 9754 times.
 63893 if (ret->nb_inputs ) {
740 54139 ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs));
741
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54139 times.
 54139 if (!ret->input_pads)
742 ✗ goto err;
743 54139 ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs));
744
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54139 times.
 54139 if (!ret->inputs)
745 ✗ goto err;
746 }
747
748 63893 ret->nb_outputs = fi->nb_outputs;
749
2/2
✓ Branch 0 taken 55442 times.
✓ Branch 1 taken 8451 times.
 63893 if (ret->nb_outputs) {
750 55442 ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 55442 times.
 55442 if (!ret->output_pads)
752 ✗ goto err;
753 55442 ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs));
754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 55442 times.
 55442 if (!ret->outputs)
755 ✗ goto err;
756 }
757
758 63893 return ret;
759
760 ✗ err:
761 ✗ if (preinited)
762 ✗ fi->uninit(ret);
763 ✗ av_freep(&ret->inputs);
764 ✗ av_freep(&ret->input_pads);
765 ✗ ret->nb_inputs = 0;
766 ✗ av_freep(&ret->outputs);
767 ✗ av_freep(&ret->output_pads);
768 ✗ ret->nb_outputs = 0;
769 ✗ av_freep(&ret->priv);
770 ✗ av_free(ret);
771 ✗ return NULL;
772 }
773
774 110251 static void free_link(AVFilterLink *link)
775 {
776
2/2
✓ Branch 0 taken 62705 times.
✓ Branch 1 taken 47546 times.
 110251 if (!link)
777 62705 return;
778
779
2/2
✓ Branch 0 taken 47414 times.
✓ Branch 1 taken 132 times.
 47546 if (link->src)
780 47414 link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
781
2/2
✓ Branch 0 taken 47414 times.
✓ Branch 1 taken 132 times.
 47546 if (link->dst)
782 47414 link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
783
784 47546 ff_formats_unref(&link->incfg.formats);
785 47546 ff_formats_unref(&link->outcfg.formats);
786 47546 ff_formats_unref(&link->incfg.color_spaces);
787 47546 ff_formats_unref(&link->outcfg.color_spaces);
788 47546 ff_formats_unref(&link->incfg.color_ranges);
789 47546 ff_formats_unref(&link->outcfg.color_ranges);
790 47546 ff_formats_unref(&link->incfg.alpha_modes);
791 47546 ff_formats_unref(&link->outcfg.alpha_modes);
792 47546 ff_formats_unref(&link->incfg.samplerates);
793 47546 ff_formats_unref(&link->outcfg.samplerates);
794 47546 ff_channel_layouts_unref(&link->incfg.channel_layouts);
795 47546 ff_channel_layouts_unref(&link->outcfg.channel_layouts);
796 47546 link_free(&link);
797 }
798
799 63893 void avfilter_free(AVFilterContext *filter)
800 {
801 FFFilterContext *ctxi;
802 int i;
803
804
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 63893 times.
 63893 if (!filter)
805 ✗ return;
806 63893 ctxi = fffilterctx(filter);
807
808
1/2
✓ Branch 0 taken 63893 times.
✗ Branch 1 not taken.
 63893 if (filter->graph)
809 63893 ff_filter_graph_remove_filter(filter->graph, filter);
810
811
2/2
✓ Branch 1 taken 49692 times.
✓ Branch 2 taken 14201 times.
 63893 if (fffilter(filter->filter)->uninit)
812 49692 fffilter(filter->filter)->uninit(filter);
813
814
2/2
✓ Branch 0 taken 54518 times.
✓ Branch 1 taken 63893 times.
 118411 for (i = 0; i < filter->nb_inputs; i++) {
815 54518 free_link(filter->inputs[i]);
816
2/2
✓ Branch 0 taken 264 times.
✓ Branch 1 taken 54254 times.
 54518 if (filter->input_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
817 264 av_freep(&filter->input_pads[i].name);
818 }
819
2/2
✓ Branch 0 taken 55733 times.
✓ Branch 1 taken 63893 times.
 119626 for (i = 0; i < filter->nb_outputs; i++) {
820 55733 free_link(filter->outputs[i]);
821
2/2
✓ Branch 0 taken 282 times.
✓ Branch 1 taken 55451 times.
 55733 if (filter->output_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
822 282 av_freep(&filter->output_pads[i].name);
823 }
824
825
2/2
✓ Branch 0 taken 55777 times.
✓ Branch 1 taken 8116 times.
 63893 if (filter->filter->priv_class)
826 55777 av_opt_free(filter->priv);
827
828 63893 av_buffer_unref(&filter->hw_device_ctx);
829
830 63893 av_freep(&filter->name);
831 63893 av_freep(&filter->input_pads);
832 63893 av_freep(&filter->output_pads);
833 63893 av_freep(&filter->inputs);
834 63893 av_freep(&filter->outputs);
835 63893 av_freep(&filter->priv);
836
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 63893 times.
 63893 while (ctxi->command_queue)
837 ✗ command_queue_pop(filter);
838 63893 av_opt_free(filter);
839 63893 av_expr_free(ctxi->enable);
840 63893 ctxi->enable = NULL;
841 63893 av_freep(&ctxi->var_values);
842 63893 av_free(filter);
843 }
844
845 19281 int ff_filter_get_nb_threads(AVFilterContext *ctx)
846 {
847
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19281 times.
 19281 if (ctx->nb_threads > 0)
848 ✗ return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
849 19281 return ctx->graph->nb_threads;
850 }
851
852 34203 int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
853 AVDictionary **options, const char *args)
854 {
855 34203 const AVOption *o = NULL;
856 int ret;
857 34203 int offset= -1;
858
859
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34203 times.
 34203 if (!args)
860 ✗ return 0;
861
862
2/2
✓ Branch 0 taken 58887 times.
✓ Branch 1 taken 34203 times.
 93090 while (*args) {
863 char *parsed_key, *value;
864 const char *key;
865 58887 const char *shorthand = NULL;
866 58887 int additional_flags = 0;
867
868
4/4
✓ Branch 0 taken 45761 times.
✓ Branch 1 taken 13126 times.
✓ Branch 3 taken 44479 times.
✓ Branch 4 taken 1282 times.
 58887 if (priv_class && (o = av_opt_next(&priv_class, o))) {
869
4/4
✓ Branch 0 taken 42709 times.
✓ Branch 1 taken 1770 times.
✓ Branch 2 taken 4564 times.
✓ Branch 3 taken 38145 times.
 44479 if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
870 6334 continue;
871 38145 offset = o->offset;
872 38145 shorthand = o->name;
873 }
874
875 52553 ret = av_opt_get_key_value(&args, "=", ":",
876 shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
877 &parsed_key, &value);
878
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 52553 times.
 52553 if (ret < 0) {
879 ✗ if (ret == AVERROR(EINVAL))
880 ✗ av_log(logctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
881 else
882 ✗ av_log(logctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
883 ✗ av_err2str(ret));
884 ✗ return ret;
885 }
886
2/2
✓ Branch 0 taken 27313 times.
✓ Branch 1 taken 25240 times.
 52553 if (*args)
887 27313 args++;
888
2/2
✓ Branch 0 taken 31548 times.
✓ Branch 1 taken 21005 times.
 52553 if (parsed_key) {
889 31548 key = parsed_key;
890 31548 additional_flags = AV_DICT_DONT_STRDUP_KEY;
891 31548 priv_class = NULL; /* reject all remaining shorthand */
892 } else {
893 21005 key = shorthand;
894 }
895
896 52553 av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
897
898 52553 av_dict_set(options, key, value,
899 additional_flags | AV_DICT_DONT_STRDUP_VAL | AV_DICT_MULTIKEY);
900 }
901
902 34203 return 0;
903 }
904
905 ✗ int ff_filter_process_command(AVFilterContext *ctx, const char *cmd,
906 const char *arg, char *res, int res_len, int flags)
907 {
908 const AVOption *o;
909
910 ✗ if (!ctx->filter->priv_class)
911 ✗ return 0;
912 ✗ o = av_opt_find2(ctx->priv, cmd, NULL, AV_OPT_FLAG_RUNTIME_PARAM | AV_OPT_FLAG_FILTERING_PARAM, AV_OPT_SEARCH_CHILDREN, NULL);
913 ✗ if (!o)
914 ✗ return AVERROR(ENOSYS);
915 ✗ return av_opt_set(ctx->priv, cmd, arg, 0);
916 }
917
918 63893 int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
919 {
920 63893 FFFilterContext *ctxi = fffilterctx(ctx);
921 63893 int ret = 0;
922
923
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 63893 times.
 63893 if (ctxi->state_flags & AV_CLASS_STATE_INITIALIZED) {
924 ✗ av_log(ctx, AV_LOG_ERROR, "Filter already initialized\n");
925 ✗ return AVERROR(EINVAL);
926 }
927
928 63893 ret = av_opt_set_dict2(ctx, options, AV_OPT_SEARCH_CHILDREN);
929
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 63893 times.
 63893 if (ret < 0) {
930 ✗ av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
931 ✗ return ret;
932 }
933
934
2/2
✓ Branch 0 taken 1244 times.
✓ Branch 1 taken 62649 times.
 63893 if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
935
2/2
✓ Branch 0 taken 153 times.
✓ Branch 1 taken 1091 times.
 1244 ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
936
1/2
✓ Branch 1 taken 153 times.
✗ Branch 2 not taken.
 153 fffiltergraph(ctx->graph)->thread_execute) {
937 153 ctx->thread_type = AVFILTER_THREAD_SLICE;
938 153 ctxi->execute = fffiltergraph(ctx->graph)->thread_execute;
939 } else {
940 63740 ctx->thread_type = 0;
941 }
942
943
2/2
✓ Branch 1 taken 50514 times.
✓ Branch 2 taken 13379 times.
 63893 if (fffilter(ctx->filter)->init)
944 50514 ret = fffilter(ctx->filter)->init(ctx);
945
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 63893 times.
 63893 if (ret < 0)
946 ✗ return ret;
947
948
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 63887 times.
 63893 if (ctx->enable_str) {
949 6 ret = set_enable_expr(ctxi, ctx->enable_str);
950
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (ret < 0)
951 ✗ return ret;
952 }
953
954 63893 ctxi->state_flags |= AV_CLASS_STATE_INITIALIZED;
955
956 63893 return 0;
957 }
958
959 20918 int avfilter_init_str(AVFilterContext *filter, const char *args)
960 {
961 20918 AVDictionary *options = NULL;
962 const AVDictionaryEntry *e;
963 20918 int ret = 0;
964
965
3/4
✓ Branch 0 taken 10444 times.
✓ Branch 1 taken 10474 times.
✓ Branch 2 taken 10444 times.
✗ Branch 3 not taken.
 20918 if (args && *args) {
966 10444 ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args);
967
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10444 times.
 10444 if (ret < 0)
968 ✗ goto fail;
969 }
970
971 20918 ret = avfilter_init_dict(filter, &options);
972
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20918 times.
 20918 if (ret < 0)
973 ✗ goto fail;
974
975
1/2
✓ Branch 1 taken 20918 times.
✗ Branch 2 not taken.
 20918 if ((e = av_dict_iterate(options, NULL))) {
976 ✗ av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
977 ✗ ret = AVERROR_OPTION_NOT_FOUND;
978 ✗ goto fail;
979 }
980
981 20918 fail:
982 20918 av_dict_free(&options);
983
984 20918 return ret;
985 }
986
987 15255 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
988 {
989 15255 return pads[pad_idx].name;
990 }
991
992 30858 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
993 {
994 30858 return pads[pad_idx].type;
995 }
996
997 ✗ AVBufferRef *avfilter_link_get_hw_frames_ctx(AVFilterLink *link)
998 {
999 ✗ FilterLink *plink = ff_filter_link(link);
1000 ✗ if (plink->hw_frames_ctx)
1001 ✗ return av_buffer_ref(plink->hw_frames_ctx);
1002
1003 ✗ return NULL;
1004 }
1005
1006 784865 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
1007 {
1008 784865 return ff_filter_frame(link->dst->outputs[0], frame);
1009 }
1010
1011 /**
1012 * Evaluate the timeline expression of the link for the time and properties
1013 * of the frame.
1014 * @return >0 if enabled, 0 if disabled
1015 * @note It does not update link->dst->is_disabled.
1016 */
1017 2490314 static int evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1018 {
1019 2490314 FilterLink *l = ff_filter_link(link);
1020 2490314 AVFilterContext *dstctx = link->dst;
1021 2490314 FFFilterContext *dsti = fffilterctx(dstctx);
1022 2490314 int64_t pts = frame->pts;
1023
1024
2/2
✓ Branch 0 taken 2490116 times.
✓ Branch 1 taken 198 times.
 2490314 if (!dstctx->enable_str)
1025 2490116 return 1;
1026
1027 198 dsti->var_values[VAR_N] = l->frame_count_out;
1028
1/2
✓ Branch 0 taken 198 times.
✗ Branch 1 not taken.
 198 dsti->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1029 198 dsti->var_values[VAR_W] = link->w;
1030 198 dsti->var_values[VAR_H] = link->h;
1031
1032 198 return fabs(av_expr_eval(dsti->enable, dsti->var_values, NULL)) >= 0.5;
1033 }
1034
1035 805320 static int filter_frame_framed(AVFilterLink *link, AVFrame *frame)
1036 {
1037 805320 FilterLink *l = ff_filter_link(link);
1038 int (*filter_frame)(AVFilterLink *, AVFrame *);
1039 805320 AVFilterContext *dstctx = link->dst;
1040 805320 AVFilterPad *dst = link->dstpad;
1041 int ret;
1042
1043
2/2
✓ Branch 0 taken 784856 times.
✓ Branch 1 taken 20464 times.
 805320 if (!(filter_frame = dst->filter_frame))
1044 784856 filter_frame = default_filter_frame;
1045
1046
2/2
✓ Branch 0 taken 2993 times.
✓ Branch 1 taken 802327 times.
 805320 if (dst->flags & AVFILTERPAD_FLAG_NEEDS_WRITABLE) {
1047 2993 ret = ff_inlink_make_frame_writable(link, &frame);
1048
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2993 times.
 2993 if (ret < 0)
1049 ✗ goto fail;
1050 }
1051
1052 805320 ff_inlink_process_commands(link, frame);
1053 805320 dstctx->is_disabled = !evaluate_timeline_at_frame(link, frame);
1054
1055
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 805301 times.
 805320 if (dstctx->is_disabled &&
1056
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 10 times.
 19 (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
1057 9 filter_frame = default_filter_frame;
1058 805320 ret = filter_frame(link, frame);
1059 805320 l->frame_count_out++;
1060 805320 return ret;
1061
1062 ✗ fail:
1063 ✗ av_frame_free(&frame);
1064 ✗ return ret;
1065 }
1066
1067 1690247 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1068 {
1069 1690247 FilterLinkInternal * const li = ff_link_internal(link);
1070 int ret;
1071 1690247 FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); tlog_ref(NULL, frame, 1);
1072
1073 /* Consistency checks */
1074
2/2
✓ Branch 0 taken 584971 times.
✓ Branch 1 taken 1105276 times.
 1690247 if (link->type == AVMEDIA_TYPE_VIDEO) {
1075
2/2
✓ Branch 0 taken 435242 times.
✓ Branch 1 taken 149729 times.
 584971 if (strcmp(link->dst->filter->name, "buffersink") &&
1076
2/2
✓ Branch 0 taken 259230 times.
✓ Branch 1 taken 176012 times.
 435242 strcmp(link->dst->filter->name, "format") &&
1077
2/2
✓ Branch 0 taken 259203 times.
✓ Branch 1 taken 27 times.
 259230 strcmp(link->dst->filter->name, "idet") &&
1078
2/2
✓ Branch 0 taken 167894 times.
✓ Branch 1 taken 91309 times.
 259203 strcmp(link->dst->filter->name, "null") &&
1079
2/2
✓ Branch 0 taken 57460 times.
✓ Branch 1 taken 110434 times.
 167894 strcmp(link->dst->filter->name, "scale") &&
1080
1/2
✓ Branch 0 taken 57460 times.
✗ Branch 1 not taken.
 57460 strcmp(link->dst->filter->name, "libplacebo")) {
1081 av_assert1(frame->format == link->format);
1082 av_assert1(frame->width == link->w);
1083 av_assert1(frame->height == link->h);
1084 57460 if (av_pix_fmt_desc_get(link->format)->flags & AV_PIX_FMT_FLAG_ALPHA)
1085 av_assert1(frame->alpha_mode == link->alpha_mode);
1086 }
1087 } else {
1088
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1105276 times.
 1105276 if (frame->format != link->format) {
1089 ✗ av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1090 ✗ goto error;
1091 }
1092
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1105276 times.
 1105276 if (av_channel_layout_compare(&frame->ch_layout, &link->ch_layout)) {
1093 ✗ av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1094 ✗ goto error;
1095 }
1096
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1105276 times.
 1105276 if (frame->sample_rate != link->sample_rate) {
1097 ✗ av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1098 ✗ goto error;
1099 }
1100
1101 1105276 frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1102 link->time_base);
1103 }
1104
1105 1690247 li->frame_blocked_in = li->frame_wanted_out = 0;
1106 1690247 li->l.frame_count_in++;
1107 1690247 li->l.sample_count_in += frame->nb_samples;
1108 1690247 filter_unblock(link->dst);
1109 1690247 ret = ff_framequeue_add(&li->fifo, frame);
1110
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1690247 times.
 1690247 if (ret < 0) {
1111 ✗ av_frame_free(&frame);
1112 ✗ return ret;
1113 }
1114 1690247 ff_filter_set_ready(link->dst, 300);
1115 1690247 return 0;
1116
1117 ✗ error:
1118 ✗ av_frame_free(&frame);
1119 ✗ return AVERROR_PATCHWELCOME;
1120 }
1121
1122 2411494 static int samples_ready(FilterLinkInternal *link, unsigned min)
1123 {
1124
2/2
✓ Branch 1 taken 805454 times.
✓ Branch 2 taken 1606040 times.
 3216948 return ff_framequeue_queued_frames(&link->fifo) &&
1125
2/2
✓ Branch 1 taken 135 times.
✓ Branch 2 taken 805319 times.
 805454 (ff_framequeue_queued_samples(&link->fifo) >= min ||
1126
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 134 times.
 135 link->status_in);
1127 }
1128
1129 2929 static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max,
1130 AVFrame **rframe)
1131 {
1132 2929 FilterLink *l = &li->l;
1133 2929 AVFilterLink *link = &l->pub;
1134 AVFrame *frame0, *frame, *buf;
1135 unsigned nb_samples, nb_frames, i, p;
1136 int ret;
1137
1138 /* Note: this function relies on no format changes and must only be
1139 called with enough samples. */
1140 av_assert1(samples_ready(li, l->min_samples));
1141 2929 frame0 = frame = ff_framequeue_peek(&li->fifo, 0);
1142
6/6
✓ Branch 0 taken 1414 times.
✓ Branch 1 taken 1515 times.
✓ Branch 2 taken 1300 times.
✓ Branch 3 taken 114 times.
✓ Branch 4 taken 1024 times.
✓ Branch 5 taken 276 times.
 2929 if (!li->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1143 1024 *rframe = ff_framequeue_take(&li->fifo);
1144 1024 return 0;
1145 }
1146 1905 nb_frames = 0;
1147 1905 nb_samples = 0;
1148 while (1) {
1149
2/2
✓ Branch 0 taken 1519 times.
✓ Branch 1 taken 1461 times.
 2980 if (nb_samples + frame->nb_samples > max) {
1150
2/2
✓ Branch 0 taken 1518 times.
✓ Branch 1 taken 1 times.
 1519 if (nb_samples < min)
1151 1518 nb_samples = max;
1152 1519 break;
1153 }
1154 1461 nb_samples += frame->nb_samples;
1155 1461 nb_frames++;
1156
2/2
✓ Branch 1 taken 386 times.
✓ Branch 2 taken 1075 times.
 1461 if (nb_frames == ff_framequeue_queued_frames(&li->fifo))
1157 386 break;
1158 1075 frame = ff_framequeue_peek(&li->fifo, nb_frames);
1159 }
1160
1161 1905 buf = ff_get_audio_buffer(link, nb_samples);
1162
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1905 times.
 1905 if (!buf)
1163 ✗ return AVERROR(ENOMEM);
1164 1905 ret = av_frame_copy_props(buf, frame0);
1165
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1905 times.
 1905 if (ret < 0) {
1166 ✗ av_frame_free(&buf);
1167 ✗ return ret;
1168 }
1169
1170 1905 p = 0;
1171
2/2
✓ Branch 0 taken 1461 times.
✓ Branch 1 taken 1905 times.
 3366 for (i = 0; i < nb_frames; i++) {
1172 1461 frame = ff_framequeue_take(&li->fifo);
1173 1461 av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1174 1461 frame->nb_samples, link->ch_layout.nb_channels, link->format);
1175 1461 p += frame->nb_samples;
1176 1461 av_frame_free(&frame);
1177 }
1178
2/2
✓ Branch 0 taken 1518 times.
✓ Branch 1 taken 387 times.
 1905 if (p < nb_samples) {
1179 1518 unsigned n = nb_samples - p;
1180 1518 frame = ff_framequeue_peek(&li->fifo, 0);
1181 1518 av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1182 1518 link->ch_layout.nb_channels, link->format);
1183 1518 ff_framequeue_skip_samples(&li->fifo, n, link->time_base);
1184 }
1185
1186 1905 *rframe = buf;
1187 1905 return 0;
1188 }
1189
1190 805320 static int filter_frame_to_filter(AVFilterLink *link)
1191 {
1192 805320 FilterLinkInternal * const li = ff_link_internal(link);
1193 805320 AVFrame *frame = NULL;
1194 805320 AVFilterContext *dst = link->dst;
1195 int ret;
1196
1197 av_assert1(ff_framequeue_queued_frames(&li->fifo));
1198 1610640 ret = li->l.min_samples ?
1199
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 805284 times.
 805320 ff_inlink_consume_samples(link, li->l.min_samples, li->l.max_samples, &frame) :
1200 805284 ff_inlink_consume_frame(link, &frame);
1201 av_assert1(ret);
1202
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 805320 times.
 805320 if (ret < 0) {
1203 av_assert1(!frame);
1204 ✗ return ret;
1205 }
1206 /* The filter will soon have received a new frame, that may allow it to
1207 produce one or more: unblock its outputs. */
1208 805320 filter_unblock(dst);
1209 /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1210 before the frame; filter_frame_framed() will re-increment it. */
1211 805320 li->l.frame_count_out--;
1212 805320 ret = filter_frame_framed(link, frame);
1213
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 805320 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 805320 if (ret < 0 && ret != li->status_out) {
1214 ✗ link_set_out_status(link, ret, AV_NOPTS_VALUE);
1215 } else {
1216 /* Run once again, to see if several frames were available, or if
1217 the input status has also changed, or any other reason. */
1218 805320 ff_filter_set_ready(dst, 300);
1219 }
1220 805320 return ret;
1221 }
1222
1223 6074 static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
1224 {
1225 6074 AVFilterLink *in = &li_in->l.pub;
1226 6074 unsigned out = 0, progress = 0;
1227 int ret;
1228
1229
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6074 times.
 6074 av_assert0(!li_in->status_out);
1230
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6073 times.
 6074 if (!filter->nb_outputs) {
1231 /* not necessary with the current API and sinks */
1232 1 return 0;
1233 }
1234
2/2
✓ Branch 0 taken 6073 times.
✓ Branch 1 taken 6073 times.
 12146 while (!li_in->status_out) {
1235 6073 FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1236
1237
1/2
✓ Branch 0 taken 6073 times.
✗ Branch 1 not taken.
 6073 if (!li_out->status_in) {
1238 6073 progress++;
1239 6073 ret = request_frame_to_filter(filter->outputs[out]);
1240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6073 times.
 6073 if (ret < 0)
1241 ✗ return ret;
1242 }
1243
1/2
✓ Branch 0 taken 6073 times.
✗ Branch 1 not taken.
 6073 if (++out == filter->nb_outputs) {
1244
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6073 times.
 6073 if (!progress) {
1245 /* Every output already closed: input no longer interesting
1246 (example: overlay in shortest mode, other input closed). */
1247 ✗ link_set_out_status(in, li_in->status_in, li_in->status_in_pts);
1248 ✗ return 0;
1249 }
1250 6073 progress = 0;
1251 6073 out = 0;
1252 }
1253 }
1254 6073 ff_filter_set_ready(filter, 200);
1255 6073 return 0;
1256 }
1257
1258 2418712 static int filter_activate_default(AVFilterContext *filter)
1259 {
1260 unsigned i;
1261 2418712 int nb_eofs = 0;
1262
1263
2/2
✓ Branch 0 taken 2418679 times.
✓ Branch 1 taken 2418712 times.
 4837391 for (i = 0; i < filter->nb_outputs; i++)
1264 2418679 nb_eofs += ff_outlink_get_status(filter->outputs[i]) == AVERROR_EOF;
1265
4/4
✓ Branch 0 taken 2418679 times.
✓ Branch 1 taken 33 times.
✓ Branch 2 taken 6949 times.
✓ Branch 3 taken 2411730 times.
 2418712 if (filter->nb_outputs && nb_eofs == filter->nb_outputs) {
1266
2/2
✓ Branch 0 taken 6949 times.
✓ Branch 1 taken 6949 times.
 13898 for (int j = 0; j < filter->nb_inputs; j++)
1267 6949 ff_inlink_set_status(filter->inputs[j], AVERROR_EOF);
1268 6949 return 0;
1269 }
1270
1271
2/2
✓ Branch 0 taken 2411494 times.
✓ Branch 1 taken 1606443 times.
 4017937 for (i = 0; i < filter->nb_inputs; i++) {
1272 2411494 FilterLinkInternal *li = ff_link_internal(filter->inputs[i]);
1273
2/2
✓ Branch 1 taken 805320 times.
✓ Branch 2 taken 1606174 times.
 2411494 if (samples_ready(li, li->l.min_samples)) {
1274 805320 return filter_frame_to_filter(filter->inputs[i]);
1275 }
1276 }
1277
2/2
✓ Branch 0 taken 1606174 times.
✓ Branch 1 taken 1600369 times.
 3206543 for (i = 0; i < filter->nb_inputs; i++) {
1278 1606174 FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1279
4/4
✓ Branch 0 taken 6103 times.
✓ Branch 1 taken 1600071 times.
✓ Branch 2 taken 6074 times.
✓ Branch 3 taken 29 times.
 1606174 if (li->status_in && !li->status_out) {
1280 av_assert1(!ff_framequeue_queued_frames(&li->fifo));
1281 6074 return forward_status_change(filter, li);
1282 }
1283 }
1284
2/2
✓ Branch 0 taken 1600353 times.
✓ Branch 1 taken 805091 times.
 2405444 for (i = 0; i < filter->nb_outputs; i++) {
1285 1600353 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1286
2/2
✓ Branch 0 taken 800137 times.
✓ Branch 1 taken 800216 times.
 1600353 if (li->frame_wanted_out &&
1287
2/2
✓ Branch 0 taken 795278 times.
✓ Branch 1 taken 4859 times.
 800137 !li->frame_blocked_in) {
1288 795278 return request_frame_to_filter(filter->outputs[i]);
1289 }
1290 }
1291
2/2
✓ Branch 0 taken 805075 times.
✓ Branch 1 taken 800232 times.
 1605307 for (i = 0; i < filter->nb_outputs; i++) {
1292 805075 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1293
2/2
✓ Branch 0 taken 4859 times.
✓ Branch 1 taken 800216 times.
 805075 if (li->frame_wanted_out)
1294 4859 return request_frame_to_filter(filter->outputs[i]);
1295 }
1296
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 800216 times.
 800232 if (!filter->nb_outputs) {
1297 16 ff_inlink_request_frame(filter->inputs[0]);
1298 16 return 0;
1299 }
1300 800216 return FFERROR_NOT_READY;
1301 }
1302
1303 /*
1304 Filter scheduling and activation
1305
1306 When a filter is activated, it must:
1307 - if possible, output a frame;
1308 - else, if relevant, forward the input status change;
1309 - else, check outputs for wanted frames and forward the requests.
1310
1311 The following AVFilterLink fields are used for activation:
1312
1313 - frame_wanted_out:
1314
1315 This field indicates if a frame is needed on this input of the
1316 destination filter. A positive value indicates that a frame is needed
1317 to process queued frames or internal data or to satisfy the
1318 application; a zero value indicates that a frame is not especially
1319 needed but could be processed anyway; a negative value indicates that a
1320 frame would just be queued.
1321
1322 It is set by filters using ff_request_frame() or ff_request_no_frame(),
1323 when requested by the application through a specific API or when it is
1324 set on one of the outputs.
1325
1326 It is cleared when a frame is sent from the source using
1327 ff_filter_frame().
1328
1329 It is also cleared when a status change is sent from the source using
1330 ff_avfilter_link_set_in_status().
1331
1332 - frame_blocked_in:
1333
1334 This field means that the source filter can not generate a frame as is.
1335 Its goal is to avoid repeatedly calling the request_frame() method on
1336 the same link.
1337
1338 It is set by the framework on all outputs of a filter before activating it.
1339
1340 It is automatically cleared by ff_filter_frame().
1341
1342 It is also automatically cleared by ff_avfilter_link_set_in_status().
1343
1344 It is also cleared on all outputs (using filter_unblock()) when
1345 something happens on an input: processing a frame or changing the
1346 status.
1347
1348 - fifo:
1349
1350 Contains the frames queued on a filter input. If it contains frames and
1351 frame_wanted_out is not set, then the filter can be activated. If that
1352 result in the filter not able to use these frames, the filter must set
1353 frame_wanted_out to ask for more frames.
1354
1355 - status_in and status_in_pts:
1356
1357 Status (EOF or error code) of the link and timestamp of the status
1358 change (in link time base, same as frames) as seen from the input of
1359 the link. The status change is considered happening after the frames
1360 queued in fifo.
1361
1362 It is set by the source filter using ff_avfilter_link_set_in_status().
1363
1364 - status_out:
1365
1366 Status of the link as seen from the output of the link. The status
1367 change is considered having already happened.
1368
1369 It is set by the destination filter using
1370 link_set_out_status().
1371
1372 Filters are activated according to the ready field, set using the
1373 ff_filter_set_ready(). Eventually, a priority queue will be used.
1374 ff_filter_set_ready() is called whenever anything could cause progress to
1375 be possible. Marking a filter ready when it is not is not a problem,
1376 except for the small overhead it causes.
1377
1378 Conditions that cause a filter to be marked ready are:
1379
1380 - frames added on an input link;
1381
1382 - changes in the input or output status of an input link;
1383
1384 - requests for a frame on an output link;
1385
1386 - after any actual processing using the legacy methods (filter_frame(),
1387 and request_frame() to acknowledge status changes), to run once more
1388 and check if enough input was present for several frames.
1389
1390 Examples of scenarios to consider:
1391
1392 - buffersrc: activate if frame_wanted_out to notify the application;
1393 activate when the application adds a frame to push it immediately.
1394
1395 - testsrc: activate only if frame_wanted_out to produce and push a frame.
1396
1397 - concat (not at stitch points): can process a frame on any output.
1398 Activate if frame_wanted_out on output to forward on the corresponding
1399 input. Activate when a frame is present on input to process it
1400 immediately.
1401
1402 - framesync: needs at least one frame on each input; extra frames on the
1403 wrong input will accumulate. When a frame is first added on one input,
1404 set frame_wanted_out<0 on it to avoid getting more (would trigger
1405 testsrc) and frame_wanted_out>0 on the other to allow processing it.
1406
1407 Activation of old filters:
1408
1409 In order to activate a filter implementing the legacy filter_frame() and
1410 request_frame() methods, perform the first possible of the following
1411 actions:
1412
1413 - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1414 frame and call filter_frame().
1415
1416 Rationale: filter frames as soon as possible instead of leaving them
1417 queued; frame_wanted_out < 0 is not possible since the old API does not
1418 set it nor provides any similar feedback; frame_wanted_out > 0 happens
1419 when min_samples > 0 and there are not enough samples queued.
1420
1421 - If an input has status_in set but not status_out, try to call
1422 request_frame() on one of the outputs in the hope that it will trigger
1423 request_frame() on the input with status_in and acknowledge it. This is
1424 awkward and fragile, filters with several inputs or outputs should be
1425 updated to direct activation as soon as possible.
1426
1427 - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1428 request_frame().
1429
1430 Rationale: checking frame_blocked_in is necessary to avoid requesting
1431 repeatedly on a blocked input if another is not blocked (example:
1432 [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1433
1434 - If an output has frame_wanted_out > 0 call request_frame().
1435
1436 Rationale: even if all inputs are blocked an activate callback should
1437 request a frame on some if its inputs if a frame is requested on any of
1438 its output.
1439
1440 - Request a frame on the input for sinks.
1441
1442 Rationale: sinks using the old api have no way to request a frame on their
1443 input, so we need to do it for them.
1444 */
1445
1446 4205197 int ff_filter_activate(AVFilterContext *filter)
1447 {
1448 4205197 FFFilterContext *ctxi = fffilterctx(filter);
1449 4205197 const FFFilter *const fi = fffilter(filter->filter);
1450 int ret;
1451
1452 /* Generic timeline support is not yet implemented but should be easy */
1453 av_assert1(!(fi->p.flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
1454 fi->activate));
1455 4205197 ctxi->ready = 0;
1456
2/2
✓ Branch 0 taken 1786485 times.
✓ Branch 1 taken 2418712 times.
 4205197 ret = fi->activate ? fi->activate(filter) : filter_activate_default(filter);
1457
2/2
✓ Branch 0 taken 801089 times.
✓ Branch 1 taken 3404108 times.
 4205197 if (ret == FFERROR_NOT_READY)
1458 801089 ret = 0;
1459 4205197 return ret;
1460 }
1461
1462 3824214 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1463 {
1464 3824214 FilterLinkInternal * const li = ff_link_internal(link);
1465 3824214 *rpts = li->l.current_pts;
1466
2/2
✓ Branch 1 taken 2174 times.
✓ Branch 2 taken 3822040 times.
 3824214 if (ff_framequeue_queued_frames(&li->fifo))
1467 2174 return *rstatus = 0;
1468
2/2
✓ Branch 0 taken 7984 times.
✓ Branch 1 taken 3814056 times.
 3822040 if (li->status_out)
1469 7984 return *rstatus = li->status_out;
1470
2/2
✓ Branch 0 taken 3806063 times.
✓ Branch 1 taken 7993 times.
 3814056 if (!li->status_in)
1471 3806063 return *rstatus = 0;
1472 7993 *rstatus = li->status_out = li->status_in;
1473 7993 update_link_current_pts(li, li->status_in_pts);
1474 7993 *rpts = li->l.current_pts;
1475 7993 return 1;
1476 }
1477
1478 1934 size_t ff_inlink_queued_frames(AVFilterLink *link)
1479 {
1480 1934 FilterLinkInternal * const li = ff_link_internal(link);
1481 1934 return ff_framequeue_queued_frames(&li->fifo);
1482 }
1483
1484 5501431 int ff_inlink_check_available_frame(AVFilterLink *link)
1485 {
1486 5501431 FilterLinkInternal * const li = ff_link_internal(link);
1487 5501431 return ff_framequeue_queued_frames(&li->fifo) > 0;
1488 }
1489
1490 8446 int ff_inlink_queued_samples(AVFilterLink *link)
1491 {
1492 8446 FilterLinkInternal * const li = ff_link_internal(link);
1493 8446 return ff_framequeue_queued_samples(&li->fifo);
1494 }
1495
1496 5033 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1497 {
1498 5033 FilterLinkInternal * const li = ff_link_internal(link);
1499 5033 uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1500 av_assert1(min);
1501
6/6
✓ Branch 0 taken 2110 times.
✓ Branch 1 taken 2923 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 2045 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 59 times.
 5033 return samples >= min || (li->status_in && samples);
1502 }
1503
1504 1687719 static void consume_update(FilterLinkInternal *li, const AVFrame *frame)
1505 {
1506 1687719 AVFilterLink *const link = &li->l.pub;
1507 1687719 update_link_current_pts(li, frame->pts);
1508 1687719 ff_inlink_process_commands(link, frame);
1509
2/2
✓ Branch 0 taken 1684994 times.
✓ Branch 1 taken 2725 times.
 1687719 if (link == link->dst->inputs[0])
1510 1684994 link->dst->is_disabled = !evaluate_timeline_at_frame(link, frame);
1511 1687719 li->l.frame_count_out++;
1512 1687719 li->l.sample_count_out += frame->nb_samples;
1513 1687719 }
1514
1515 5499316 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1516 {
1517 5499316 FilterLinkInternal * const li = ff_link_internal(link);
1518 AVFrame *frame;
1519
1520 5499316 *rframe = NULL;
1521
2/2
✓ Branch 1 taken 3814522 times.
✓ Branch 2 taken 1684794 times.
 5499316 if (!ff_inlink_check_available_frame(link))
1522 3814522 return 0;
1523
1524
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1684790 times.
 1684794 if (li->fifo.samples_skipped) {
1525 4 frame = ff_framequeue_peek(&li->fifo, 0);
1526 4 return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1527 }
1528
1529 1684790 frame = ff_framequeue_take(&li->fifo);
1530 1684790 consume_update(li, frame);
1531 1684790 *rframe = frame;
1532 1684790 return 1;
1533 }
1534
1535 5033 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1536 AVFrame **rframe)
1537 {
1538 5033 FilterLinkInternal * const li = ff_link_internal(link);
1539 AVFrame *frame;
1540 int ret;
1541
1542 av_assert1(min);
1543 5033 *rframe = NULL;
1544
2/2
✓ Branch 1 taken 2104 times.
✓ Branch 2 taken 2929 times.
 5033 if (!ff_inlink_check_available_samples(link, min))
1545 2104 return 0;
1546
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 2916 times.
 2929 if (li->status_in)
1547
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 7 times.
 13 min = FFMIN(min, ff_framequeue_queued_samples(&li->fifo));
1548 2929 ret = take_samples(li, min, max, &frame);
1549
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2929 times.
 2929 if (ret < 0)
1550 ✗ return ret;
1551 2929 consume_update(li, frame);
1552 2929 *rframe = frame;
1553 2929 return 1;
1554 }
1555
1556 210 AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
1557 {
1558 210 FilterLinkInternal * const li = ff_link_internal(link);
1559 210 return ff_framequeue_peek(&li->fifo, idx);
1560 }
1561
1562 5168 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1563 {
1564 5168 AVFrame *frame = *rframe;
1565 AVFrame *out;
1566 int ret;
1567
1568
2/2
✓ Branch 1 taken 2268 times.
✓ Branch 2 taken 2900 times.
 5168 if (av_frame_is_writable(frame))
1569 2268 return 0;
1570 2900 av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1571
1572
1/3
✓ Branch 0 taken 2900 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 2900 switch (link->type) {
1573 2900 case AVMEDIA_TYPE_VIDEO:
1574 2900 out = ff_get_video_buffer(link, link->w, link->h);
1575 2900 break;
1576 ✗ case AVMEDIA_TYPE_AUDIO:
1577 ✗ out = ff_get_audio_buffer(link, frame->nb_samples);
1578 ✗ break;
1579 ✗ default:
1580 ✗ return AVERROR(EINVAL);
1581 }
1582
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2900 times.
 2900 if (!out)
1583 ✗ return AVERROR(ENOMEM);
1584
1585 2900 ret = av_frame_copy_props(out, frame);
1586
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2900 times.
 2900 if (ret < 0) {
1587 ✗ av_frame_free(&out);
1588 ✗ return ret;
1589 }
1590
1591 2900 ret = av_frame_copy(out, frame);
1592
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2900 times.
 2900 if (ret < 0) {
1593 ✗ av_frame_free(&out);
1594 ✗ return ret;
1595 }
1596
1597 2900 av_frame_free(&frame);
1598 2900 *rframe = out;
1599 2900 return 0;
1600 }
1601
1602 2493039 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1603 {
1604 2493039 FFFilterContext *ctxi = fffilterctx(link->dst);
1605 2493039 AVFilterCommand *cmd = ctxi->command_queue;
1606
1607
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2493039 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 2493039 while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1608 ✗ av_log(link->dst, AV_LOG_DEBUG,
1609 "Processing command time:%f command:%s arg:%s\n",
1610 cmd->time, cmd->command, cmd->arg);
1611 ✗ avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1612 ✗ command_queue_pop(link->dst);
1613 ✗ cmd = ctxi->command_queue;
1614 }
1615 2493039 return 0;
1616 }
1617
1618 889286 void ff_inlink_request_frame(AVFilterLink *link)
1619 {
1620 889286 av_unused FilterLinkInternal *li = ff_link_internal(link);
1621 av_assert1(!li->status_in);
1622 av_assert1(!li->status_out);
1623 889286 li->frame_wanted_out = 1;
1624 889286 ff_filter_set_ready(link->src, 100);
1625 889286 }
1626
1627 11076 void ff_inlink_set_status(AVFilterLink *link, int status)
1628 {
1629 11076 FilterLinkInternal * const li = ff_link_internal(link);
1630
2/2
✓ Branch 0 taken 8562 times.
✓ Branch 1 taken 2514 times.
 11076 if (li->status_out)
1631 8562 return;
1632 2514 li->frame_wanted_out = 0;
1633 2514 li->frame_blocked_in = 0;
1634 2514 link_set_out_status(link, status, AV_NOPTS_VALUE);
1635
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 2514 times.
 2520 while (ff_framequeue_queued_frames(&li->fifo)) {
1636 6 AVFrame *frame = ff_framequeue_take(&li->fifo);
1637 6 av_frame_free(&frame);
1638 }
1639
2/2
✓ Branch 0 taken 2511 times.
✓ Branch 1 taken 3 times.
 2514 if (!li->status_in)
1640 2511 li->status_in = status;
1641 }
1642
1643 4128209 int ff_outlink_get_status(AVFilterLink *link)
1644 {
1645 4128209 FilterLinkInternal * const li = ff_link_internal(link);
1646 4128209 return li->status_in;
1647 }
1648
1649 1668 int ff_inoutlink_check_flow(AVFilterLink *inlink, AVFilterLink *outlink)
1650 {
1651 1668 FilterLinkInternal * const li_in = ff_link_internal(inlink);
1652
1/2
✓ Branch 1 taken 1049 times.
✗ Branch 2 not taken.
 2717 return ff_outlink_frame_wanted(outlink) ||
1653
2/2
✓ Branch 0 taken 1049 times.
✓ Branch 1 taken 619 times.
 2717 ff_inlink_check_available_frame(inlink) ||
1654
2/2
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 994 times.
 1049 li_in->status_out;
1655 }
1656
1657
1658 ✗ const AVClass *avfilter_get_class(void)
1659 {
1660 ✗ return &avfilter_class;
1661 }
1662
1663 ✗ int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link,
1664 int default_pool_size)
1665 {
1666 ✗ FilterLink *l = ff_filter_link(link);
1667 AVHWFramesContext *frames;
1668
1669 // Must already be set by caller.
1670 ✗ av_assert0(l->hw_frames_ctx);
1671
1672 ✗ frames = (AVHWFramesContext*)l->hw_frames_ctx->data;
1673
1674 ✗ if (frames->initial_pool_size == 0) {
1675 // Dynamic allocation is necessarily supported.
1676 ✗ } else if (avctx->extra_hw_frames >= 0) {
1677 ✗ frames->initial_pool_size += avctx->extra_hw_frames;
1678 } else {
1679 ✗ frames->initial_pool_size = default_pool_size;
1680 }
1681
1682 ✗ return 0;
1683 }
1684
1685 483939 int ff_outlink_frame_wanted(AVFilterLink *link)
1686 {
1687 483939 FilterLinkInternal * const li = ff_link_internal(link);
1688 483939 return li->frame_wanted_out;
1689 }
1690
1691 4989 int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func,
1692 void *arg, int *ret, int nb_jobs)
1693 {
1694 4989 return fffilterctx(ctx)->execute(ctx, func, arg, ret, nb_jobs);
1695 }
1696