FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/avfilter.c
Date: 2026-09-27 02:02:56
Exec Total Coverage
Lines: 677 853 79.4%
Functions: 58 66 87.9%
Branches: 367 516 71.1%
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 1732077 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 1732077 }
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 588 static int append_pad(unsigned *count, AVFilterPad **pads,
101 AVFilterLink ***links, AVFilterPad *newpad)
102 {
103 AVFilterLink **newlinks;
104 AVFilterPad *newpads;
105 588 unsigned idx = *count;
106
107 588 newpads = av_realloc_array(*pads, idx + 1, sizeof(*newpads));
108 588 newlinks = av_realloc_array(*links, idx + 1, sizeof(*newlinks));
109
1/2
✓ Branch 0 taken 588 times.
✗ Branch 1 not taken.
 588 if (newpads)
110 588 *pads = newpads;
111
1/2
✓ Branch 0 taken 588 times.
✗ Branch 1 not taken.
 588 if (newlinks)
112 588 *links = newlinks;
113
2/4
✓ Branch 0 taken 588 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 588 times.
 588 if (!newpads || !newlinks) {
114 ✗ if (newpad->flags & AVFILTERPAD_FLAG_FREE_NAME)
115 ✗ av_freep(&newpad->name);
116 ✗ return AVERROR(ENOMEM);
117 }
118
119 588 memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
120 588 (*links)[idx] = NULL;
121
122 588 (*count)++;
123
124 588 return 0;
125 }
126
127 293 int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
128 {
129 293 return append_pad(&f->nb_inputs, &f->input_pads, &f->inputs, p);
130 }
131
132 272 int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
133 {
134 272 p->flags |= AVFILTERPAD_FLAG_FREE_NAME;
135 272 return ff_append_inpad(f, p);
136 }
137
138 295 int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
139 {
140 295 return append_pad(&f->nb_outputs, &f->output_pads, &f->outputs, p);
141 }
142
143 153 int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
144 {
145 153 p->flags |= AVFILTERPAD_FLAG_FREE_NAME;
146 153 return ff_append_outpad(f, p);
147 }
148
149 47988 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 47988 times.
 47988 av_assert0(src->graph);
156
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47988 times.
 47988 av_assert0(dst->graph);
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47988 times.
 47988 av_assert0(src->graph == dst->graph);
158
159
2/4
✓ Branch 0 taken 47988 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 47988 times.
✗ Branch 3 not taken.
 47988 if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
160
2/4
✓ Branch 0 taken 47988 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 47988 times.
 47988 src->outputs[srcpad] || dst->inputs[dstpad])
161 ✗ return AVERROR(EINVAL);
162
163
1/2
✓ Branch 1 taken 47988 times.
✗ Branch 2 not taken.
 47988 if (!(fffilterctx(src)->state_flags & AV_CLASS_STATE_INITIALIZED) ||
164
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47988 times.
 47988 !(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 47988 times.
 47988 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 47988 li = av_mallocz(sizeof(*li));
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47988 times.
 47988 if (!li)
179 ✗ return AVERROR(ENOMEM);
180 47988 link = &li->l.pub;
181
182 47988 src->outputs[srcpad] = dst->inputs[dstpad] = link;
183
184 47988 link->src = src;
185 47988 link->dst = dst;
186 47988 link->srcpad = &src->output_pads[srcpad];
187 47988 link->dstpad = &dst->input_pads[dstpad];
188 47988 link->type = src->output_pads[srcpad].type;
189 47988 li->l.graph = src->graph;
190 av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
191 47988 link->format = -1;
192 47988 link->colorspace = AVCOL_SPC_UNSPECIFIED;
193 47988 ff_framequeue_init(&li->fifo, &fffiltergraph(src->graph)->frame_queues);
194
195 47988 return 0;
196 }
197
198 48120 static void link_free(AVFilterLink **link)
199 {
200 FilterLinkInternal *li;
201
202
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48120 times.
 48120 if (!*link)
203 ✗ return;
204 48120 li = ff_link_internal(*link);
205
206 48120 ff_framequeue_free(&li->fifo);
207 48120 ff_frame_pool_uninit(&li->frame_pool);
208 48120 av_channel_layout_uninit(&(*link)->ch_layout);
209 48120 av_frame_side_data_free(&(*link)->side_data, &(*link)->nb_side_data);
210
211 48120 av_buffer_unref(&li->l.hw_frames_ctx);
212
213 48120 av_freep(link);
214 }
215
216 1743970 static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
217 {
218 1743970 AVFilterLink *const link = &li->l.pub;
219
220
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1743965 times.
 1743970 if (pts == AV_NOPTS_VALUE)
221 5 return;
222 1743965 li->l.current_pts = pts;
223 1743965 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 1743965 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 470180 times.
✓ Branch 3 taken 1273785 times.
 1743965 if (li->l.graph && li->age_index >= 0)
226 470180 ff_avfilter_graph_update_heap(li->l.graph, li);
227 }
228
229 4323214 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
230 {
231 4323214 FFFilterContext *ctxi = fffilterctx(filter);
232 4323214 ctxi->ready = FFMAX(ctxi->ready, priority);
233 4323214 }
234
235 /**
236 * Clear frame_blocked_in on all outputs.
237 * This is necessary whenever something changes on input.
238 */
239 2580520 static void filter_unblock(AVFilterContext *filter)
240 {
241 unsigned i;
242
243
2/2
✓ Branch 0 taken 2110426 times.
✓ Branch 1 taken 2580520 times.
 4690946 for (i = 0; i < filter->nb_outputs; i++) {
244 2110426 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
245 2110426 li->frame_blocked_in = 0;
246 }
247 2580520 }
248
249
250 20216 void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
251 {
252 20216 FilterLinkInternal * const li = ff_link_internal(link);
253
254
2/2
✓ Branch 0 taken 5737 times.
✓ Branch 1 taken 14479 times.
 20216 if (li->status_in == status)
255 5737 return;
256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14479 times.
 14479 av_assert0(!li->status_in);
257 14479 li->status_in = status;
258 14479 li->status_in_pts = pts;
259 14479 li->frame_wanted_out = 0;
260 14479 li->frame_blocked_in = 0;
261 14479 filter_unblock(link->dst);
262 14479 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 8808 static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
270 {
271 8808 FilterLinkInternal * const li = ff_link_internal(link);
272
273
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8808 times.
 8808 av_assert0(!li->frame_wanted_out);
274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8808 times.
 8808 av_assert0(!li->status_out);
275 8808 li->status_out = status;
276
2/2
✓ Branch 0 taken 6263 times.
✓ Branch 1 taken 2545 times.
 8808 if (pts != AV_NOPTS_VALUE)
277 6263 update_link_current_pts(li, pts);
278 8808 filter_unblock(link->dst);
279 8808 ff_filter_set_ready(link->src, 200);
280 8808 }
281
282 1336 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
283 unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
284 {
285 int ret;
286 1336 unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
287
288 1336 av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
289 "between the filter '%s' and the filter '%s'\n",
290 1336 filt->name, link->src->name, link->dst->name);
291
292 1336 link->dst->inputs[dstpad_idx] = NULL;
293
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1336 times.
 1336 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 1336 link->dst = filt;
301 1336 link->dstpad = &filt->input_pads[filt_srcpad_idx];
302 1336 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 1336 times.
✗ Branch 1 not taken.
 1336 if (link->outcfg.formats)
307 1336 ff_formats_changeref(&link->outcfg.formats,
308 1336 &filt->outputs[filt_dstpad_idx]->outcfg.formats);
309
2/2
✓ Branch 0 taken 634 times.
✓ Branch 1 taken 702 times.
 1336 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 702 times.
 1336 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 702 times.
 1336 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 702 times.
✓ Branch 1 taken 634 times.
 1336 if (link->outcfg.samplerates)
319 702 ff_formats_changeref(&link->outcfg.samplerates,
320 702 &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
321
2/2
✓ Branch 0 taken 702 times.
✓ Branch 1 taken 634 times.
 1336 if (link->outcfg.channel_layouts)
322 702 ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
323 702 &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
324
325 1336 return 0;
326 }
327
328 46107 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 37706 times.
✓ Branch 1 taken 46103 times.
 83809 for (i = 0; i < filter->nb_inputs; i ++) {
335 37706 AVFilterLink *link = filter->inputs[i];
336 AVFilterLink *inlink;
337 37706 FilterLinkInternal *li = ff_link_internal(link);
338 FilterLinkInternal *li_in;
339
340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37706 times.
 37706 if (!link) continue;
341
2/4
✓ Branch 0 taken 37706 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 37706 times.
 37706 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 29101 times.
✓ Branch 1 taken 8605 times.
 37706 inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
348
2/2
✓ Branch 0 taken 29101 times.
✓ Branch 1 taken 8605 times.
 37706 li_in = inlink ? ff_link_internal(inlink) : NULL;
349 37706 li->l.current_pts =
350 37706 li->l.current_pts_us = AV_NOPTS_VALUE;
351
352
3/4
✓ Branch 0 taken 112 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 37592 times.
✗ Branch 3 not taken.
 37706 switch (li->init_state) {
353 112 case AVLINK_INIT:
354 112 continue;
355 2 case AVLINK_STARTINIT:
356 2 av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
357 2 return 0;
358 37592 case AVLINK_UNINIT:
359 37592 li->init_state = AVLINK_STARTINIT;
360
361
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 37591 times.
 37592 if ((ret = ff_filter_config_links(link->src)) < 0)
362 1 return ret;
363
364
2/2
✓ Branch 0 taken 19677 times.
✓ Branch 1 taken 17914 times.
 37591 if (!(config_link = link->srcpad->config_props)) {
365
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19677 times.
 19677 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 29020 times.
✓ Branch 1 taken 8571 times.
✓ Branch 2 taken 332 times.
✓ Branch 3 taken 28688 times.
✓ Branch 4 taken 332 times.
✗ Branch 5 not taken.
 37591 if (inlink && inlink->nb_side_data && !link->nb_side_data) {
377
2/2
✓ Branch 0 taken 377 times.
✓ Branch 1 taken 332 times.
 709 for (int j = 0; j < inlink->nb_side_data; j++) {
378 377 ret = av_frame_side_data_clone(&link->side_data, &link->nb_side_data,
379 377 inlink->side_data[j], 0);
380
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 377 times.
 377 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 17914 times.
✓ Branch 1 taken 19677 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 17913 times.
 37591 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 31196 times.
✓ Branch 1 taken 6394 times.
✗ Branch 2 not taken.
 37590 switch (link->type) {
395 31196 case AVMEDIA_TYPE_VIDEO:
396
3/4
✓ Branch 0 taken 23858 times.
✓ Branch 1 taken 7338 times.
✓ Branch 2 taken 23858 times.
✗ Branch 3 not taken.
 31196 if (!link->time_base.num && !link->time_base.den)
397
1/2
✓ Branch 0 taken 23858 times.
✗ Branch 1 not taken.
 23858 link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
398
399
4/4
✓ Branch 0 taken 26648 times.
✓ Branch 1 taken 4548 times.
✓ Branch 2 taken 16970 times.
✓ Branch 3 taken 9678 times.
 31196 if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
400 16970 link->sample_aspect_ratio = inlink ?
401
2/2
✓ Branch 0 taken 16955 times.
✓ Branch 1 taken 15 times.
 16970 inlink->sample_aspect_ratio : (AVRational){1,1};
402
403
2/2
✓ Branch 0 taken 24125 times.
✓ Branch 1 taken 7071 times.
 31196 if (inlink) {
404
3/4
✓ Branch 0 taken 23901 times.
✓ Branch 1 taken 224 times.
✓ Branch 2 taken 23901 times.
✗ Branch 3 not taken.
 24125 if (!li->l.frame_rate.num && !li->l.frame_rate.den)
405 23901 li->l.frame_rate = li_in->l.frame_rate;
406
2/2
✓ Branch 0 taken 16466 times.
✓ Branch 1 taken 7659 times.
 24125 if (!link->w)
407 16466 link->w = inlink->w;
408
2/2
✓ Branch 0 taken 16466 times.
✓ Branch 1 taken 7659 times.
 24125 if (!link->h)
409 16466 link->h = inlink->h;
410
2/4
✓ Branch 0 taken 7071 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7071 times.
 7071 } 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 31196 break;
417
418 6394 case AVMEDIA_TYPE_AUDIO:
419
2/2
✓ Branch 0 taken 4894 times.
✓ Branch 1 taken 1500 times.
 6394 if (inlink) {
420
3/4
✓ Branch 0 taken 3308 times.
✓ Branch 1 taken 1586 times.
✓ Branch 2 taken 3308 times.
✗ Branch 3 not taken.
 4894 if (!link->time_base.num && !link->time_base.den)
421 3308 link->time_base = inlink->time_base;
422 }
423
424
3/4
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 6306 times.
✓ Branch 2 taken 88 times.
✗ Branch 3 not taken.
 6394 if (!link->time_base.num && !link->time_base.den)
425 88 link->time_base = (AVRational) {1, link->sample_rate};
426 }
427
428
2/2
✓ Branch 0 taken 29019 times.
✓ Branch 1 taken 8571 times.
 37590 if (link->src->nb_inputs &&
429
1/2
✓ Branch 1 taken 29019 times.
✗ Branch 2 not taken.
 29019 !(fffilter(link->src->filter)->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
430 29019 FilterLink *l0 = ff_filter_link(link->src->inputs[0]);
431
432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 29019 times.
 29019 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 29019 times.
 29019 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 5083 times.
✓ Branch 1 taken 32507 times.
 37590 if ((config_link = link->dstpad->config_props))
443
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5083 times.
 5083 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 37590 li->init_state = AVLINK_INIT;
451 }
452 }
453
454 46103 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 825688 int ff_request_frame(AVFilterLink *link)
484 {
485 825688 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 11 times.
✓ Branch 1 taken 825677 times.
 825688 if (li->status_out)
491 11 return li->status_out;
492
2/2
✓ Branch 0 taken 6265 times.
✓ Branch 1 taken 819412 times.
 825677 if (li->status_in) {
493
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6265 times.
 6265 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 6265 link_set_out_status(link, li->status_in, li->status_in_pts);
502 6265 return li->status_out;
503 }
504 }
505 819412 li->frame_wanted_out = 1;
506 819412 ff_filter_set_ready(link->src, 100);
507 819412 return 0;
508 }
509
510 6257 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
511 {
512 unsigned i;
513 6257 int64_t r = INT64_MAX;
514
515
2/2
✓ Branch 0 taken 6256 times.
✓ Branch 1 taken 6257 times.
 12513 for (i = 0; i < ctx->nb_inputs; i++) {
516 6256 FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
517
1/2
✓ Branch 0 taken 6256 times.
✗ Branch 1 not taken.
 6256 if (li->status_out == status)
518 6256 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 6256 times.
✓ Branch 1 taken 1 times.
 6257 if (r < INT64_MAX)
521 6256 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 826008 static int request_frame_to_filter(AVFilterLink *link)
533 {
534 826008 FilterLinkInternal * const li = ff_link_internal(link);
535 826008 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 826008 li->frame_blocked_in = 1;
540
2/2
✓ Branch 0 taken 2041 times.
✓ Branch 1 taken 823967 times.
 826008 if (link->srcpad->request_frame)
541 2041 ret = link->srcpad->request_frame(link);
542
1/2
✓ Branch 0 taken 823967 times.
✗ Branch 1 not taken.
 823967 else if (link->src->inputs[0])
543 823967 ret = ff_request_frame(link->src->inputs[0]);
544
2/2
✓ Branch 0 taken 6257 times.
✓ Branch 1 taken 819751 times.
 826008 if (ret < 0) {
545
2/4
✓ Branch 0 taken 6257 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6257 times.
✗ Branch 3 not taken.
 6257 if (ret != AVERROR(EAGAIN) && ret != li->status_in)
546 6257 ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
547
1/2
✓ Branch 0 taken 6257 times.
✗ Branch 1 not taken.
 6257 if (ret == AVERROR_EOF)
548 6257 ret = 0;
549 }
550 826008 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 662 static const char *default_filter_name(void *filter_ctx)
637 {
638 662 AVFilterContext *ctx = filter_ctx;
639
1/2
✓ Branch 0 taken 662 times.
✗ Branch 1 not taken.
 662 return ctx->name ? ctx->name : ctx->filter->name;
640 }
641
642 58020 static void *filter_child_next(void *obj, void *prev)
643 {
644 58020 AVFilterContext *ctx = obj;
645
5/8
✓ Branch 0 taken 58014 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 58014 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 58014 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 58014 times.
✗ Branch 7 not taken.
 58020 if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
646 58014 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 1372 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 1428 times.
✓ Branch 1 taken 1372 times.
 2800 for (i = 0; i < nb_jobs; i++) {
694 1428 int r = func(ctx, arg, i, nb_jobs);
695
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1428 times.
 1428 if (ret)
696 ✗ ret[i] = r;
697 }
698 1372 return 0;
699 }
700
701 64761 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
702 {
703 FFFilterContext *ctx;
704 AVFilterContext *ret;
705 64761 const FFFilter *const fi = fffilter(filter);
706 64761 int preinited = 0;
707
708
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64761 times.
 64761 if (!filter)
709 ✗ return NULL;
710
711 64761 ctx = av_mallocz(sizeof(*ctx));
712
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64761 times.
 64761 if (!ctx)
713 ✗ return NULL;
714 64761 ret = &ctx->p;
715
716 64761 ret->av_class = &avfilter_class;
717 64761 ret->filter = filter;
718
1/2
✓ Branch 0 taken 64761 times.
✗ Branch 1 not taken.
 64761 ret->name = inst_name ? av_strdup(inst_name) : NULL;
719
2/2
✓ Branch 0 taken 57722 times.
✓ Branch 1 taken 7039 times.
 64761 if (fi->priv_size) {
720 57722 ret->priv = av_mallocz(fi->priv_size);
721
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 57722 times.
 57722 if (!ret->priv)
722 ✗ goto err;
723 }
724
2/2
✓ Branch 0 taken 13801 times.
✓ Branch 1 taken 50960 times.
 64761 if (fi->preinit) {
725
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13801 times.
 13801 if (fi->preinit(ret) < 0)
726 ✗ goto err;
727 13801 preinited = 1;
728 }
729
730 64761 av_opt_set_defaults(ret);
731
2/2
✓ Branch 0 taken 56463 times.
✓ Branch 1 taken 8298 times.
 64761 if (filter->priv_class) {
732 56463 *(const AVClass**)ret->priv = filter->priv_class;
733 56463 av_opt_set_defaults(ret->priv);
734 }
735
736 64761 ctx->execute = default_execute;
737
738 64761 ret->nb_inputs = fi->nb_inputs;
739
2/2
✓ Branch 0 taken 54830 times.
✓ Branch 1 taken 9931 times.
 64761 if (ret->nb_inputs ) {
740 54830 ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs));
741
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54830 times.
 54830 if (!ret->input_pads)
742 ✗ goto err;
743 54830 ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs));
744
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54830 times.
 54830 if (!ret->inputs)
745 ✗ goto err;
746 }
747
748 64761 ret->nb_outputs = fi->nb_outputs;
749
2/2
✓ Branch 0 taken 56149 times.
✓ Branch 1 taken 8612 times.
 64761 if (ret->nb_outputs) {
750 56149 ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 56149 times.
 56149 if (!ret->output_pads)
752 ✗ goto err;
753 56149 ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs));
754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 56149 times.
 56149 if (!ret->outputs)
755 ✗ goto err;
756 }
757
758 64761 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 111669 static void free_link(AVFilterLink *link)
776 {
777
2/2
✓ Branch 0 taken 63549 times.
✓ Branch 1 taken 48120 times.
 111669 if (!link)
778 63549 return;
779
780
2/2
✓ Branch 0 taken 47988 times.
✓ Branch 1 taken 132 times.
 48120 if (link->src)
781 47988 link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
782
2/2
✓ Branch 0 taken 47988 times.
✓ Branch 1 taken 132 times.
 48120 if (link->dst)
783 47988 link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
784
785 48120 ff_formats_unref(&link->incfg.formats);
786 48120 ff_formats_unref(&link->outcfg.formats);
787 48120 ff_formats_unref(&link->incfg.color_spaces);
788 48120 ff_formats_unref(&link->outcfg.color_spaces);
789 48120 ff_formats_unref(&link->incfg.color_ranges);
790 48120 ff_formats_unref(&link->outcfg.color_ranges);
791 48120 ff_formats_unref(&link->incfg.alpha_modes);
792 48120 ff_formats_unref(&link->outcfg.alpha_modes);
793 48120 ff_formats_unref(&link->incfg.samplerates);
794 48120 ff_formats_unref(&link->outcfg.samplerates);
795 48120 ff_channel_layouts_unref(&link->incfg.channel_layouts);
796 48120 ff_channel_layouts_unref(&link->outcfg.channel_layouts);
797 48120 link_free(&link);
798 }
799
800 64761 void avfilter_free(AVFilterContext *filter)
801 {
802 FFFilterContext *ctxi;
803 int i;
804
805
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64761 times.
 64761 if (!filter)
806 ✗ return;
807 64761 ctxi = fffilterctx(filter);
808
809
1/2
✓ Branch 0 taken 64761 times.
✗ Branch 1 not taken.
 64761 if (filter->graph)
810 64761 ff_filter_graph_remove_filter(filter->graph, filter);
811
812
2/2
✓ Branch 1 taken 50249 times.
✓ Branch 2 taken 14512 times.
 64761 if (fffilter(filter->filter)->uninit)
813 50249 fffilter(filter->filter)->uninit(filter);
814
815
2/2
✓ Branch 0 taken 55221 times.
✓ Branch 1 taken 64761 times.
 119982 for (i = 0; i < filter->nb_inputs; i++) {
816 55221 free_link(filter->inputs[i]);
817
2/2
✓ Branch 0 taken 272 times.
✓ Branch 1 taken 54949 times.
 55221 if (filter->input_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
818 272 av_freep(&filter->input_pads[i].name);
819 }
820
2/2
✓ Branch 0 taken 56448 times.
✓ Branch 1 taken 64761 times.
 121209 for (i = 0; i < filter->nb_outputs; i++) {
821 56448 free_link(filter->outputs[i]);
822
2/2
✓ Branch 0 taken 289 times.
✓ Branch 1 taken 56159 times.
 56448 if (filter->output_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
823 289 av_freep(&filter->output_pads[i].name);
824 }
825
826
2/2
✓ Branch 0 taken 56463 times.
✓ Branch 1 taken 8298 times.
 64761 if (filter->filter->priv_class)
827 56463 av_opt_free(filter->priv);
828
829 64761 av_buffer_unref(&filter->hw_device_ctx);
830
831 64761 av_freep(&filter->name);
832 64761 av_freep(&filter->input_pads);
833 64761 av_freep(&filter->output_pads);
834 64761 av_freep(&filter->inputs);
835 64761 av_freep(&filter->outputs);
836 64761 av_freep(&filter->priv);
837
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64761 times.
 64761 while (ctxi->command_queue)
838 ✗ command_queue_pop(filter);
839 64761 av_opt_free(filter);
840 64761 av_expr_free(ctxi->enable);
841 64761 ctxi->enable = NULL;
842 64761 av_freep(&ctxi->var_values);
843 64761 av_free(filter);
844 }
845
846 19566 int ff_filter_get_nb_threads(AVFilterContext *ctx)
847 {
848
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19566 times.
 19566 if (ctx->nb_threads > 0)
849 ✗ return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
850 19566 return ctx->graph->nb_threads;
851 }
852
853 34582 int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
854 AVDictionary **options, const char *args)
855 {
856 34582 const AVOption *o = NULL;
857 int ret;
858 34582 int offset= -1;
859
860
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34582 times.
 34582 if (!args)
861 ✗ return 0;
862
863
2/2
✓ Branch 0 taken 59830 times.
✓ Branch 1 taken 34582 times.
 94412 while (*args) {
864 char *parsed_key, *value;
865 const char *key;
866 59830 const char *shorthand = NULL;
867 59830 int additional_flags = 0;
868
869
4/4
✓ Branch 0 taken 46275 times.
✓ Branch 1 taken 13555 times.
✓ Branch 3 taken 44993 times.
✓ Branch 4 taken 1282 times.
 59830 if (priv_class && (o = av_opt_next(&priv_class, o))) {
870
4/4
✓ Branch 0 taken 43223 times.
✓ Branch 1 taken 1770 times.
✓ Branch 2 taken 4626 times.
✓ Branch 3 taken 38597 times.
 44993 if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
871 6396 continue;
872 38597 offset = o->offset;
873 38597 shorthand = o->name;
874 }
875
876 53434 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 53434 times.
 53434 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 27928 times.
✓ Branch 1 taken 25506 times.
 53434 if (*args)
888 27928 args++;
889
2/2
✓ Branch 0 taken 32279 times.
✓ Branch 1 taken 21155 times.
 53434 if (parsed_key) {
890 32279 key = parsed_key;
891 32279 additional_flags = AV_DICT_DONT_STRDUP_KEY;
892 32279 priv_class = NULL; /* reject all remaining shorthand */
893 } else {
894 21155 key = shorthand;
895 }
896
897 53434 av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
898
899 53434 av_dict_set(options, key, value,
900 additional_flags | AV_DICT_DONT_STRDUP_VAL | AV_DICT_MULTIKEY);
901 }
902
903 34582 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 64761 int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
920 {
921 64761 FFFilterContext *ctxi = fffilterctx(ctx);
922 64761 int ret = 0;
923
924
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64761 times.
 64761 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 64761 ret = av_opt_set_dict2(ctx, options, AV_OPT_SEARCH_CHILDREN);
930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64761 times.
 64761 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 1264 times.
✓ Branch 1 taken 63497 times.
 64761 if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
936
2/2
✓ Branch 0 taken 159 times.
✓ Branch 1 taken 1105 times.
 1264 ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
937
1/2
✓ Branch 1 taken 159 times.
✗ Branch 2 not taken.
 159 fffiltergraph(ctx->graph)->thread_execute) {
938 159 ctx->thread_type = AVFILTER_THREAD_SLICE;
939 159 ctxi->execute = fffiltergraph(ctx->graph)->thread_execute;
940 } else {
941 64602 ctx->thread_type = 0;
942 }
943
944
2/2
✓ Branch 1 taken 51079 times.
✓ Branch 2 taken 13682 times.
 64761 if (fffilter(ctx->filter)->init)
945 51079 ret = fffilter(ctx->filter)->init(ctx);
946
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 64760 times.
 64761 if (ret < 0)
947 1 return ret;
948
949
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 64754 times.
 64760 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 64760 ctxi->state_flags |= AV_CLASS_STATE_INITIALIZED;
956
957 64760 return 0;
958 }
959
960 21341 int avfilter_init_str(AVFilterContext *filter, const char *args)
961 {
962 21341 AVDictionary *options = NULL;
963 const AVDictionaryEntry *e;
964 21341 int ret = 0;
965
966
3/4
✓ Branch 0 taken 10652 times.
✓ Branch 1 taken 10689 times.
✓ Branch 2 taken 10652 times.
✗ Branch 3 not taken.
 21341 if (args && *args) {
967 10652 ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args);
968
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10652 times.
 10652 if (ret < 0)
969 ✗ goto fail;
970 }
971
972 21341 ret = avfilter_init_dict(filter, &options);
973
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21341 times.
 21341 if (ret < 0)
974 ✗ goto fail;
975
976
1/2
✓ Branch 1 taken 21341 times.
✗ Branch 2 not taken.
 21341 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 21341 fail:
983 21341 av_dict_free(&options);
984
985 21341 return ret;
986 }
987
988 15522 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
989 {
990 15522 return pads[pad_idx].name;
991 }
992
993 31409 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
994 {
995 31409 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 804382 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
1008 {
1009 804382 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 2551932 static int evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1019 {
1020 2551932 FilterLink *l = ff_filter_link(link);
1021 2551932 AVFilterContext *dstctx = link->dst;
1022 2551932 FFFilterContext *dsti = fffilterctx(dstctx);
1023 2551932 int64_t pts = frame->pts;
1024
1025
2/2
✓ Branch 0 taken 2551734 times.
✓ Branch 1 taken 198 times.
 2551932 if (!dstctx->enable_str)
1026 2551734 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 825156 static int filter_frame_framed(AVFilterLink *link, AVFrame *frame)
1037 {
1038 825156 FilterLink *l = ff_filter_link(link);
1039 int (*filter_frame)(AVFilterLink *, AVFrame *);
1040 825156 AVFilterContext *dstctx = link->dst;
1041 825156 AVFilterPad *dst = link->dstpad;
1042 int ret;
1043
1044
2/2
✓ Branch 0 taken 804373 times.
✓ Branch 1 taken 20783 times.
 825156 if (!(filter_frame = dst->filter_frame))
1045 804373 filter_frame = default_filter_frame;
1046
1047
2/2
✓ Branch 0 taken 2993 times.
✓ Branch 1 taken 822163 times.
 825156 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 825156 ff_inlink_process_commands(link, frame);
1054 825156 dstctx->is_disabled = !evaluate_timeline_at_frame(link, frame);
1055
1056
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 825137 times.
 825156 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 825156 ret = filter_frame(link, frame);
1060 825156 l->frame_count_out++;
1061 825156 return ret;
1062
1063 ✗ fail:
1064 ✗ av_frame_free(&frame);
1065 ✗ return ret;
1066 }
1067
1068 1732077 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1069 {
1070 1732077 FilterLinkInternal * const li = ff_link_internal(link);
1071 int ret;
1072 1732077 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 586926 times.
✓ Branch 1 taken 1145151 times.
 1732077 if (link->type == AVMEDIA_TYPE_VIDEO) {
1076
2/2
✓ Branch 0 taken 436527 times.
✓ Branch 1 taken 150399 times.
 586926 if (strcmp(link->dst->filter->name, "buffersink") &&
1077
2/2
✓ Branch 0 taken 260146 times.
✓ Branch 1 taken 176381 times.
 436527 strcmp(link->dst->filter->name, "format") &&
1078
2/2
✓ Branch 0 taken 260119 times.
✓ Branch 1 taken 27 times.
 260146 strcmp(link->dst->filter->name, "idet") &&
1079
2/2
✓ Branch 0 taken 168443 times.
✓ Branch 1 taken 91676 times.
 260119 strcmp(link->dst->filter->name, "null") &&
1080
2/2
✓ Branch 0 taken 57852 times.
✓ Branch 1 taken 110591 times.
 168443 strcmp(link->dst->filter->name, "scale") &&
1081
1/2
✓ Branch 0 taken 57852 times.
✗ Branch 1 not taken.
 57852 strcmp(link->dst->filter->name, "libplacebo") &&
1082
2/2
✓ Branch 0 taken 57729 times.
✓ Branch 1 taken 123 times.
 57852 strcmp(link->dst->filter->name, "hqdn3d")) {
1083 av_assert1(frame->format == link->format);
1084 av_assert1(frame->width == link->w);
1085 av_assert1(frame->height == link->h);
1086 57729 if (av_pix_fmt_desc_get(link->format)->flags & AV_PIX_FMT_FLAG_ALPHA)
1087 av_assert1(frame->alpha_mode == link->alpha_mode);
1088 }
1089 } else {
1090
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1145151 times.
 1145151 if (frame->format != link->format) {
1091 ✗ av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1092 ✗ goto error;
1093 }
1094
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1145151 times.
 1145151 if (av_channel_layout_compare(&frame->ch_layout, &link->ch_layout)) {
1095 ✗ av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1096 ✗ goto error;
1097 }
1098
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1145151 times.
 1145151 if (frame->sample_rate != link->sample_rate) {
1099 ✗ av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1100 ✗ goto error;
1101 }
1102
1103 1145151 frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1104 link->time_base);
1105 }
1106
1107 1732077 li->frame_blocked_in = li->frame_wanted_out = 0;
1108 1732077 li->l.frame_count_in++;
1109 1732077 li->l.sample_count_in += frame->nb_samples;
1110 1732077 filter_unblock(link->dst);
1111 1732077 ret = ff_framequeue_add(&li->fifo, frame);
1112
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1732077 times.
 1732077 if (ret < 0) {
1113 ✗ const FFFrameQueueGlobal *global = li->fifo.global;
1114 ✗ if (ret == AVERROR(ENOMEM) && global->queued >= global->max_queued)
1115 ✗ av_log(link->dst, AV_LOG_ERROR, "Exhausted frame queue capacity (%zu frames)\n", global->max_queued);
1116 ✗ av_frame_free(&frame);
1117 ✗ return ret;
1118 }
1119 1732077 ff_filter_set_ready(link->dst, 300);
1120 1732077 return 0;
1121
1122 ✗ error:
1123 ✗ av_frame_free(&frame);
1124 ✗ return AVERROR_PATCHWELCOME;
1125 }
1126
1127 2470927 static int samples_ready(FilterLinkInternal *link, unsigned min)
1128 {
1129
2/2
✓ Branch 1 taken 825290 times.
✓ Branch 2 taken 1645637 times.
 3296217 return ff_framequeue_queued_frames(&link->fifo) &&
1130
2/2
✓ Branch 1 taken 135 times.
✓ Branch 2 taken 825155 times.
 825290 (ff_framequeue_queued_samples(&link->fifo) >= min ||
1131
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 134 times.
 135 link->status_in);
1132 }
1133
1134 2941 static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max,
1135 AVFrame **rframe)
1136 {
1137 2941 FilterLink *l = &li->l;
1138 2941 AVFilterLink *link = &l->pub;
1139 AVFrame *frame0, *frame, *buf;
1140 unsigned nb_samples, nb_frames, i, p;
1141 int ret;
1142
1143 /* Note: this function relies on no format changes and must only be
1144 called with enough samples. */
1145 av_assert1(samples_ready(li, l->min_samples));
1146 2941 frame0 = frame = ff_framequeue_peek(&li->fifo, 0);
1147
6/6
✓ Branch 0 taken 1423 times.
✓ Branch 1 taken 1518 times.
✓ Branch 2 taken 1307 times.
✓ Branch 3 taken 116 times.
✓ Branch 4 taken 1030 times.
✓ Branch 5 taken 277 times.
 2941 if (!li->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1148 1030 *rframe = ff_framequeue_take(&li->fifo);
1149 1030 return 0;
1150 }
1151 1911 nb_frames = 0;
1152 1911 nb_samples = 0;
1153 while (1) {
1154
2/2
✓ Branch 0 taken 1648 times.
✓ Branch 1 taken 1482 times.
 3130 if (nb_samples + frame->nb_samples > max) {
1155
2/2
✓ Branch 0 taken 1522 times.
✓ Branch 1 taken 126 times.
 1648 if (nb_samples < min)
1156 1522 nb_samples = max;
1157 1648 break;
1158 }
1159 1482 nb_samples += frame->nb_samples;
1160 1482 nb_frames++;
1161
2/2
✓ Branch 1 taken 263 times.
✓ Branch 2 taken 1219 times.
 1482 if (nb_frames == ff_framequeue_queued_frames(&li->fifo))
1162 263 break;
1163 1219 frame = ff_framequeue_peek(&li->fifo, nb_frames);
1164 }
1165
1166 1911 buf = ff_get_audio_buffer(link, nb_samples);
1167
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1911 times.
 1911 if (!buf)
1168 ✗ return AVERROR(ENOMEM);
1169 1911 ret = av_frame_copy_props(buf, frame0);
1170
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1911 times.
 1911 if (ret < 0) {
1171 ✗ av_frame_free(&buf);
1172 ✗ return ret;
1173 }
1174
1175 1911 p = 0;
1176
2/2
✓ Branch 0 taken 1482 times.
✓ Branch 1 taken 1911 times.
 3393 for (i = 0; i < nb_frames; i++) {
1177 1482 frame = ff_framequeue_take(&li->fifo);
1178 1482 av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1179 1482 frame->nb_samples, link->ch_layout.nb_channels, link->format);
1180 1482 p += frame->nb_samples;
1181 1482 av_frame_free(&frame);
1182 }
1183
2/2
✓ Branch 0 taken 1522 times.
✓ Branch 1 taken 389 times.
 1911 if (p < nb_samples) {
1184 1522 unsigned n = nb_samples - p;
1185 1522 frame = ff_framequeue_peek(&li->fifo, 0);
1186 1522 av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1187 1522 link->ch_layout.nb_channels, link->format);
1188 1522 ff_framequeue_skip_samples(&li->fifo, n, link->time_base);
1189 }
1190
1191 1911 *rframe = buf;
1192 1911 return 0;
1193 }
1194
1195 825156 static int filter_frame_to_filter(AVFilterLink *link)
1196 {
1197 825156 FilterLinkInternal * const li = ff_link_internal(link);
1198 825156 AVFrame *frame = NULL;
1199 825156 AVFilterContext *dst = link->dst;
1200 int ret;
1201
1202 av_assert1(ff_framequeue_queued_frames(&li->fifo));
1203 1650312 ret = li->l.min_samples ?
1204
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 825120 times.
 825156 ff_inlink_consume_samples(link, li->l.min_samples, li->l.max_samples, &frame) :
1205 825120 ff_inlink_consume_frame(link, &frame);
1206 av_assert1(ret);
1207
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 825156 times.
 825156 if (ret < 0) {
1208 av_assert1(!frame);
1209 ✗ return ret;
1210 }
1211 /* The filter will soon have received a new frame, that may allow it to
1212 produce one or more: unblock its outputs. */
1213 825156 filter_unblock(dst);
1214 /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1215 before the frame; filter_frame_framed() will re-increment it. */
1216 825156 li->l.frame_count_out--;
1217 825156 ret = filter_frame_framed(link, frame);
1218
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 825156 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 825156 if (ret < 0 && ret != li->status_out) {
1219 ✗ link_set_out_status(link, ret, AV_NOPTS_VALUE);
1220 } else {
1221 /* Run once again, to see if several frames were available, or if
1222 the input status has also changed, or any other reason. */
1223 825156 ff_filter_set_ready(dst, 300);
1224 }
1225 825156 return ret;
1226 }
1227
1228 6265 static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
1229 {
1230 6265 AVFilterLink *in = &li_in->l.pub;
1231 6265 unsigned out = 0, progress = 0;
1232 int ret;
1233
1234
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6265 times.
 6265 av_assert0(!li_in->status_out);
1235
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6264 times.
 6265 if (!filter->nb_outputs) {
1236 /* not necessary with the current API and sinks */
1237 1 return 0;
1238 }
1239
2/2
✓ Branch 0 taken 6264 times.
✓ Branch 1 taken 6264 times.
 12528 while (!li_in->status_out) {
1240 6264 FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1241
1242
1/2
✓ Branch 0 taken 6264 times.
✗ Branch 1 not taken.
 6264 if (!li_out->status_in) {
1243 6264 progress++;
1244 6264 ret = request_frame_to_filter(filter->outputs[out]);
1245
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6264 times.
 6264 if (ret < 0)
1246 ✗ return ret;
1247 }
1248
1/2
✓ Branch 0 taken 6264 times.
✗ Branch 1 not taken.
 6264 if (++out == filter->nb_outputs) {
1249
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6264 times.
 6264 if (!progress) {
1250 /* Every output already closed: input no longer interesting
1251 (example: overlay in shortest mode, other input closed). */
1252 ✗ link_set_out_status(in, li_in->status_in, li_in->status_in_pts);
1253 ✗ return 0;
1254 }
1255 6264 progress = 0;
1256 6264 out = 0;
1257 }
1258 }
1259 6264 ff_filter_set_ready(filter, 200);
1260 6264 return 0;
1261 }
1262
1263 2478361 static int filter_activate_default(AVFilterContext *filter)
1264 {
1265 unsigned i;
1266 2478361 int nb_eofs = 0;
1267
1268
2/2
✓ Branch 0 taken 2478340 times.
✓ Branch 1 taken 2478361 times.
 4956701 for (i = 0; i < filter->nb_outputs; i++)
1269 2478340 nb_eofs += ff_outlink_get_status(filter->outputs[i]) == AVERROR_EOF;
1270
4/4
✓ Branch 0 taken 2478340 times.
✓ Branch 1 taken 21 times.
✓ Branch 2 taken 7168 times.
✓ Branch 3 taken 2471172 times.
 2478361 if (filter->nb_outputs && nb_eofs == filter->nb_outputs) {
1271
2/2
✓ Branch 0 taken 7168 times.
✓ Branch 1 taken 7168 times.
 14336 for (int j = 0; j < filter->nb_inputs; j++)
1272 7168 ff_inlink_set_status(filter->inputs[j], AVERROR_EOF);
1273 7168 return 0;
1274 }
1275
1276
2/2
✓ Branch 0 taken 2470927 times.
✓ Branch 1 taken 1646037 times.
 4116964 for (i = 0; i < filter->nb_inputs; i++) {
1277 2470927 FilterLinkInternal *li = ff_link_internal(filter->inputs[i]);
1278
2/2
✓ Branch 1 taken 825156 times.
✓ Branch 2 taken 1645771 times.
 2470927 if (samples_ready(li, li->l.min_samples)) {
1279 825156 return filter_frame_to_filter(filter->inputs[i]);
1280 }
1281 }
1282
2/2
✓ Branch 0 taken 1645771 times.
✓ Branch 1 taken 1639772 times.
 3285543 for (i = 0; i < filter->nb_inputs; i++) {
1283 1645771 FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1284
4/4
✓ Branch 0 taken 6300 times.
✓ Branch 1 taken 1639471 times.
✓ Branch 2 taken 6265 times.
✓ Branch 3 taken 35 times.
 1645771 if (li->status_in && !li->status_out) {
1285 av_assert1(!ff_framequeue_queued_frames(&li->fifo));
1286 6265 return forward_status_change(filter, li);
1287 }
1288 }
1289
2/2
✓ Branch 0 taken 1639762 times.
✓ Branch 1 taken 825056 times.
 2464818 for (i = 0; i < filter->nb_outputs; i++) {
1290 1639762 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1291
2/2
✓ Branch 0 taken 819744 times.
✓ Branch 1 taken 820018 times.
 1639762 if (li->frame_wanted_out &&
1292
2/2
✓ Branch 0 taken 814716 times.
✓ Branch 1 taken 5028 times.
 819744 !li->frame_blocked_in) {
1293 814716 return request_frame_to_filter(filter->outputs[i]);
1294 }
1295 }
1296
2/2
✓ Branch 0 taken 825046 times.
✓ Branch 1 taken 820028 times.
 1645074 for (i = 0; i < filter->nb_outputs; i++) {
1297 825046 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1298
2/2
✓ Branch 0 taken 5028 times.
✓ Branch 1 taken 820018 times.
 825046 if (li->frame_wanted_out)
1299 5028 return request_frame_to_filter(filter->outputs[i]);
1300 }
1301
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 820018 times.
 820028 if (!filter->nb_outputs) {
1302 10 ff_inlink_request_frame(filter->inputs[0]);
1303 10 return 0;
1304 }
1305 820018 return FFERROR_NOT_READY;
1306 }
1307
1308 /*
1309 Filter scheduling and activation
1310
1311 When a filter is activated, it must:
1312 - if possible, output a frame;
1313 - else, if relevant, forward the input status change;
1314 - else, check outputs for wanted frames and forward the requests.
1315
1316 The following AVFilterLink fields are used for activation:
1317
1318 - frame_wanted_out:
1319
1320 This field indicates if a frame is needed on this input of the
1321 destination filter. A positive value indicates that a frame is needed
1322 to process queued frames or internal data or to satisfy the
1323 application; a zero value indicates that a frame is not especially
1324 needed but could be processed anyway; a negative value indicates that a
1325 frame would just be queued.
1326
1327 It is set by filters using ff_request_frame() or ff_request_no_frame(),
1328 when requested by the application through a specific API or when it is
1329 set on one of the outputs.
1330
1331 It is cleared when a frame is sent from the source using
1332 ff_filter_frame().
1333
1334 It is also cleared when a status change is sent from the source using
1335 ff_avfilter_link_set_in_status().
1336
1337 - frame_blocked_in:
1338
1339 This field means that the source filter can not generate a frame as is.
1340 Its goal is to avoid repeatedly calling the request_frame() method on
1341 the same link.
1342
1343 It is set by the framework on all outputs of a filter before activating it.
1344
1345 It is automatically cleared by ff_filter_frame().
1346
1347 It is also automatically cleared by ff_avfilter_link_set_in_status().
1348
1349 It is also cleared on all outputs (using filter_unblock()) when
1350 something happens on an input: processing a frame or changing the
1351 status.
1352
1353 - fifo:
1354
1355 Contains the frames queued on a filter input. If it contains frames and
1356 frame_wanted_out is not set, then the filter can be activated. If that
1357 result in the filter not able to use these frames, the filter must set
1358 frame_wanted_out to ask for more frames.
1359
1360 - status_in and status_in_pts:
1361
1362 Status (EOF or error code) of the link and timestamp of the status
1363 change (in link time base, same as frames) as seen from the input of
1364 the link. The status change is considered happening after the frames
1365 queued in fifo.
1366
1367 It is set by the source filter using ff_avfilter_link_set_in_status().
1368
1369 - status_out:
1370
1371 Status of the link as seen from the output of the link. The status
1372 change is considered having already happened.
1373
1374 It is set by the destination filter using
1375 link_set_out_status().
1376
1377 Filters are activated according to the ready field, set using the
1378 ff_filter_set_ready(). Eventually, a priority queue will be used.
1379 ff_filter_set_ready() is called whenever anything could cause progress to
1380 be possible. Marking a filter ready when it is not is not a problem,
1381 except for the small overhead it causes.
1382
1383 Conditions that cause a filter to be marked ready are:
1384
1385 - frames added on an input link;
1386
1387 - changes in the input or output status of an input link;
1388
1389 - requests for a frame on an output link;
1390
1391 - after any actual processing using the legacy methods (filter_frame(),
1392 and request_frame() to acknowledge status changes), to run once more
1393 and check if enough input was present for several frames.
1394
1395 Examples of scenarios to consider:
1396
1397 - buffersrc: activate if frame_wanted_out to notify the application;
1398 activate when the application adds a frame to push it immediately.
1399
1400 - testsrc: activate only if frame_wanted_out to produce and push a frame.
1401
1402 - concat (not at stitch points): can process a frame on any output.
1403 Activate if frame_wanted_out on output to forward on the corresponding
1404 input. Activate when a frame is present on input to process it
1405 immediately.
1406
1407 - framesync: needs at least one frame on each input; extra frames on the
1408 wrong input will accumulate. When a frame is first added on one input,
1409 set frame_wanted_out<0 on it to avoid getting more (would trigger
1410 testsrc) and frame_wanted_out>0 on the other to allow processing it.
1411
1412 Activation of old filters:
1413
1414 In order to activate a filter implementing the legacy filter_frame() and
1415 request_frame() methods, perform the first possible of the following
1416 actions:
1417
1418 - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1419 frame and call filter_frame().
1420
1421 Rationale: filter frames as soon as possible instead of leaving them
1422 queued; frame_wanted_out < 0 is not possible since the old API does not
1423 set it nor provides any similar feedback; frame_wanted_out > 0 happens
1424 when min_samples > 0 and there are not enough samples queued.
1425
1426 - If an input has status_in set but not status_out, try to call
1427 request_frame() on one of the outputs in the hope that it will trigger
1428 request_frame() on the input with status_in and acknowledge it. This is
1429 awkward and fragile, filters with several inputs or outputs should be
1430 updated to direct activation as soon as possible.
1431
1432 - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1433 request_frame().
1434
1435 Rationale: checking frame_blocked_in is necessary to avoid requesting
1436 repeatedly on a blocked input if another is not blocked (example:
1437 [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1438
1439 - If an output has frame_wanted_out > 0 call request_frame().
1440
1441 Rationale: even if all inputs are blocked an activate callback should
1442 request a frame on some if its inputs if a frame is requested on any of
1443 its output.
1444
1445 - Request a frame on the input for sinks.
1446
1447 Rationale: sinks using the old api have no way to request a frame on their
1448 input, so we need to do it for them.
1449 */
1450
1451 4308893 int ff_filter_activate(AVFilterContext *filter)
1452 {
1453 4308893 FFFilterContext *ctxi = fffilterctx(filter);
1454 4308893 const FFFilter *const fi = fffilter(filter->filter);
1455 int ret;
1456
1457 /* Generic timeline support is not yet implemented but should be easy */
1458 av_assert1(!(fi->p.flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
1459 fi->activate));
1460 4308893 ctxi->ready = 0;
1461
2/2
✓ Branch 0 taken 1830532 times.
✓ Branch 1 taken 2478361 times.
 4308893 ret = fi->activate ? fi->activate(filter) : filter_activate_default(filter);
1462
2/2
✓ Branch 0 taken 820898 times.
✓ Branch 1 taken 3487995 times.
 4308893 if (ret == FFERROR_NOT_READY)
1463 820898 ret = 0;
1464 4308893 return ret;
1465 }
1466
1467 3878520 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1468 {
1469 3878520 FilterLinkInternal * const li = ff_link_internal(link);
1470 3878520 *rpts = li->l.current_pts;
1471
2/2
✓ Branch 1 taken 2170 times.
✓ Branch 2 taken 3876350 times.
 3878520 if (ff_framequeue_queued_frames(&li->fifo))
1472 2170 return *rstatus = 0;
1473
2/2
✓ Branch 0 taken 8079 times.
✓ Branch 1 taken 3868271 times.
 3876350 if (li->status_out)
1474 8079 return *rstatus = li->status_out;
1475
2/2
✓ Branch 0 taken 3860074 times.
✓ Branch 1 taken 8197 times.
 3868271 if (!li->status_in)
1476 3860074 return *rstatus = 0;
1477 8197 *rstatus = li->status_out = li->status_in;
1478 8197 update_link_current_pts(li, li->status_in_pts);
1479 8197 *rpts = li->l.current_pts;
1480 8197 return 1;
1481 }
1482
1483 1934 size_t ff_inlink_queued_frames(AVFilterLink *link)
1484 {
1485 1934 FilterLinkInternal * const li = ff_link_internal(link);
1486 1934 return ff_framequeue_queued_frames(&li->fifo);
1487 }
1488
1489 5597797 int ff_inlink_check_available_frame(AVFilterLink *link)
1490 {
1491 5597797 FilterLinkInternal * const li = ff_link_internal(link);
1492 5597797 return ff_framequeue_queued_frames(&li->fifo) > 0;
1493 }
1494
1495 8514 int ff_inlink_queued_samples(AVFilterLink *link)
1496 {
1497 8514 FilterLinkInternal * const li = ff_link_internal(link);
1498 8514 return ff_framequeue_queued_samples(&li->fifo);
1499 }
1500
1501 4869 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1502 {
1503 4869 FilterLinkInternal * const li = ff_link_internal(link);
1504 4869 uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1505 av_assert1(min);
1506
6/6
✓ Branch 0 taken 1934 times.
✓ Branch 1 taken 2935 times.
✓ Branch 2 taken 67 times.
✓ Branch 3 taken 1867 times.
✓ Branch 4 taken 7 times.
✓ Branch 5 taken 60 times.
 4869 return samples >= min || (li->status_in && samples);
1507 }
1508
1509 1729510 static void consume_update(FilterLinkInternal *li, const AVFrame *frame)
1510 {
1511 1729510 AVFilterLink *const link = &li->l.pub;
1512 1729510 update_link_current_pts(li, frame->pts);
1513 1729510 ff_inlink_process_commands(link, frame);
1514
2/2
✓ Branch 0 taken 1726776 times.
✓ Branch 1 taken 2734 times.
 1729510 if (link == link->dst->inputs[0])
1515 1726776 link->dst->is_disabled = !evaluate_timeline_at_frame(link, frame);
1516 1729510 li->l.frame_count_out++;
1517 1729510 li->l.sample_count_out += frame->nb_samples;
1518 1729510 }
1519
1520 5595536 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1521 {
1522 5595536 FilterLinkInternal * const li = ff_link_internal(link);
1523 AVFrame *frame;
1524
1525 5595536 *rframe = NULL;
1526
2/2
✓ Branch 1 taken 3868963 times.
✓ Branch 2 taken 1726573 times.
 5595536 if (!ff_inlink_check_available_frame(link))
1527 3868963 return 0;
1528
1529
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1726569 times.
 1726573 if (li->fifo.samples_skipped) {
1530 4 frame = ff_framequeue_peek(&li->fifo, 0);
1531 4 return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1532 }
1533
1534 1726569 frame = ff_framequeue_take(&li->fifo);
1535 1726569 consume_update(li, frame);
1536 1726569 *rframe = frame;
1537 1726569 return 1;
1538 }
1539
1540 4865 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1541 AVFrame **rframe)
1542 {
1543 4865 FilterLinkInternal * const li = ff_link_internal(link);
1544 AVFrame *frame;
1545 int ret;
1546
1547 av_assert1(min);
1548 4865 *rframe = NULL;
1549
2/2
✓ Branch 1 taken 1924 times.
✓ Branch 2 taken 2941 times.
 4865 if (!ff_inlink_check_available_samples(link, min))
1550 1924 return 0;
1551
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 2908 times.
 2941 if (li->status_in)
1552
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 27 times.
 33 min = FFMIN(min, ff_framequeue_queued_samples(&li->fifo));
1553 2941 ret = take_samples(li, min, max, &frame);
1554
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2941 times.
 2941 if (ret < 0)
1555 ✗ return ret;
1556 2941 consume_update(li, frame);
1557 2941 *rframe = frame;
1558 2941 return 1;
1559 }
1560
1561 210 AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
1562 {
1563 210 FilterLinkInternal * const li = ff_link_internal(link);
1564 210 return ff_framequeue_peek(&li->fifo, idx);
1565 }
1566
1567 5185 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1568 {
1569 5185 AVFrame *frame = *rframe;
1570 AVFrame *out;
1571 int ret;
1572
1573
2/2
✓ Branch 1 taken 2267 times.
✓ Branch 2 taken 2918 times.
 5185 if (av_frame_is_writable(frame))
1574 2267 return 0;
1575 2918 av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1576
1577
1/3
✓ Branch 0 taken 2918 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 2918 switch (link->type) {
1578 2918 case AVMEDIA_TYPE_VIDEO:
1579 2918 out = ff_get_video_buffer(link, link->w, link->h);
1580 2918 break;
1581 ✗ case AVMEDIA_TYPE_AUDIO:
1582 ✗ out = ff_get_audio_buffer(link, frame->nb_samples);
1583 ✗ break;
1584 ✗ default:
1585 ✗ return AVERROR(EINVAL);
1586 }
1587
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2918 times.
 2918 if (!out)
1588 ✗ return AVERROR(ENOMEM);
1589
1590 2918 ret = av_frame_copy_props(out, frame);
1591
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2918 times.
 2918 if (ret < 0) {
1592 ✗ av_frame_free(&out);
1593 ✗ return ret;
1594 }
1595
1596 2918 ret = av_frame_copy(out, frame);
1597
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2918 times.
 2918 if (ret < 0) {
1598 ✗ av_frame_free(&out);
1599 ✗ return ret;
1600 }
1601
1602 2918 av_frame_free(&frame);
1603 2918 *rframe = out;
1604 2918 return 0;
1605 }
1606
1607 2554666 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1608 {
1609 2554666 FFFilterContext *ctxi = fffilterctx(link->dst);
1610 2554666 AVFilterCommand *cmd = ctxi->command_queue;
1611
1612
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2554666 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 2554666 while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1613 ✗ av_log(link->dst, AV_LOG_DEBUG,
1614 "Processing command time:%f command:%s arg:%s\n",
1615 cmd->time, cmd->command, cmd->arg);
1616 ✗ avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1617 ✗ command_queue_pop(link->dst);
1618 ✗ cmd = ctxi->command_queue;
1619 }
1620 2554666 return 0;
1621 }
1622
1623 910868 void ff_inlink_request_frame(AVFilterLink *link)
1624 {
1625 910868 av_unused FilterLinkInternal *li = ff_link_internal(link);
1626 av_assert1(!li->status_in);
1627 av_assert1(!li->status_out);
1628 910868 li->frame_wanted_out = 1;
1629 910868 ff_filter_set_ready(link->src, 100);
1630 910868 }
1631
1632 11372 void ff_inlink_set_status(AVFilterLink *link, int status)
1633 {
1634 11372 FilterLinkInternal * const li = ff_link_internal(link);
1635
2/2
✓ Branch 0 taken 8829 times.
✓ Branch 1 taken 2543 times.
 11372 if (li->status_out)
1636 8829 return;
1637 2543 li->frame_wanted_out = 0;
1638 2543 li->frame_blocked_in = 0;
1639 2543 link_set_out_status(link, status, AV_NOPTS_VALUE);
1640
2/2
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 2543 times.
 2552 while (ff_framequeue_queued_frames(&li->fifo)) {
1641 9 AVFrame *frame = ff_framequeue_take(&li->fifo);
1642 9 av_frame_free(&frame);
1643 }
1644
2/2
✓ Branch 0 taken 2540 times.
✓ Branch 1 taken 3 times.
 2543 if (!li->status_in)
1645 2540 li->status_in = status;
1646 }
1647
1648 4232150 int ff_outlink_get_status(AVFilterLink *link)
1649 {
1650 4232150 FilterLinkInternal * const li = ff_link_internal(link);
1651 4232150 return li->status_in;
1652 }
1653
1654 1776 int ff_inoutlink_check_flow(AVFilterLink *inlink, AVFilterLink *outlink)
1655 {
1656 1776 FilterLinkInternal * const li_in = ff_link_internal(inlink);
1657
2/2
✓ Branch 1 taken 1056 times.
✓ Branch 2 taken 70 times.
 2902 return ff_outlink_frame_wanted(outlink) ||
1658
2/2
✓ Branch 0 taken 1126 times.
✓ Branch 1 taken 650 times.
 2902 ff_inlink_check_available_frame(inlink) ||
1659
2/2
✓ Branch 0 taken 59 times.
✓ Branch 1 taken 997 times.
 1056 li_in->status_out;
1660 }
1661
1662
1663 ✗ const AVClass *avfilter_get_class(void)
1664 {
1665 ✗ return &avfilter_class;
1666 }
1667
1668 ✗ int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link,
1669 int default_pool_size)
1670 {
1671 ✗ FilterLink *l = ff_filter_link(link);
1672 AVHWFramesContext *frames;
1673
1674 // Must already be set by caller.
1675 ✗ av_assert0(l->hw_frames_ctx);
1676
1677 ✗ frames = (AVHWFramesContext*)l->hw_frames_ctx->data;
1678
1679 ✗ if (frames->initial_pool_size == 0) {
1680 // Dynamic allocation is necessarily supported.
1681 ✗ } else if (avctx->extra_hw_frames >= 0) {
1682 ✗ frames->initial_pool_size += avctx->extra_hw_frames;
1683 } else {
1684 ✗ frames->initial_pool_size = default_pool_size;
1685 }
1686
1687 ✗ return 0;
1688 }
1689
1690 495232 int ff_outlink_frame_wanted(AVFilterLink *link)
1691 {
1692 495232 FilterLinkInternal * const li = ff_link_internal(link);
1693 495232 return li->frame_wanted_out;
1694 }
1695
1696 5112 int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func,
1697 void *arg, int *ret, int nb_jobs)
1698 {
1699 5112 return fffilterctx(ctx)->execute(ctx, func, arg, ret, nb_jobs);
1700 }
1701