FFmpeg coverage


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