FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/avfilter.c
Date: 2026-07-18 19:31:15
Exec Total Coverage
Lines: 675 852 79.2%
Functions: 58 66 87.9%
Branches: 364 514 70.8%
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 1721160 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 1721160 }
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 579 static int append_pad(unsigned *count, AVFilterPad **pads,
101 AVFilterLink ***links, AVFilterPad *newpad)
102 {
103 AVFilterLink **newlinks;
104 AVFilterPad *newpads;
105 579 unsigned idx = *count;
106
107 579 newpads = av_realloc_array(*pads, idx + 1, sizeof(*newpads));
108 579 newlinks = av_realloc_array(*links, idx + 1, sizeof(*newlinks));
109
1/2
✓ Branch 0 taken 579 times.
✗ Branch 1 not taken.
 579 if (newpads)
110 579 *pads = newpads;
111
1/2
✓ Branch 0 taken 579 times.
✗ Branch 1 not taken.
 579 if (newlinks)
112 579 *links = newlinks;
113
2/4
✓ Branch 0 taken 579 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 579 times.
 579 if (!newpads || !newlinks) {
114 ✗ if (newpad->flags & AVFILTERPAD_FLAG_FREE_NAME)
115 ✗ av_freep(&newpad->name);
116 ✗ return AVERROR(ENOMEM);
117 }
118
119 579 memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
120 579 (*links)[idx] = NULL;
121
122 579 (*count)++;
123
124 579 return 0;
125 }
126
127 289 int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
128 {
129 289 return append_pad(&f->nb_inputs, &f->input_pads, &f->inputs, p);
130 }
131
132 270 int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
133 {
134 270 p->flags |= AVFILTERPAD_FLAG_FREE_NAME;
135 270 return ff_append_inpad(f, p);
136 }
137
138 290 int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
139 {
140 290 return append_pad(&f->nb_outputs, &f->output_pads, &f->outputs, p);
141 }
142
143 149 int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
144 {
145 149 p->flags |= AVFILTERPAD_FLAG_FREE_NAME;
146 149 return ff_append_outpad(f, p);
147 }
148
149 47722 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 47722 times.
 47722 av_assert0(src->graph);
156
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47722 times.
 47722 av_assert0(dst->graph);
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47722 times.
 47722 av_assert0(src->graph == dst->graph);
158
159
2/4
✓ Branch 0 taken 47722 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 47722 times.
✗ Branch 3 not taken.
 47722 if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
160
2/4
✓ Branch 0 taken 47722 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 47722 times.
 47722 src->outputs[srcpad] || dst->inputs[dstpad])
161 ✗ return AVERROR(EINVAL);
162
163
1/2
✓ Branch 1 taken 47722 times.
✗ Branch 2 not taken.
 47722 if (!(fffilterctx(src)->state_flags & AV_CLASS_STATE_INITIALIZED) ||
164
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47722 times.
 47722 !(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 47722 times.
 47722 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 47722 li = av_mallocz(sizeof(*li));
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47722 times.
 47722 if (!li)
179 ✗ return AVERROR(ENOMEM);
180 47722 link = &li->l.pub;
181
182 47722 src->outputs[srcpad] = dst->inputs[dstpad] = link;
183
184 47722 link->src = src;
185 47722 link->dst = dst;
186 47722 link->srcpad = &src->output_pads[srcpad];
187 47722 link->dstpad = &dst->input_pads[dstpad];
188 47722 link->type = src->output_pads[srcpad].type;
189 47722 li->l.graph = src->graph;
190 av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
191 47722 link->format = -1;
192 47722 link->colorspace = AVCOL_SPC_UNSPECIFIED;
193 47722 ff_framequeue_init(&li->fifo, &fffiltergraph(src->graph)->frame_queues);
194
195 47722 return 0;
196 }
197
198 47854 static void link_free(AVFilterLink **link)
199 {
200 FilterLinkInternal *li;
201
202
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47854 times.
 47854 if (!*link)
203 ✗ return;
204 47854 li = ff_link_internal(*link);
205
206 47854 ff_framequeue_free(&li->fifo);
207 47854 ff_frame_pool_uninit(&li->frame_pool);
208 47854 av_channel_layout_uninit(&(*link)->ch_layout);
209 47854 av_frame_side_data_free(&(*link)->side_data, &(*link)->nb_side_data);
210
211 47854 av_buffer_unref(&li->l.hw_frames_ctx);
212
213 47854 av_freep(link);
214 }
215
216 1732924 static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
217 {
218 1732924 AVFilterLink *const link = &li->l.pub;
219
220
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1732919 times.
 1732924 if (pts == AV_NOPTS_VALUE)
221 5 return;
222 1732919 li->l.current_pts = pts;
223 1732919 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 1732919 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 467412 times.
✓ Branch 3 taken 1265507 times.
 1732919 if (li->l.graph && li->age_index >= 0)
226 467412 ff_avfilter_graph_update_heap(li->l.graph, li);
227 }
228
229 4295702 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
230 {
231 4295702 FFFilterContext *ctxi = fffilterctx(filter);
232 4295702 ctxi->ready = FFMAX(ctxi->ready, priority);
233 4295702 }
234
235 /**
236 * Clear frame_blocked_in on all outputs.
237 * This is necessary whenever something changes on input.
238 */
239 2564145 static void filter_unblock(AVFilterContext *filter)
240 {
241 unsigned i;
242
243
2/2
✓ Branch 0 taken 2096833 times.
✓ Branch 1 taken 2564145 times.
 4660978 for (i = 0; i < filter->nb_outputs; i++) {
244 2096833 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
245 2096833 li->frame_blocked_in = 0;
246 }
247 2564145 }
248
249
250 20014 void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
251 {
252 20014 FilterLinkInternal * const li = ff_link_internal(link);
253
254
2/2
✓ Branch 0 taken 5698 times.
✓ Branch 1 taken 14316 times.
 20014 if (li->status_in == status)
255 5698 return;
256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14316 times.
 14316 av_assert0(!li->status_in);
257 14316 li->status_in = status;
258 14316 li->status_in_pts = pts;
259 14316 li->frame_wanted_out = 0;
260 14316 li->frame_blocked_in = 0;
261 14316 filter_unblock(link->dst);
262 14316 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 8732 static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
270 {
271 8732 FilterLinkInternal * const li = ff_link_internal(link);
272
273
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8732 times.
 8732 av_assert0(!li->frame_wanted_out);
274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8732 times.
 8732 av_assert0(!li->status_out);
275 8732 li->status_out = status;
276
2/2
✓ Branch 0 taken 6191 times.
✓ Branch 1 taken 2541 times.
 8732 if (pts != AV_NOPTS_VALUE)
277 6191 update_link_current_pts(li, pts);
278 8732 filter_unblock(link->dst);
279 8732 ff_filter_set_ready(link->src, 200);
280 8732 }
281
282 1303 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
283 unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
284 {
285 int ret;
286 1303 unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
287
288 1303 av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
289 "between the filter '%s' and the filter '%s'\n",
290 1303 filt->name, link->src->name, link->dst->name);
291
292 1303 link->dst->inputs[dstpad_idx] = NULL;
293
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1303 times.
 1303 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 1303 link->dst = filt;
301 1303 link->dstpad = &filt->input_pads[filt_srcpad_idx];
302 1303 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 1303 times.
✗ Branch 1 not taken.
 1303 if (link->outcfg.formats)
307 1303 ff_formats_changeref(&link->outcfg.formats,
308 1303 &filt->outputs[filt_dstpad_idx]->outcfg.formats);
309
2/2
✓ Branch 0 taken 634 times.
✓ Branch 1 taken 669 times.
 1303 if (link->outcfg.color_spaces)
310 634 ff_formats_changeref(&link->outcfg.color_spaces,
311 634 &filt->outputs[filt_dstpad_idx]->outcfg.color_spaces);
312
2/2
✓ Branch 0 taken 634 times.
✓ Branch 1 taken 669 times.
 1303 if (link->outcfg.color_ranges)
313 634 ff_formats_changeref(&link->outcfg.color_ranges,
314 634 &filt->outputs[filt_dstpad_idx]->outcfg.color_ranges);
315
2/2
✓ Branch 0 taken 634 times.
✓ Branch 1 taken 669 times.
 1303 if (link->outcfg.alpha_modes)
316 634 ff_formats_changeref(&link->outcfg.alpha_modes,
317 634 &filt->outputs[filt_dstpad_idx]->outcfg.alpha_modes);
318
2/2
✓ Branch 0 taken 669 times.
✓ Branch 1 taken 634 times.
 1303 if (link->outcfg.samplerates)
319 669 ff_formats_changeref(&link->outcfg.samplerates,
320 669 &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
321
2/2
✓ Branch 0 taken 669 times.
✓ Branch 1 taken 634 times.
 1303 if (link->outcfg.channel_layouts)
322 669 ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
323 669 &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
324
325 1303 return 0;
326 }
327
328 45793 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 37464 times.
✓ Branch 1 taken 45789 times.
 83253 for (i = 0; i < filter->nb_inputs; i ++) {
335 37464 AVFilterLink *link = filter->inputs[i];
336 AVFilterLink *inlink;
337 37464 FilterLinkInternal *li = ff_link_internal(link);
338 FilterLinkInternal *li_in;
339
340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37464 times.
 37464 if (!link) continue;
341
2/4
✓ Branch 0 taken 37464 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 37464 times.
 37464 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 28933 times.
✓ Branch 1 taken 8531 times.
 37464 inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
348
2/2
✓ Branch 0 taken 28933 times.
✓ Branch 1 taken 8531 times.
 37464 li_in = inlink ? ff_link_internal(inlink) : NULL;
349 37464 li->l.current_pts =
350 37464 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 37351 times.
✗ Branch 3 not taken.
 37464 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 37351 case AVLINK_UNINIT:
359 37351 li->init_state = AVLINK_STARTINIT;
360
361
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 37350 times.
 37351 if ((ret = ff_filter_config_links(link->src)) < 0)
362 1 return ret;
363
364
2/2
✓ Branch 0 taken 19566 times.
✓ Branch 1 taken 17784 times.
 37350 if (!(config_link = link->srcpad->config_props)) {
365
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19566 times.
 19566 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 28853 times.
✓ Branch 1 taken 8497 times.
✓ Branch 2 taken 311 times.
✓ Branch 3 taken 28542 times.
✓ Branch 4 taken 311 times.
✗ Branch 5 not taken.
 37350 if (inlink && inlink->nb_side_data && !link->nb_side_data) {
377
2/2
✓ Branch 0 taken 355 times.
✓ Branch 1 taken 311 times.
 666 for (int j = 0; j < inlink->nb_side_data; j++) {
378 355 ret = av_frame_side_data_clone(&link->side_data, &link->nb_side_data,
379 355 inlink->side_data[j], 0);
380
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
 355 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 17784 times.
✓ Branch 1 taken 19566 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 17783 times.
 37350 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 31111 times.
✓ Branch 1 taken 6238 times.
✗ Branch 2 not taken.
 37349 switch (link->type) {
395 31111 case AVMEDIA_TYPE_VIDEO:
396
3/4
✓ Branch 0 taken 23806 times.
✓ Branch 1 taken 7305 times.
✓ Branch 2 taken 23806 times.
✗ Branch 3 not taken.
 31111 if (!link->time_base.num && !link->time_base.den)
397
1/2
✓ Branch 0 taken 23806 times.
✗ Branch 1 not taken.
 23806 link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
398
399
4/4
✓ Branch 0 taken 26590 times.
✓ Branch 1 taken 4521 times.
✓ Branch 2 taken 16926 times.
✓ Branch 3 taken 9664 times.
 31111 if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
400 16926 link->sample_aspect_ratio = inlink ?
401
2/2
✓ Branch 0 taken 16911 times.
✓ Branch 1 taken 15 times.
 16926 inlink->sample_aspect_ratio : (AVRational){1,1};
402
403
2/2
✓ Branch 0 taken 24070 times.
✓ Branch 1 taken 7041 times.
 31111 if (inlink) {
404
3/4
✓ Branch 0 taken 23849 times.
✓ Branch 1 taken 221 times.
✓ Branch 2 taken 23849 times.
✗ Branch 3 not taken.
 24070 if (!li->l.frame_rate.num && !li->l.frame_rate.den)
405 23849 li->l.frame_rate = li_in->l.frame_rate;
406
2/2
✓ Branch 0 taken 16423 times.
✓ Branch 1 taken 7647 times.
 24070 if (!link->w)
407 16423 link->w = inlink->w;
408
2/2
✓ Branch 0 taken 16423 times.
✓ Branch 1 taken 7647 times.
 24070 if (!link->h)
409 16423 link->h = inlink->h;
410
2/4
✓ Branch 0 taken 7041 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7041 times.
 7041 } 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 31111 break;
417
418 6238 case AVMEDIA_TYPE_AUDIO:
419
2/2
✓ Branch 0 taken 4782 times.
✓ Branch 1 taken 1456 times.
 6238 if (inlink) {
420
3/4
✓ Branch 0 taken 3234 times.
✓ Branch 1 taken 1548 times.
✓ Branch 2 taken 3234 times.
✗ Branch 3 not taken.
 4782 if (!link->time_base.num && !link->time_base.den)
421 3234 link->time_base = inlink->time_base;
422 }
423
424
3/4
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 6154 times.
✓ Branch 2 taken 84 times.
✗ Branch 3 not taken.
 6238 if (!link->time_base.num && !link->time_base.den)
425 84 link->time_base = (AVRational) {1, link->sample_rate};
426 }
427
428
2/2
✓ Branch 0 taken 28852 times.
✓ Branch 1 taken 8497 times.
 37349 if (link->src->nb_inputs &&
429
1/2
✓ Branch 1 taken 28852 times.
✗ Branch 2 not taken.
 28852 !(fffilter(link->src->filter)->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
430 28852 FilterLink *l0 = ff_filter_link(link->src->inputs[0]);
431
432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28852 times.
 28852 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 28852 times.
 28852 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 5021 times.
✓ Branch 1 taken 32328 times.
 37349 if ((config_link = link->dstpad->config_props))
443
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5021 times.
 5021 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 37349 li->init_state = AVLINK_INIT;
451 }
452 }
453
454 45789 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 820182 int ff_request_frame(AVFilterLink *link)
484 {
485 820182 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 820173 times.
 820182 if (li->status_out)
491 9 return li->status_out;
492
2/2
✓ Branch 0 taken 6193 times.
✓ Branch 1 taken 813980 times.
 820173 if (li->status_in) {
493
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6193 times.
 6193 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 6193 link_set_out_status(link, li->status_in, li->status_in_pts);
502 6193 return li->status_out;
503 }
504 }
505 813980 li->frame_wanted_out = 1;
506 813980 ff_filter_set_ready(link->src, 100);
507 813980 return 0;
508 }
509
510 6185 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
511 {
512 unsigned i;
513 6185 int64_t r = INT64_MAX;
514
515
2/2
✓ Branch 0 taken 6184 times.
✓ Branch 1 taken 6185 times.
 12369 for (i = 0; i < ctx->nb_inputs; i++) {
516 6184 FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
517
1/2
✓ Branch 0 taken 6184 times.
✗ Branch 1 not taken.
 6184 if (li->status_out == status)
518 6184 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 6184 times.
✓ Branch 1 taken 1 times.
 6185 if (r < INT64_MAX)
521 6184 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 820517 static int request_frame_to_filter(AVFilterLink *link)
533 {
534 820517 FilterLinkInternal * const li = ff_link_internal(link);
535 820517 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 820517 li->frame_blocked_in = 1;
540
2/2
✓ Branch 0 taken 2021 times.
✓ Branch 1 taken 818496 times.
 820517 if (link->srcpad->request_frame)
541 2021 ret = link->srcpad->request_frame(link);
542
1/2
✓ Branch 0 taken 818496 times.
✗ Branch 1 not taken.
 818496 else if (link->src->inputs[0])
543 818496 ret = ff_request_frame(link->src->inputs[0]);
544
2/2
✓ Branch 0 taken 6185 times.
✓ Branch 1 taken 814332 times.
 820517 if (ret < 0) {
545
2/4
✓ Branch 0 taken 6185 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6185 times.
✗ Branch 3 not taken.
 6185 if (ret != AVERROR(EAGAIN) && ret != li->status_in)
546 6185 ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
547
1/2
✓ Branch 0 taken 6185 times.
✗ Branch 1 not taken.
 6185 if (ret == AVERROR_EOF)
548 6185 ret = 0;
549 }
550 820517 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 ✗ unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
632 {
633 ✗ return is_output ? fffilter(filter)->nb_outputs : fffilter(filter)->nb_inputs;
634 }
635
636 594 static const char *default_filter_name(void *filter_ctx)
637 {
638 594 AVFilterContext *ctx = filter_ctx;
639
1/2
✓ Branch 0 taken 594 times.
✗ Branch 1 not taken.
 594 return ctx->name ? ctx->name : ctx->filter->name;
640 }
641
642 57595 static void *filter_child_next(void *obj, void *prev)
643 {
644 57595 AVFilterContext *ctx = obj;
645
5/8
✓ Branch 0 taken 57589 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 57589 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 57589 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 57589 times.
✗ Branch 7 not taken.
 57595 if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
646 57589 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 1374 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 1430 times.
✓ Branch 1 taken 1374 times.
 2804 for (i = 0; i < nb_jobs; i++) {
694 1430 int r = func(ctx, arg, i, nb_jobs);
695
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1430 times.
 1430 if (ret)
696 ✗ ret[i] = r;
697 }
698 1374 return 0;
699 }
700
701 64357 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
702 {
703 FFFilterContext *ctx;
704 AVFilterContext *ret;
705 64357 const FFFilter *const fi = fffilter(filter);
706 64357 int preinited = 0;
707
708
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64357 times.
 64357 if (!filter)
709 ✗ return NULL;
710
711 64357 ctx = av_mallocz(sizeof(*ctx));
712
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64357 times.
 64357 if (!ctx)
713 ✗ return NULL;
714 64357 ret = &ctx->p;
715
716 64357 ret->av_class = &avfilter_class;
717 64357 ret->filter = filter;
718
1/2
✓ Branch 0 taken 64357 times.
✗ Branch 1 not taken.
 64357 ret->name = inst_name ? av_strdup(inst_name) : NULL;
719
2/2
✓ Branch 0 taken 57405 times.
✓ Branch 1 taken 6952 times.
 64357 if (fi->priv_size) {
720 57405 ret->priv = av_mallocz(fi->priv_size);
721
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 57405 times.
 57405 if (!ret->priv)
722 ✗ goto err;
723 }
724
2/2
✓ Branch 0 taken 13746 times.
✓ Branch 1 taken 50611 times.
 64357 if (fi->preinit) {
725
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13746 times.
 13746 if (fi->preinit(ret) < 0)
726 ✗ goto err;
727 13746 preinited = 1;
728 }
729
730 64357 av_opt_set_defaults(ret);
731
2/2
✓ Branch 0 taken 56146 times.
✓ Branch 1 taken 8211 times.
 64357 if (filter->priv_class) {
732 56146 *(const AVClass**)ret->priv = filter->priv_class;
733 56146 av_opt_set_defaults(ret->priv);
734 }
735
736 64357 ctx->execute = default_execute;
737
738 64357 ret->nb_inputs = fi->nb_inputs;
739
2/2
✓ Branch 0 taken 54511 times.
✓ Branch 1 taken 9846 times.
 64357 if (ret->nb_inputs ) {
740 54511 ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs));
741
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54511 times.
 54511 if (!ret->input_pads)
742 ✗ goto err;
743 54511 ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs));
744
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54511 times.
 54511 if (!ret->inputs)
745 ✗ goto err;
746 }
747
748 64357 ret->nb_outputs = fi->nb_outputs;
749
2/2
✓ Branch 0 taken 55821 times.
✓ Branch 1 taken 8536 times.
 64357 if (ret->nb_outputs) {
750 55821 ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 55821 times.
 55821 if (!ret->output_pads)
752 ✗ goto err;
753 55821 ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs));
754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 55821 times.
 55821 if (!ret->outputs)
755 ✗ goto err;
756 }
757
758 64357 return ret;
759
760 ✗ err:
761 ✗ if (preinited)
762 ✗ fi->uninit(ret);
763 ✗ av_freep(&ret->name);
764 ✗ av_freep(&ret->inputs);
765 ✗ av_freep(&ret->input_pads);
766 ✗ ret->nb_inputs = 0;
767 ✗ av_freep(&ret->outputs);
768 ✗ av_freep(&ret->output_pads);
769 ✗ ret->nb_outputs = 0;
770 ✗ av_freep(&ret->priv);
771 ✗ av_free(ret);
772 ✗ return NULL;
773 }
774
775 111011 static void free_link(AVFilterLink *link)
776 {
777
2/2
✓ Branch 0 taken 63157 times.
✓ Branch 1 taken 47854 times.
 111011 if (!link)
778 63157 return;
779
780
2/2
✓ Branch 0 taken 47722 times.
✓ Branch 1 taken 132 times.
 47854 if (link->src)
781 47722 link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
782
2/2
✓ Branch 0 taken 47722 times.
✓ Branch 1 taken 132 times.
 47854 if (link->dst)
783 47722 link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
784
785 47854 ff_formats_unref(&link->incfg.formats);
786 47854 ff_formats_unref(&link->outcfg.formats);
787 47854 ff_formats_unref(&link->incfg.color_spaces);
788 47854 ff_formats_unref(&link->outcfg.color_spaces);
789 47854 ff_formats_unref(&link->incfg.color_ranges);
790 47854 ff_formats_unref(&link->outcfg.color_ranges);
791 47854 ff_formats_unref(&link->incfg.alpha_modes);
792 47854 ff_formats_unref(&link->outcfg.alpha_modes);
793 47854 ff_formats_unref(&link->incfg.samplerates);
794 47854 ff_formats_unref(&link->outcfg.samplerates);
795 47854 ff_channel_layouts_unref(&link->incfg.channel_layouts);
796 47854 ff_channel_layouts_unref(&link->outcfg.channel_layouts);
797 47854 link_free(&link);
798 }
799
800 64357 void avfilter_free(AVFilterContext *filter)
801 {
802 FFFilterContext *ctxi;
803 int i;
804
805
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64357 times.
 64357 if (!filter)
806 ✗ return;
807 64357 ctxi = fffilterctx(filter);
808
809
1/2
✓ Branch 0 taken 64357 times.
✗ Branch 1 not taken.
 64357 if (filter->graph)
810 64357 ff_filter_graph_remove_filter(filter->graph, filter);
811
812
2/2
✓ Branch 1 taken 49987 times.
✓ Branch 2 taken 14370 times.
 64357 if (fffilter(filter->filter)->uninit)
813 49987 fffilter(filter->filter)->uninit(filter);
814
815
2/2
✓ Branch 0 taken 54896 times.
✓ Branch 1 taken 64357 times.
 119253 for (i = 0; i < filter->nb_inputs; i++) {
816 54896 free_link(filter->inputs[i]);
817
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 54626 times.
 54896 if (filter->input_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
818 270 av_freep(&filter->input_pads[i].name);
819 }
820
2/2
✓ Branch 0 taken 56115 times.
✓ Branch 1 taken 64357 times.
 120472 for (i = 0; i < filter->nb_outputs; i++) {
821 56115 free_link(filter->outputs[i]);
822
2/2
✓ Branch 0 taken 285 times.
✓ Branch 1 taken 55830 times.
 56115 if (filter->output_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
823 285 av_freep(&filter->output_pads[i].name);
824 }
825
826
2/2
✓ Branch 0 taken 56146 times.
✓ Branch 1 taken 8211 times.
 64357 if (filter->filter->priv_class)
827 56146 av_opt_free(filter->priv);
828
829 64357 av_buffer_unref(&filter->hw_device_ctx);
830
831 64357 av_freep(&filter->name);
832 64357 av_freep(&filter->input_pads);
833 64357 av_freep(&filter->output_pads);
834 64357 av_freep(&filter->inputs);
835 64357 av_freep(&filter->outputs);
836 64357 av_freep(&filter->priv);
837
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64357 times.
 64357 while (ctxi->command_queue)
838 ✗ command_queue_pop(filter);
839 64357 av_opt_free(filter);
840 64357 av_expr_free(ctxi->enable);
841 64357 ctxi->enable = NULL;
842 64357 av_freep(&ctxi->var_values);
843 64357 av_free(filter);
844 }
845
846 19546 int ff_filter_get_nb_threads(AVFilterContext *ctx)
847 {
848
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19546 times.
 19546 if (ctx->nb_threads > 0)
849 ✗ return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
850 19546 return ctx->graph->nb_threads;
851 }
852
853 34407 int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
854 AVDictionary **options, const char *args)
855 {
856 34407 const AVOption *o = NULL;
857 int ret;
858 34407 int offset= -1;
859
860
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34407 times.
 34407 if (!args)
861 ✗ return 0;
862
863
2/2
✓ Branch 0 taken 59380 times.
✓ Branch 1 taken 34407 times.
 93787 while (*args) {
864 char *parsed_key, *value;
865 const char *key;
866 59380 const char *shorthand = NULL;
867 59380 int additional_flags = 0;
868
869
4/4
✓ Branch 0 taken 46022 times.
✓ Branch 1 taken 13358 times.
✓ Branch 3 taken 44740 times.
✓ Branch 4 taken 1282 times.
 59380 if (priv_class && (o = av_opt_next(&priv_class, o))) {
870
4/4
✓ Branch 0 taken 42970 times.
✓ Branch 1 taken 1770 times.
✓ Branch 2 taken 4592 times.
✓ Branch 3 taken 38378 times.
 44740 if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
871 6362 continue;
872 38378 offset = o->offset;
873 38378 shorthand = o->name;
874 }
875
876 53018 ret = av_opt_get_key_value(&args, "=", ":",
877 shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
878 &parsed_key, &value);
879
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 53018 times.
 53018 if (ret < 0) {
880 ✗ if (ret == AVERROR(EINVAL))
881 ✗ av_log(logctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
882 else
883 ✗ av_log(logctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
884 ✗ av_err2str(ret));
885 ✗ return ret;
886 }
887
2/2
✓ Branch 0 taken 27637 times.
✓ Branch 1 taken 25381 times.
 53018 if (*args)
888 27637 args++;
889
2/2
✓ Branch 0 taken 31938 times.
✓ Branch 1 taken 21080 times.
 53018 if (parsed_key) {
890 31938 key = parsed_key;
891 31938 additional_flags = AV_DICT_DONT_STRDUP_KEY;
892 31938 priv_class = NULL; /* reject all remaining shorthand */
893 } else {
894 21080 key = shorthand;
895 }
896
897 53018 av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
898
899 53018 av_dict_set(options, key, value,
900 additional_flags | AV_DICT_DONT_STRDUP_VAL | AV_DICT_MULTIKEY);
901 }
902
903 34407 return 0;
904 }
905
906 ✗ int ff_filter_process_command(AVFilterContext *ctx, const char *cmd,
907 const char *arg, char *res, int res_len, int flags)
908 {
909 const AVOption *o;
910
911 ✗ if (!ctx->filter->priv_class)
912 ✗ return 0;
913 ✗ o = av_opt_find2(ctx->priv, cmd, NULL, AV_OPT_FLAG_RUNTIME_PARAM | AV_OPT_FLAG_FILTERING_PARAM, AV_OPT_SEARCH_CHILDREN, NULL);
914 ✗ if (!o)
915 ✗ return AVERROR(ENOSYS);
916 ✗ return av_opt_set(ctx->priv, cmd, arg, 0);
917 }
918
919 64357 int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
920 {
921 64357 FFFilterContext *ctxi = fffilterctx(ctx);
922 64357 int ret = 0;
923
924
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64357 times.
 64357 if (ctxi->state_flags & AV_CLASS_STATE_INITIALIZED) {
925 ✗ av_log(ctx, AV_LOG_ERROR, "Filter already initialized\n");
926 ✗ return AVERROR(EINVAL);
927 }
928
929 64357 ret = av_opt_set_dict2(ctx, options, AV_OPT_SEARCH_CHILDREN);
930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64357 times.
 64357 if (ret < 0) {
931 ✗ av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
932 ✗ return ret;
933 }
934
935
2/2
✓ Branch 0 taken 1254 times.
✓ Branch 1 taken 63103 times.
 64357 if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
936
2/2
✓ Branch 0 taken 154 times.
✓ Branch 1 taken 1100 times.
 1254 ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
937
1/2
✓ Branch 1 taken 154 times.
✗ Branch 2 not taken.
 154 fffiltergraph(ctx->graph)->thread_execute) {
938 154 ctx->thread_type = AVFILTER_THREAD_SLICE;
939 154 ctxi->execute = fffiltergraph(ctx->graph)->thread_execute;
940 } else {
941 64203 ctx->thread_type = 0;
942 }
943
944
2/2
✓ Branch 1 taken 50819 times.
✓ Branch 2 taken 13538 times.
 64357 if (fffilter(ctx->filter)->init)
945 50819 ret = fffilter(ctx->filter)->init(ctx);
946
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64357 times.
 64357 if (ret < 0)
947 ✗ return ret;
948
949
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 64351 times.
 64357 if (ctx->enable_str) {
950 6 ret = set_enable_expr(ctxi, ctx->enable_str);
951
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (ret < 0)
952 ✗ return ret;
953 }
954
955 64357 ctxi->state_flags |= AV_CLASS_STATE_INITIALIZED;
956
957 64357 return 0;
958 }
959
960 21151 int avfilter_init_str(AVFilterContext *filter, const char *args)
961 {
962 21151 AVDictionary *options = NULL;
963 const AVDictionaryEntry *e;
964 21151 int ret = 0;
965
966
3/4
✓ Branch 0 taken 10564 times.
✓ Branch 1 taken 10587 times.
✓ Branch 2 taken 10564 times.
✗ Branch 3 not taken.
 21151 if (args && *args) {
967 10564 ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args);
968
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10564 times.
 10564 if (ret < 0)
969 ✗ goto fail;
970 }
971
972 21151 ret = avfilter_init_dict(filter, &options);
973
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21151 times.
 21151 if (ret < 0)
974 ✗ goto fail;
975
976
1/2
✓ Branch 1 taken 21151 times.
✗ Branch 2 not taken.
 21151 if ((e = av_dict_iterate(options, NULL))) {
977 ✗ av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
978 ✗ ret = AVERROR_OPTION_NOT_FOUND;
979 ✗ goto fail;
980 }
981
982 21151 fail:
983 21151 av_dict_free(&options);
984
985 21151 return ret;
986 }
987
988 15399 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
989 {
990 15399 return pads[pad_idx].name;
991 }
992
993 31155 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
994 {
995 31155 return pads[pad_idx].type;
996 }
997
998 ✗ AVBufferRef *avfilter_link_get_hw_frames_ctx(AVFilterLink *link)
999 {
1000 ✗ FilterLink *plink = ff_filter_link(link);
1001 ✗ if (plink->hw_frames_ctx)
1002 ✗ return av_buffer_ref(plink->hw_frames_ctx);
1003
1004 ✗ return NULL;
1005 }
1006
1007 799347 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
1008 {
1009 799347 return ff_filter_frame(link->dst->outputs[0], frame);
1010 }
1011
1012 /**
1013 * Evaluate the timeline expression of the link for the time and properties
1014 * of the frame.
1015 * @return >0 if enabled, 0 if disabled
1016 * @note It does not update link->dst->is_disabled.
1017 */
1018 2535830 static int evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1019 {
1020 2535830 FilterLink *l = ff_filter_link(link);
1021 2535830 AVFilterContext *dstctx = link->dst;
1022 2535830 FFFilterContext *dsti = fffilterctx(dstctx);
1023 2535830 int64_t pts = frame->pts;
1024
1025
2/2
✓ Branch 0 taken 2535632 times.
✓ Branch 1 taken 198 times.
 2535830 if (!dstctx->enable_str)
1026 2535632 return 1;
1027
1028 198 dsti->var_values[VAR_N] = l->frame_count_out;
1029
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);
1030 198 dsti->var_values[VAR_W] = link->w;
1031 198 dsti->var_values[VAR_H] = link->h;
1032
1033 198 return fabs(av_expr_eval(dsti->enable, dsti->var_values, NULL)) >= 0.5;
1034 }
1035
1036 819937 static int filter_frame_framed(AVFilterLink *link, AVFrame *frame)
1037 {
1038 819937 FilterLink *l = ff_filter_link(link);
1039 int (*filter_frame)(AVFilterLink *, AVFrame *);
1040 819937 AVFilterContext *dstctx = link->dst;
1041 819937 AVFilterPad *dst = link->dstpad;
1042 int ret;
1043
1044
2/2
✓ Branch 0 taken 799338 times.
✓ Branch 1 taken 20599 times.
 819937 if (!(filter_frame = dst->filter_frame))
1045 799338 filter_frame = default_filter_frame;
1046
1047
2/2
✓ Branch 0 taken 2993 times.
✓ Branch 1 taken 816944 times.
 819937 if (dst->flags & AVFILTERPAD_FLAG_NEEDS_WRITABLE) {
1048 2993 ret = ff_inlink_make_frame_writable(link, &frame);
1049
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2993 times.
 2993 if (ret < 0)
1050 ✗ goto fail;
1051 }
1052
1053 819937 ff_inlink_process_commands(link, frame);
1054 819937 dstctx->is_disabled = !evaluate_timeline_at_frame(link, frame);
1055
1056
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 819918 times.
 819937 if (dstctx->is_disabled &&
1057
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 10 times.
 19 (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
1058 9 filter_frame = default_filter_frame;
1059 819937 ret = filter_frame(link, frame);
1060 819937 l->frame_count_out++;
1061 819937 return ret;
1062
1063 ✗ fail:
1064 ✗ av_frame_free(&frame);
1065 ✗ return ret;
1066 }
1067
1068 1721160 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1069 {
1070 1721160 FilterLinkInternal * const li = ff_link_internal(link);
1071 int ret;
1072 1721160 FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); tlog_ref(NULL, frame, 1);
1073
1074 /* Consistency checks */
1075
2/2
✓ Branch 0 taken 586132 times.
✓ Branch 1 taken 1135028 times.
 1721160 if (link->type == AVMEDIA_TYPE_VIDEO) {
1076
2/2
✓ Branch 0 taken 435968 times.
✓ Branch 1 taken 150164 times.
 586132 if (strcmp(link->dst->filter->name, "buffersink") &&
1077
2/2
✓ Branch 0 taken 259741 times.
✓ Branch 1 taken 176227 times.
 435968 strcmp(link->dst->filter->name, "format") &&
1078
2/2
✓ Branch 0 taken 259714 times.
✓ Branch 1 taken 27 times.
 259741 strcmp(link->dst->filter->name, "idet") &&
1079
2/2
✓ Branch 0 taken 168195 times.
✓ Branch 1 taken 91519 times.
 259714 strcmp(link->dst->filter->name, "null") &&
1080
2/2
✓ Branch 0 taken 57613 times.
✓ Branch 1 taken 110582 times.
 168195 strcmp(link->dst->filter->name, "scale") &&
1081
1/2
✓ Branch 0 taken 57613 times.
✗ Branch 1 not taken.
 57613 strcmp(link->dst->filter->name, "libplacebo")) {
1082 av_assert1(frame->format == link->format);
1083 av_assert1(frame->width == link->w);
1084 av_assert1(frame->height == link->h);
1085 57613 if (av_pix_fmt_desc_get(link->format)->flags & AV_PIX_FMT_FLAG_ALPHA)
1086 av_assert1(frame->alpha_mode == link->alpha_mode);
1087 }
1088 } else {
1089
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1135028 times.
 1135028 if (frame->format != link->format) {
1090 ✗ av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1091 ✗ goto error;
1092 }
1093
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1135028 times.
 1135028 if (av_channel_layout_compare(&frame->ch_layout, &link->ch_layout)) {
1094 ✗ av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1095 ✗ goto error;
1096 }
1097
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1135028 times.
 1135028 if (frame->sample_rate != link->sample_rate) {
1098 ✗ av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1099 ✗ goto error;
1100 }
1101
1102 1135028 frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1103 link->time_base);
1104 }
1105
1106 1721160 li->frame_blocked_in = li->frame_wanted_out = 0;
1107 1721160 li->l.frame_count_in++;
1108 1721160 li->l.sample_count_in += frame->nb_samples;
1109 1721160 filter_unblock(link->dst);
1110 1721160 ret = ff_framequeue_add(&li->fifo, frame);
1111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1721160 times.
 1721160 if (ret < 0) {
1112 ✗ const FFFrameQueueGlobal *global = li->fifo.global;
1113 ✗ if (ret == AVERROR(ENOMEM) && global->queued >= global->max_queued)
1114 ✗ av_log(link->dst, AV_LOG_ERROR, "Exhausted frame queue capacity (%zu frames)\n", global->max_queued);
1115 ✗ av_frame_free(&frame);
1116 ✗ return ret;
1117 }
1118 1721160 ff_filter_set_ready(link->dst, 300);
1119 1721160 return 0;
1120
1121 ✗ error:
1122 ✗ av_frame_free(&frame);
1123 ✗ return AVERROR_PATCHWELCOME;
1124 }
1125
1126 2455090 static int samples_ready(FilterLinkInternal *link, unsigned min)
1127 {
1128
2/2
✓ Branch 1 taken 820071 times.
✓ Branch 2 taken 1635019 times.
 3275161 return ff_framequeue_queued_frames(&link->fifo) &&
1129
2/2
✓ Branch 1 taken 135 times.
✓ Branch 2 taken 819936 times.
 820071 (ff_framequeue_queued_samples(&link->fifo) >= min ||
1130
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 134 times.
 135 link->status_in);
1131 }
1132
1133 2929 static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max,
1134 AVFrame **rframe)
1135 {
1136 2929 FilterLink *l = &li->l;
1137 2929 AVFilterLink *link = &l->pub;
1138 AVFrame *frame0, *frame, *buf;
1139 unsigned nb_samples, nb_frames, i, p;
1140 int ret;
1141
1142 /* Note: this function relies on no format changes and must only be
1143 called with enough samples. */
1144 av_assert1(samples_ready(li, l->min_samples));
1145 2929 frame0 = frame = ff_framequeue_peek(&li->fifo, 0);
1146
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) {
1147 1024 *rframe = ff_framequeue_take(&li->fifo);
1148 1024 return 0;
1149 }
1150 1905 nb_frames = 0;
1151 1905 nb_samples = 0;
1152 while (1) {
1153
2/2
✓ Branch 0 taken 1658 times.
✓ Branch 1 taken 1461 times.
 3119 if (nb_samples + frame->nb_samples > max) {
1154
2/2
✓ Branch 0 taken 1518 times.
✓ Branch 1 taken 140 times.
 1658 if (nb_samples < min)
1155 1518 nb_samples = max;
1156 1658 break;
1157 }
1158 1461 nb_samples += frame->nb_samples;
1159 1461 nb_frames++;
1160
2/2
✓ Branch 1 taken 247 times.
✓ Branch 2 taken 1214 times.
 1461 if (nb_frames == ff_framequeue_queued_frames(&li->fifo))
1161 247 break;
1162 1214 frame = ff_framequeue_peek(&li->fifo, nb_frames);
1163 }
1164
1165 1905 buf = ff_get_audio_buffer(link, nb_samples);
1166
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1905 times.
 1905 if (!buf)
1167 ✗ return AVERROR(ENOMEM);
1168 1905 ret = av_frame_copy_props(buf, frame0);
1169
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1905 times.
 1905 if (ret < 0) {
1170 ✗ av_frame_free(&buf);
1171 ✗ return ret;
1172 }
1173
1174 1905 p = 0;
1175
2/2
✓ Branch 0 taken 1461 times.
✓ Branch 1 taken 1905 times.
 3366 for (i = 0; i < nb_frames; i++) {
1176 1461 frame = ff_framequeue_take(&li->fifo);
1177 1461 av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1178 1461 frame->nb_samples, link->ch_layout.nb_channels, link->format);
1179 1461 p += frame->nb_samples;
1180 1461 av_frame_free(&frame);
1181 }
1182
2/2
✓ Branch 0 taken 1518 times.
✓ Branch 1 taken 387 times.
 1905 if (p < nb_samples) {
1183 1518 unsigned n = nb_samples - p;
1184 1518 frame = ff_framequeue_peek(&li->fifo, 0);
1185 1518 av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1186 1518 link->ch_layout.nb_channels, link->format);
1187 1518 ff_framequeue_skip_samples(&li->fifo, n, link->time_base);
1188 }
1189
1190 1905 *rframe = buf;
1191 1905 return 0;
1192 }
1193
1194 819937 static int filter_frame_to_filter(AVFilterLink *link)
1195 {
1196 819937 FilterLinkInternal * const li = ff_link_internal(link);
1197 819937 AVFrame *frame = NULL;
1198 819937 AVFilterContext *dst = link->dst;
1199 int ret;
1200
1201 av_assert1(ff_framequeue_queued_frames(&li->fifo));
1202 1639874 ret = li->l.min_samples ?
1203
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 819901 times.
 819937 ff_inlink_consume_samples(link, li->l.min_samples, li->l.max_samples, &frame) :
1204 819901 ff_inlink_consume_frame(link, &frame);
1205 av_assert1(ret);
1206
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 819937 times.
 819937 if (ret < 0) {
1207 av_assert1(!frame);
1208 ✗ return ret;
1209 }
1210 /* The filter will soon have received a new frame, that may allow it to
1211 produce one or more: unblock its outputs. */
1212 819937 filter_unblock(dst);
1213 /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1214 before the frame; filter_frame_framed() will re-increment it. */
1215 819937 li->l.frame_count_out--;
1216 819937 ret = filter_frame_framed(link, frame);
1217
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 819937 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 819937 if (ret < 0 && ret != li->status_out) {
1218 ✗ link_set_out_status(link, ret, AV_NOPTS_VALUE);
1219 } else {
1220 /* Run once again, to see if several frames were available, or if
1221 the input status has also changed, or any other reason. */
1222 819937 ff_filter_set_ready(dst, 300);
1223 }
1224 819937 return ret;
1225 }
1226
1227 6193 static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
1228 {
1229 6193 AVFilterLink *in = &li_in->l.pub;
1230 6193 unsigned out = 0, progress = 0;
1231 int ret;
1232
1233
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6193 times.
 6193 av_assert0(!li_in->status_out);
1234
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6192 times.
 6193 if (!filter->nb_outputs) {
1235 /* not necessary with the current API and sinks */
1236 1 return 0;
1237 }
1238
2/2
✓ Branch 0 taken 6192 times.
✓ Branch 1 taken 6192 times.
 12384 while (!li_in->status_out) {
1239 6192 FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1240
1241
1/2
✓ Branch 0 taken 6192 times.
✗ Branch 1 not taken.
 6192 if (!li_out->status_in) {
1242 6192 progress++;
1243 6192 ret = request_frame_to_filter(filter->outputs[out]);
1244
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6192 times.
 6192 if (ret < 0)
1245 ✗ return ret;
1246 }
1247
1/2
✓ Branch 0 taken 6192 times.
✗ Branch 1 not taken.
 6192 if (++out == filter->nb_outputs) {
1248
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6192 times.
 6192 if (!progress) {
1249 /* Every output already closed: input no longer interesting
1250 (example: overlay in shortest mode, other input closed). */
1251 ✗ link_set_out_status(in, li_in->status_in, li_in->status_in_pts);
1252 ✗ return 0;
1253 }
1254 6192 progress = 0;
1255 6192 out = 0;
1256 }
1257 }
1258 6192 ff_filter_set_ready(filter, 200);
1259 6192 return 0;
1260 }
1261
1262 2462463 static int filter_activate_default(AVFilterContext *filter)
1263 {
1264 unsigned i;
1265 2462463 int nb_eofs = 0;
1266
1267
2/2
✓ Branch 0 taken 2462454 times.
✓ Branch 1 taken 2462463 times.
 4924917 for (i = 0; i < filter->nb_outputs; i++)
1268 2462454 nb_eofs += ff_outlink_get_status(filter->outputs[i]) == AVERROR_EOF;
1269
4/4
✓ Branch 0 taken 2462454 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 7098 times.
✓ Branch 3 taken 2455356 times.
 2462463 if (filter->nb_outputs && nb_eofs == filter->nb_outputs) {
1270
2/2
✓ Branch 0 taken 7098 times.
✓ Branch 1 taken 7098 times.
 14196 for (int j = 0; j < filter->nb_inputs; j++)
1271 7098 ff_inlink_set_status(filter->inputs[j], AVERROR_EOF);
1272 7098 return 0;
1273 }
1274
1275
2/2
✓ Branch 0 taken 2455090 times.
✓ Branch 1 taken 1635428 times.
 4090518 for (i = 0; i < filter->nb_inputs; i++) {
1276 2455090 FilterLinkInternal *li = ff_link_internal(filter->inputs[i]);
1277
2/2
✓ Branch 1 taken 819937 times.
✓ Branch 2 taken 1635153 times.
 2455090 if (samples_ready(li, li->l.min_samples)) {
1278 819937 return filter_frame_to_filter(filter->inputs[i]);
1279 }
1280 }
1281
2/2
✓ Branch 0 taken 1635153 times.
✓ Branch 1 taken 1629235 times.
 3264388 for (i = 0; i < filter->nb_inputs; i++) {
1282 1635153 FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1283
4/4
✓ Branch 0 taken 6224 times.
✓ Branch 1 taken 1628929 times.
✓ Branch 2 taken 6193 times.
✓ Branch 3 taken 31 times.
 1635153 if (li->status_in && !li->status_out) {
1284 av_assert1(!ff_framequeue_queued_frames(&li->fifo));
1285 6193 return forward_status_change(filter, li);
1286 }
1287 }
1288
2/2
✓ Branch 0 taken 1629231 times.
✓ Branch 1 taken 819760 times.
 2448991 for (i = 0; i < filter->nb_outputs; i++) {
1289 1629231 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1290
2/2
✓ Branch 0 taken 814325 times.
✓ Branch 1 taken 814906 times.
 1629231 if (li->frame_wanted_out &&
1291
2/2
✓ Branch 0 taken 809475 times.
✓ Branch 1 taken 4850 times.
 814325 !li->frame_blocked_in) {
1292 809475 return request_frame_to_filter(filter->outputs[i]);
1293 }
1294 }
1295
2/2
✓ Branch 0 taken 819756 times.
✓ Branch 1 taken 814910 times.
 1634666 for (i = 0; i < filter->nb_outputs; i++) {
1296 819756 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1297
2/2
✓ Branch 0 taken 4850 times.
✓ Branch 1 taken 814906 times.
 819756 if (li->frame_wanted_out)
1298 4850 return request_frame_to_filter(filter->outputs[i]);
1299 }
1300
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 814906 times.
 814910 if (!filter->nb_outputs) {
1301 4 ff_inlink_request_frame(filter->inputs[0]);
1302 4 return 0;
1303 }
1304 814906 return FFERROR_NOT_READY;
1305 }
1306
1307 /*
1308 Filter scheduling and activation
1309
1310 When a filter is activated, it must:
1311 - if possible, output a frame;
1312 - else, if relevant, forward the input status change;
1313 - else, check outputs for wanted frames and forward the requests.
1314
1315 The following AVFilterLink fields are used for activation:
1316
1317 - frame_wanted_out:
1318
1319 This field indicates if a frame is needed on this input of the
1320 destination filter. A positive value indicates that a frame is needed
1321 to process queued frames or internal data or to satisfy the
1322 application; a zero value indicates that a frame is not especially
1323 needed but could be processed anyway; a negative value indicates that a
1324 frame would just be queued.
1325
1326 It is set by filters using ff_request_frame() or ff_request_no_frame(),
1327 when requested by the application through a specific API or when it is
1328 set on one of the outputs.
1329
1330 It is cleared when a frame is sent from the source using
1331 ff_filter_frame().
1332
1333 It is also cleared when a status change is sent from the source using
1334 ff_avfilter_link_set_in_status().
1335
1336 - frame_blocked_in:
1337
1338 This field means that the source filter can not generate a frame as is.
1339 Its goal is to avoid repeatedly calling the request_frame() method on
1340 the same link.
1341
1342 It is set by the framework on all outputs of a filter before activating it.
1343
1344 It is automatically cleared by ff_filter_frame().
1345
1346 It is also automatically cleared by ff_avfilter_link_set_in_status().
1347
1348 It is also cleared on all outputs (using filter_unblock()) when
1349 something happens on an input: processing a frame or changing the
1350 status.
1351
1352 - fifo:
1353
1354 Contains the frames queued on a filter input. If it contains frames and
1355 frame_wanted_out is not set, then the filter can be activated. If that
1356 result in the filter not able to use these frames, the filter must set
1357 frame_wanted_out to ask for more frames.
1358
1359 - status_in and status_in_pts:
1360
1361 Status (EOF or error code) of the link and timestamp of the status
1362 change (in link time base, same as frames) as seen from the input of
1363 the link. The status change is considered happening after the frames
1364 queued in fifo.
1365
1366 It is set by the source filter using ff_avfilter_link_set_in_status().
1367
1368 - status_out:
1369
1370 Status of the link as seen from the output of the link. The status
1371 change is considered having already happened.
1372
1373 It is set by the destination filter using
1374 link_set_out_status().
1375
1376 Filters are activated according to the ready field, set using the
1377 ff_filter_set_ready(). Eventually, a priority queue will be used.
1378 ff_filter_set_ready() is called whenever anything could cause progress to
1379 be possible. Marking a filter ready when it is not is not a problem,
1380 except for the small overhead it causes.
1381
1382 Conditions that cause a filter to be marked ready are:
1383
1384 - frames added on an input link;
1385
1386 - changes in the input or output status of an input link;
1387
1388 - requests for a frame on an output link;
1389
1390 - after any actual processing using the legacy methods (filter_frame(),
1391 and request_frame() to acknowledge status changes), to run once more
1392 and check if enough input was present for several frames.
1393
1394 Examples of scenarios to consider:
1395
1396 - buffersrc: activate if frame_wanted_out to notify the application;
1397 activate when the application adds a frame to push it immediately.
1398
1399 - testsrc: activate only if frame_wanted_out to produce and push a frame.
1400
1401 - concat (not at stitch points): can process a frame on any output.
1402 Activate if frame_wanted_out on output to forward on the corresponding
1403 input. Activate when a frame is present on input to process it
1404 immediately.
1405
1406 - framesync: needs at least one frame on each input; extra frames on the
1407 wrong input will accumulate. When a frame is first added on one input,
1408 set frame_wanted_out<0 on it to avoid getting more (would trigger
1409 testsrc) and frame_wanted_out>0 on the other to allow processing it.
1410
1411 Activation of old filters:
1412
1413 In order to activate a filter implementing the legacy filter_frame() and
1414 request_frame() methods, perform the first possible of the following
1415 actions:
1416
1417 - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1418 frame and call filter_frame().
1419
1420 Rationale: filter frames as soon as possible instead of leaving them
1421 queued; frame_wanted_out < 0 is not possible since the old API does not
1422 set it nor provides any similar feedback; frame_wanted_out > 0 happens
1423 when min_samples > 0 and there are not enough samples queued.
1424
1425 - If an input has status_in set but not status_out, try to call
1426 request_frame() on one of the outputs in the hope that it will trigger
1427 request_frame() on the input with status_in and acknowledge it. This is
1428 awkward and fragile, filters with several inputs or outputs should be
1429 updated to direct activation as soon as possible.
1430
1431 - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1432 request_frame().
1433
1434 Rationale: checking frame_blocked_in is necessary to avoid requesting
1435 repeatedly on a blocked input if another is not blocked (example:
1436 [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1437
1438 - If an output has frame_wanted_out > 0 call request_frame().
1439
1440 Rationale: even if all inputs are blocked an activate callback should
1441 request a frame on some if its inputs if a frame is requested on any of
1442 its output.
1443
1444 - Request a frame on the input for sinks.
1445
1446 Rationale: sinks using the old api have no way to request a frame on their
1447 input, so we need to do it for them.
1448 */
1449
1450 4281451 int ff_filter_activate(AVFilterContext *filter)
1451 {
1452 4281451 FFFilterContext *ctxi = fffilterctx(filter);
1453 4281451 const FFFilter *const fi = fffilter(filter->filter);
1454 int ret;
1455
1456 /* Generic timeline support is not yet implemented but should be easy */
1457 av_assert1(!(fi->p.flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
1458 fi->activate));
1459 4281451 ctxi->ready = 0;
1460
2/2
✓ Branch 0 taken 1818988 times.
✓ Branch 1 taken 2462463 times.
 4281451 ret = fi->activate ? fi->activate(filter) : filter_activate_default(filter);
1461
2/2
✓ Branch 0 taken 815779 times.
✓ Branch 1 taken 3465672 times.
 4281451 if (ret == FFERROR_NOT_READY)
1462 815779 ret = 0;
1463 4281451 return ret;
1464 }
1465
1466 3855821 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1467 {
1468 3855821 FilterLinkInternal * const li = ff_link_internal(link);
1469 3855821 *rpts = li->l.current_pts;
1470
2/2
✓ Branch 1 taken 2181 times.
✓ Branch 2 taken 3853640 times.
 3855821 if (ff_framequeue_queued_frames(&li->fifo))
1471 2181 return *rstatus = 0;
1472
2/2
✓ Branch 0 taken 8198 times.
✓ Branch 1 taken 3845442 times.
 3853640 if (li->status_out)
1473 8198 return *rstatus = li->status_out;
1474
2/2
✓ Branch 0 taken 3837334 times.
✓ Branch 1 taken 8108 times.
 3845442 if (!li->status_in)
1475 3837334 return *rstatus = 0;
1476 8108 *rstatus = li->status_out = li->status_in;
1477 8108 update_link_current_pts(li, li->status_in_pts);
1478 8108 *rpts = li->l.current_pts;
1479 8108 return 1;
1480 }
1481
1482 1934 size_t ff_inlink_queued_frames(AVFilterLink *link)
1483 {
1484 1934 FilterLinkInternal * const li = ff_link_internal(link);
1485 1934 return ff_framequeue_queued_frames(&li->fifo);
1486 }
1487
1488 5564094 int ff_inlink_check_available_frame(AVFilterLink *link)
1489 {
1490 5564094 FilterLinkInternal * const li = ff_link_internal(link);
1491 5564094 return ff_framequeue_queued_frames(&li->fifo) > 0;
1492 }
1493
1494 8479 int ff_inlink_queued_samples(AVFilterLink *link)
1495 {
1496 8479 FilterLinkInternal * const li = ff_link_internal(link);
1497 8479 return ff_framequeue_queued_samples(&li->fifo);
1498 }
1499
1500 4804 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1501 {
1502 4804 FilterLinkInternal * const li = ff_link_internal(link);
1503 4804 uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1504 av_assert1(min);
1505
6/6
✓ Branch 0 taken 1881 times.
✓ Branch 1 taken 2923 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 1816 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 59 times.
 4804 return samples >= min || (li->status_in && samples);
1506 }
1507
1508 1718625 static void consume_update(FilterLinkInternal *li, const AVFrame *frame)
1509 {
1510 1718625 AVFilterLink *const link = &li->l.pub;
1511 1718625 update_link_current_pts(li, frame->pts);
1512 1718625 ff_inlink_process_commands(link, frame);
1513
2/2
✓ Branch 0 taken 1715893 times.
✓ Branch 1 taken 2732 times.
 1718625 if (link == link->dst->inputs[0])
1514 1715893 link->dst->is_disabled = !evaluate_timeline_at_frame(link, frame);
1515 1718625 li->l.frame_count_out++;
1516 1718625 li->l.sample_count_out += frame->nb_samples;
1517 1718625 }
1518
1519 5561979 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1520 {
1521 5561979 FilterLinkInternal * const li = ff_link_internal(link);
1522 AVFrame *frame;
1523
1524 5561979 *rframe = NULL;
1525
2/2
✓ Branch 1 taken 3846279 times.
✓ Branch 2 taken 1715700 times.
 5561979 if (!ff_inlink_check_available_frame(link))
1526 3846279 return 0;
1527
1528
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1715696 times.
 1715700 if (li->fifo.samples_skipped) {
1529 4 frame = ff_framequeue_peek(&li->fifo, 0);
1530 4 return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1531 }
1532
1533 1715696 frame = ff_framequeue_take(&li->fifo);
1534 1715696 consume_update(li, frame);
1535 1715696 *rframe = frame;
1536 1715696 return 1;
1537 }
1538
1539 4804 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1540 AVFrame **rframe)
1541 {
1542 4804 FilterLinkInternal * const li = ff_link_internal(link);
1543 AVFrame *frame;
1544 int ret;
1545
1546 av_assert1(min);
1547 4804 *rframe = NULL;
1548
2/2
✓ Branch 1 taken 1875 times.
✓ Branch 2 taken 2929 times.
 4804 if (!ff_inlink_check_available_samples(link, min))
1549 1875 return 0;
1550
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 2901 times.
 2929 if (li->status_in)
1551
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 22 times.
 28 min = FFMIN(min, ff_framequeue_queued_samples(&li->fifo));
1552 2929 ret = take_samples(li, min, max, &frame);
1553
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2929 times.
 2929 if (ret < 0)
1554 ✗ return ret;
1555 2929 consume_update(li, frame);
1556 2929 *rframe = frame;
1557 2929 return 1;
1558 }
1559
1560 210 AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
1561 {
1562 210 FilterLinkInternal * const li = ff_link_internal(link);
1563 210 return ff_framequeue_peek(&li->fifo, idx);
1564 }
1565
1566 5189 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1567 {
1568 5189 AVFrame *frame = *rframe;
1569 AVFrame *out;
1570 int ret;
1571
1572
2/2
✓ Branch 1 taken 2278 times.
✓ Branch 2 taken 2911 times.
 5189 if (av_frame_is_writable(frame))
1573 2278 return 0;
1574 2911 av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1575
1576
1/3
✓ Branch 0 taken 2911 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 2911 switch (link->type) {
1577 2911 case AVMEDIA_TYPE_VIDEO:
1578 2911 out = ff_get_video_buffer(link, link->w, link->h);
1579 2911 break;
1580 ✗ case AVMEDIA_TYPE_AUDIO:
1581 ✗ out = ff_get_audio_buffer(link, frame->nb_samples);
1582 ✗ break;
1583 ✗ default:
1584 ✗ return AVERROR(EINVAL);
1585 }
1586
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2911 times.
 2911 if (!out)
1587 ✗ return AVERROR(ENOMEM);
1588
1589 2911 ret = av_frame_copy_props(out, frame);
1590
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2911 times.
 2911 if (ret < 0) {
1591 ✗ av_frame_free(&out);
1592 ✗ return ret;
1593 }
1594
1595 2911 ret = av_frame_copy(out, frame);
1596
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2911 times.
 2911 if (ret < 0) {
1597 ✗ av_frame_free(&out);
1598 ✗ return ret;
1599 }
1600
1601 2911 av_frame_free(&frame);
1602 2911 *rframe = out;
1603 2911 return 0;
1604 }
1605
1606 2538562 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1607 {
1608 2538562 FFFilterContext *ctxi = fffilterctx(link->dst);
1609 2538562 AVFilterCommand *cmd = ctxi->command_queue;
1610
1611
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2538562 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 2538562 while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1612 ✗ av_log(link->dst, AV_LOG_DEBUG,
1613 "Processing command time:%f command:%s arg:%s\n",
1614 cmd->time, cmd->command, cmd->arg);
1615 ✗ avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1616 ✗ command_queue_pop(link->dst);
1617 ✗ cmd = ctxi->command_queue;
1618 }
1619 2538562 return 0;
1620 }
1621
1622 905273 void ff_inlink_request_frame(AVFilterLink *link)
1623 {
1624 905273 av_unused FilterLinkInternal *li = ff_link_internal(link);
1625 av_assert1(!li->status_in);
1626 av_assert1(!li->status_out);
1627 905273 li->frame_wanted_out = 1;
1628 905273 ff_filter_set_ready(link->src, 100);
1629 905273 }
1630
1631 11272 void ff_inlink_set_status(AVFilterLink *link, int status)
1632 {
1633 11272 FilterLinkInternal * const li = ff_link_internal(link);
1634
2/2
✓ Branch 0 taken 8733 times.
✓ Branch 1 taken 2539 times.
 11272 if (li->status_out)
1635 8733 return;
1636 2539 li->frame_wanted_out = 0;
1637 2539 li->frame_blocked_in = 0;
1638 2539 link_set_out_status(link, status, AV_NOPTS_VALUE);
1639
2/2
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2539 times.
 2547 while (ff_framequeue_queued_frames(&li->fifo)) {
1640 8 AVFrame *frame = ff_framequeue_take(&li->fifo);
1641 8 av_frame_free(&frame);
1642 }
1643
2/2
✓ Branch 0 taken 2535 times.
✓ Branch 1 taken 4 times.
 2539 if (!li->status_in)
1644 2535 li->status_in = status;
1645 }
1646
1647 4204809 int ff_outlink_get_status(AVFilterLink *link)
1648 {
1649 4204809 FilterLinkInternal * const li = ff_link_internal(link);
1650 4204809 return li->status_in;
1651 }
1652
1653 1668 int ff_inoutlink_check_flow(AVFilterLink *inlink, AVFilterLink *outlink)
1654 {
1655 1668 FilterLinkInternal * const li_in = ff_link_internal(inlink);
1656
2/2
✓ Branch 1 taken 982 times.
✓ Branch 2 taken 70 times.
 2720 return ff_outlink_frame_wanted(outlink) ||
1657
2/2
✓ Branch 0 taken 1052 times.
✓ Branch 1 taken 616 times.
 2720 ff_inlink_check_available_frame(inlink) ||
1658
2/2
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 927 times.
 982 li_in->status_out;
1659 }
1660
1661
1662 ✗ const AVClass *avfilter_get_class(void)
1663 {
1664 ✗ return &avfilter_class;
1665 }
1666
1667 ✗ int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link,
1668 int default_pool_size)
1669 {
1670 ✗ FilterLink *l = ff_filter_link(link);
1671 AVHWFramesContext *frames;
1672
1673 // Must already be set by caller.
1674 ✗ av_assert0(l->hw_frames_ctx);
1675
1676 ✗ frames = (AVHWFramesContext*)l->hw_frames_ctx->data;
1677
1678 ✗ if (frames->initial_pool_size == 0) {
1679 // Dynamic allocation is necessarily supported.
1680 ✗ } else if (avctx->extra_hw_frames >= 0) {
1681 ✗ frames->initial_pool_size += avctx->extra_hw_frames;
1682 } else {
1683 ✗ frames->initial_pool_size = default_pool_size;
1684 }
1685
1686 ✗ return 0;
1687 }
1688
1689 492357 int ff_outlink_frame_wanted(AVFilterLink *link)
1690 {
1691 492357 FilterLinkInternal * const li = ff_link_internal(link);
1692 492357 return li->frame_wanted_out;
1693 }
1694
1695 5103 int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func,
1696 void *arg, int *ret, int nb_jobs)
1697 {
1698 5103 return fffilterctx(ctx)->execute(ctx, func, arg, ret, nb_jobs);
1699 }
1700