FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/avfilter.c
Date: 2024-07-26 21:54:09
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 1269485 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 1269485 }
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 1281328 static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
223 {
224 1281328 AVFilterLink *const link = &li->l;
225
226
2/2
✓ Branch 0 taken 69 times.
✓ Branch 1 taken 1281259 times.
 1281328 if (pts == AV_NOPTS_VALUE)
227 69 return;
228 1281259 link->current_pts = pts;
229 1281259 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 1281259 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 375854 times.
✓ Branch 3 taken 905405 times.
 1281259 if (link->graph && li->age_index >= 0)
232 375854 ff_avfilter_graph_update_heap(link->graph, li);
233 }
234
235 3163610 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
236 {
237 3163610 filter->ready = FFMAX(filter->ready, priority);
238 3163610 }
239
240 /**
241 * Clear frame_blocked_in on all outputs.
242 * This is necessary whenever something changes on input.
243 */
244 1898881 static void filter_unblock(AVFilterContext *filter)
245 {
246 unsigned i;
247
248
2/2
✓ Branch 0 taken 1524754 times.
✓ Branch 1 taken 1898881 times.
 3423635 for (i = 0; i < filter->nb_outputs; i++) {
249 1524754 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
250 1524754 li->frame_blocked_in = 0;
251 }
252 1898881 }
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 607011 int ff_request_frame(AVFilterLink *link)
464 {
465 607011 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 607002 times.
 607011 if (li->status_out)
471 9 return li->status_out;
472
2/2
✓ Branch 0 taken 5708 times.
✓ Branch 1 taken 601294 times.
 607002 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 601294 link->frame_wanted_out = 1;
486 601294 ff_filter_set_ready(link->src, 100);
487 601294 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 607354 static int ff_request_frame_to_filter(AVFilterLink *link)
513 {
514 607354 FilterLinkInternal * const li = ff_link_internal(link);
515 607354 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 607354 li->frame_blocked_in = 1;
520
2/2
✓ Branch 0 taken 2864 times.
✓ Branch 1 taken 604490 times.
 607354 if (link->srcpad->request_frame)
521 2864 ret = link->srcpad->request_frame(link);
522
1/2
✓ Branch 0 taken 604490 times.
✗ Branch 1 not taken.
 604490 else if (link->src->inputs[0])
523 604490 ret = ff_request_frame(link->src->inputs[0]);
524
2/2
✓ Branch 0 taken 5709 times.
✓ Branch 1 taken 601645 times.
 607354 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 607354 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 592836 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
980 {
981 592836 return ff_filter_frame(link->dst->outputs[0], frame);
982 }
983
984 610501 static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
985 {
986 int (*filter_frame)(AVFilterLink *, AVFrame *);
987 610501 AVFilterContext *dstctx = link->dst;
988 610501 AVFilterPad *dst = link->dstpad;
989 int ret;
990
991
2/2
✓ Branch 0 taken 592827 times.
✓ Branch 1 taken 17674 times.
 610501 if (!(filter_frame = dst->filter_frame))
992 592827 filter_frame = default_filter_frame;
993
994
2/2
✓ Branch 0 taken 2281 times.
✓ Branch 1 taken 608220 times.
 610501 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 610501 ff_inlink_process_commands(link, frame);
1001 610501 dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1002
1003
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 610482 times.
 610501 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 610501 ret = filter_frame(link, frame);
1007 610501 link->frame_count_out++;
1008 610501 return ret;
1009
1010 ✗ fail:
1011 ✗ av_frame_free(&frame);
1012 ✗ return ret;
1013 }
1014
1015 1269485 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1016 {
1017 1269485 FilterLinkInternal * const li = ff_link_internal(link);
1018 int ret;
1019 1269485 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 342486 times.
✓ Branch 1 taken 926999 times.
 1269485 if (link->type == AVMEDIA_TYPE_VIDEO) {
1023
2/2
✓ Branch 0 taken 232573 times.
✓ Branch 1 taken 109913 times.
 342486 if (strcmp(link->dst->filter->name, "buffersink") &&
1024
2/2
✓ Branch 0 taken 156717 times.
✓ Branch 1 taken 75856 times.
 232573 strcmp(link->dst->filter->name, "format") &&
1025
2/2
✓ Branch 0 taken 156691 times.
✓ Branch 1 taken 26 times.
 156717 strcmp(link->dst->filter->name, "idet") &&
1026
2/2
✓ Branch 0 taken 70034 times.
✓ Branch 1 taken 86657 times.
 156691 strcmp(link->dst->filter->name, "null") &&
1027 70034 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 342486 frame->sample_aspect_ratio = link->sample_aspect_ratio;
1034 } else {
1035
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 926999 times.
 926999 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 926999 times.
 926999 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 926999 times.
 926999 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 926999 frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1049 link->time_base);
1050 }
1051
1052 1269485 li->frame_blocked_in = link->frame_wanted_out = 0;
1053 1269485 link->frame_count_in++;
1054 1269485 link->sample_count_in += frame->nb_samples;
1055 1269485 filter_unblock(link->dst);
1056 1269485 ret = ff_framequeue_add(&li->fifo, frame);
1057
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1269485 times.
 1269485 if (ret < 0) {
1058 ✗ av_frame_free(&frame);
1059 ✗ return ret;
1060 }
1061 1269485 ff_filter_set_ready(link->dst, 300);
1062 1269485 return 0;
1063
1064 ✗ error:
1065 ✗ av_frame_free(&frame);
1066 ✗ return AVERROR_PATCHWELCOME;
1067 }
1068
1069 1823360 static int samples_ready(FilterLinkInternal *link, unsigned min)
1070 {
1071
2/2
✓ Branch 1 taken 610604 times.
✓ Branch 2 taken 1212756 times.
 2433964 return ff_framequeue_queued_frames(&link->fifo) &&
1072
2/2
✓ Branch 1 taken 104 times.
✓ Branch 2 taken 610500 times.
 610604 (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 610501 static int ff_filter_frame_to_filter(AVFilterLink *link)
1137 {
1138 610501 FilterLinkInternal * const li = ff_link_internal(link);
1139 610501 AVFrame *frame = NULL;
1140 610501 AVFilterContext *dst = link->dst;
1141 int ret;
1142
1143 av_assert1(ff_framequeue_queued_frames(&li->fifo));
1144 1221002 ret = link->min_samples ?
1145
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 610465 times.
 610501 ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1146 610465 ff_inlink_consume_frame(link, &frame);
1147 av_assert1(ret);
1148
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 610501 times.
 610501 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 610501 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 610501 link->frame_count_out--;
1158 610501 ret = ff_filter_frame_framed(link, frame);
1159
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 610501 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 610501 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 610501 ff_filter_set_ready(dst, 300);
1165 }
1166 610501 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 1830125 static int ff_filter_activate_default(AVFilterContext *filter)
1205 {
1206 unsigned i;
1207
1208
2/2
✓ Branch 0 taken 1830125 times.
✓ Branch 1 taken 1823641 times.
 3653766 for (i = 0; i < filter->nb_outputs; i++) {
1209 1830125 FilterLinkInternal *li = ff_link_internal(filter->outputs[i]);
1210 1830125 int ret = li->status_in;
1211
1212
2/2
✓ Branch 0 taken 6484 times.
✓ Branch 1 taken 1823641 times.
 1830125 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 1823360 times.
✓ Branch 1 taken 1213140 times.
 3036500 for (i = 0; i < filter->nb_inputs; i++) {
1220
2/2
✓ Branch 1 taken 610501 times.
✓ Branch 2 taken 1212859 times.
 1823360 if (samples_ready(ff_link_internal(filter->inputs[i]),
1221 1823360 filter->inputs[i]->min_samples)) {
1222 610501 return ff_filter_frame_to_filter(filter->inputs[i]);
1223 }
1224 }
1225
2/2
✓ Branch 0 taken 1212859 times.
✓ Branch 1 taken 1207432 times.
 2420291 for (i = 0; i < filter->nb_inputs; i++) {
1226 1212859 FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1227
4/4
✓ Branch 0 taken 5732 times.
✓ Branch 1 taken 1207127 times.
✓ Branch 2 taken 5708 times.
✓ Branch 3 taken 24 times.
 1212859 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 1207432 times.
✓ Branch 1 taken 605786 times.
 1813218 for (i = 0; i < filter->nb_outputs; i++) {
1233 1207432 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1234
2/2
✓ Branch 0 taken 601796 times.
✓ Branch 1 taken 605636 times.
 1207432 if (filter->outputs[i]->frame_wanted_out &&
1235
2/2
✓ Branch 0 taken 601646 times.
✓ Branch 1 taken 150 times.
 601796 !li->frame_blocked_in) {
1236 601646 return ff_request_frame_to_filter(filter->outputs[i]);
1237 }
1238 }
1239 605786 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 3153414 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 3153414 filter->ready = 0;
1382
2/2
✓ Branch 0 taken 1323289 times.
✓ Branch 1 taken 1830125 times.
 3153414 ret = filter->filter->activate ? filter->filter->activate(filter) :
1383 1830125 ff_filter_activate_default(filter);
1384
2/2
✓ Branch 0 taken 963427 times.
✓ Branch 1 taken 2189987 times.
 3153414 if (ret == FFERROR_NOT_READY)
1385 963427 ret = 0;
1386 3153414 return ret;
1387 }
1388
1389 2674854 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1390 {
1391 2674854 FilterLinkInternal * const li = ff_link_internal(link);
1392 2674854 *rpts = link->current_pts;
1393
2/2
✓ Branch 1 taken 1610 times.
✓ Branch 2 taken 2673244 times.
 2674854 if (ff_framequeue_queued_frames(&li->fifo))
1394 1610 return *rstatus = 0;
1395
2/2
✓ Branch 0 taken 1933 times.
✓ Branch 1 taken 2671311 times.
 2673244 if (li->status_out)
1396 1933 return *rstatus = li->status_out;
1397
2/2
✓ Branch 0 taken 2664915 times.
✓ Branch 1 taken 6396 times.
 2671311 if (!li->status_in)
1398 2664915 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 456123 size_t ff_inlink_queued_frames(AVFilterLink *link)
1406 {
1407 456123 FilterLinkInternal * const li = ff_link_internal(link);
1408 456123 return ff_framequeue_queued_frames(&li->fifo);
1409 }
1410
1411 3709955 int ff_inlink_check_available_frame(AVFilterLink *link)
1412 {
1413 3709955 FilterLinkInternal * const li = ff_link_internal(link);
1414 3709955 return ff_framequeue_queued_frames(&li->fifo) > 0;
1415 }
1416
1417 1741 int ff_inlink_queued_samples(AVFilterLink *link)
1418 {
1419 1741 FilterLinkInternal * const li = ff_link_internal(link);
1420 1741 return ff_framequeue_queued_samples(&li->fifo);
1421 }
1422
1423 3665 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1424 {
1425 3665 FilterLinkInternal * const li = ff_link_internal(link);
1426 3665 uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1427 av_assert1(min);
1428
6/6
✓ Branch 0 taken 1359 times.
✓ Branch 1 taken 2306 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 1294 times.
✓ Branch 4 taken 7 times.
✓ Branch 5 taken 58 times.
 3665 return samples >= min || (li->status_in && samples);
1429 }
1430
1431 1270270 static void consume_update(FilterLinkInternal *li, const AVFrame *frame)
1432 {
1433 1270270 AVFilterLink *const link = &li->l;
1434 1270270 update_link_current_pts(li, frame->pts);
1435 1270270 ff_inlink_process_commands(link, frame);
1436
2/2
✓ Branch 0 taken 1268031 times.
✓ Branch 1 taken 2239 times.
 1270270 if (link == link->dst->inputs[0])
1437 1268031 link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1438 1270270 link->frame_count_out++;
1439 1270270 link->sample_count_out += frame->nb_samples;
1440 1270270 }
1441
1442 3708071 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1443 {
1444 3708071 FilterLinkInternal * const li = ff_link_internal(link);
1445 AVFrame *frame;
1446
1447 3708071 *rframe = NULL;
1448
2/2
✓ Branch 1 taken 2440110 times.
✓ Branch 2 taken 1267961 times.
 3708071 if (!ff_inlink_check_available_frame(link))
1449 2440110 return 0;
1450
1451
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1267958 times.
 1267961 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 1267958 frame = ff_framequeue_take(&li->fifo);
1457 1267958 consume_update(li, frame);
1458 1267958 *rframe = frame;
1459 1267958 return 1;
1460 }
1461
1462 3529 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1463 AVFrame **rframe)
1464 {
1465 3529 FilterLinkInternal * const li = ff_link_internal(link);
1466 AVFrame *frame;
1467 int ret;
1468
1469 av_assert1(min);
1470 3529 *rframe = NULL;
1471
2/2
✓ Branch 1 taken 1217 times.
✓ Branch 2 taken 2312 times.
 3529 if (!ff_inlink_check_available_samples(link, min))
1472 1217 return 0;
1473
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 2289 times.
 2312 if (li->status_in)
1474
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 17 times.
 23 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 5382 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1490 {
1491 5382 AVFrame *frame = *rframe;
1492 AVFrame *out;
1493 int ret;
1494
1495
2/2
✓ Branch 1 taken 2790 times.
✓ Branch 2 taken 2592 times.
 5382 if (av_frame_is_writable(frame))
1496 2790 return 0;
1497 2592 av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1498
1499
1/3
✓ Branch 0 taken 2592 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 2592 switch (link->type) {
1500 2592 case AVMEDIA_TYPE_VIDEO:
1501 2592 out = ff_get_video_buffer(link, link->w, link->h);
1502 2592 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 2592 times.
 2592 if (!out)
1510 ✗ return AVERROR(ENOMEM);
1511
1512 2592 ret = av_frame_copy_props(out, frame);
1513
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2592 times.
 2592 if (ret < 0) {
1514 ✗ av_frame_free(&out);
1515 ✗ return ret;
1516 }
1517
1518 2592 ret = av_frame_copy(out, frame);
1519
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2592 times.
 2592 if (ret < 0) {
1520 ✗ av_frame_free(&out);
1521 ✗ return ret;
1522 }
1523
1524 2592 av_frame_free(&frame);
1525 2592 *rframe = out;
1526 2592 return 0;
1527 }
1528
1529 1880771 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1530 {
1531 1880771 AVFilterCommand *cmd = link->dst->command_queue;
1532
1533
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1880771 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1880771 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 1880771 return 0;
1542 }
1543
1544 1878532 int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1545 {
1546 1878532 AVFilterContext *dstctx = link->dst;
1547 1878532 int64_t pts = frame->pts;
1548 #if FF_API_FRAME_PKT
1549 FF_DISABLE_DEPRECATION_WARNINGS
1550 1878532 int64_t pos = frame->pkt_pos;
1551 FF_ENABLE_DEPRECATION_WARNINGS
1552 #endif
1553
1554
2/2
✓ Branch 0 taken 1878336 times.
✓ Branch 1 taken 196 times.
 1878532 if (!dstctx->enable_str)
1555 1878336 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 651618 void ff_inlink_request_frame(AVFilterLink *link)
1569 {
1570 651618 av_unused FilterLinkInternal *li = ff_link_internal(link);
1571 av_assert1(!li->status_in);
1572 av_assert1(!li->status_out);
1573 651618 link->frame_wanted_out = 1;
1574 651618 ff_filter_set_ready(link->src, 100);
1575 651618 }
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 938141 int ff_outlink_get_status(AVFilterLink *link)
1594 {
1595 938141 FilterLinkInternal * const li = ff_link_internal(link);
1596 938141 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