FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/avfilter.c
Date: 2024-04-25 15:36:26
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 1252754 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 1252754 }
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 227 static int append_pad(unsigned *count, AVFilterPad **pads,
101 AVFilterLink ***links, AVFilterPad *newpad)
102 {
103 AVFilterLink **newlinks;
104 AVFilterPad *newpads;
105 227 unsigned idx = *count;
106
107 227 newpads = av_realloc_array(*pads, idx + 1, sizeof(*newpads));
108 227 newlinks = av_realloc_array(*links, idx + 1, sizeof(*newlinks));
109
1/2
✓ Branch 0 taken 227 times.
✗ Branch 1 not taken.
 227 if (newpads)
110 227 *pads = newpads;
111
1/2
✓ Branch 0 taken 227 times.
✗ Branch 1 not taken.
 227 if (newlinks)
112 227 *links = newlinks;
113
2/4
✓ Branch 0 taken 227 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 227 times.
 227 if (!newpads || !newlinks) {
114 ✗ if (newpad->flags & AVFILTERPAD_FLAG_FREE_NAME)
115 ✗ av_freep(&newpad->name);
116 ✗ return AVERROR(ENOMEM);
117 }
118
119 227 memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
120 227 (*links)[idx] = NULL;
121
122 227 (*count)++;
123
124 227 return 0;
125 }
126
127 95 int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
128 {
129 95 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 32467 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 32467 times.
 32467 av_assert0(src->graph);
156
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32467 times.
 32467 av_assert0(dst->graph);
157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32467 times.
 32467 av_assert0(src->graph == dst->graph);
158
159
2/4
✓ Branch 0 taken 32467 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 32467 times.
✗ Branch 3 not taken.
 32467 if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
160
2/4
✓ Branch 0 taken 32467 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 32467 times.
 32467 src->outputs[srcpad] || dst->inputs[dstpad])
161 ✗ return AVERROR(EINVAL);
162
163
2/4
✓ Branch 1 taken 32467 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 32467 times.
 32467 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 32467 times.
 32467 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 32467 li = av_mallocz(sizeof(*li));
177
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32467 times.
 32467 if (!li)
178 ✗ return AVERROR(ENOMEM);
179 32467 link = &li->l;
180
181 32467 src->outputs[srcpad] = dst->inputs[dstpad] = link;
182
183 32467 link->src = src;
184 32467 link->dst = dst;
185 32467 link->srcpad = &src->output_pads[srcpad];
186 32467 link->dstpad = &dst->input_pads[dstpad];
187 32467 link->type = src->output_pads[srcpad].type;
188 av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
189 32467 link->format = -1;
190 32467 link->colorspace = AVCOL_SPC_UNSPECIFIED;
191 32467 ff_framequeue_init(&li->fifo, &fffiltergraph(src->graph)->frame_queues);
192
193 32467 return 0;
194 }
195
196 32599 static void link_free(AVFilterLink **link)
197 {
198 FilterLinkInternal *li;
199
200
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32599 times.
 32599 if (!*link)
201 ✗ return;
202 32599 li = ff_link_internal(*link);
203
204 32599 ff_framequeue_free(&li->fifo);
205 32599 ff_frame_pool_uninit(&li->frame_pool);
206 32599 av_channel_layout_uninit(&(*link)->ch_layout);
207
208 32599 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 1265592 static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
223 {
224 1265592 AVFilterLink *const link = &li->l;
225
226
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 1265573 times.
 1265592 if (pts == AV_NOPTS_VALUE)
227 19 return;
228 1265573 link->current_pts = pts;
229 1265573 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 1265573 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 371617 times.
✓ Branch 3 taken 893956 times.
 1265573 if (link->graph && li->age_index >= 0)
232 371617 ff_avfilter_graph_update_heap(link->graph, li);
233 }
234
235 3170324 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
236 {
237 3170324 filter->ready = FFMAX(filter->ready, priority);
238 3170324 }
239
240 /**
241 * Clear frame_blocked_in on all outputs.
242 * This is necessary whenever something changes on input.
243 */
244 1921325 static void filter_unblock(AVFilterContext *filter)
245 {
246 unsigned i;
247
248
2/2
✓ Branch 0 taken 1551454 times.
✓ Branch 1 taken 1921325 times.
 3472779 for (i = 0; i < filter->nb_outputs; i++) {
249 1551454 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
250 1551454 li->frame_blocked_in = 0;
251 }
252 1921325 }
253
254
255 15050 void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
256 {
257 15050 FilterLinkInternal * const li = ff_link_internal(link);
258
259
2/2
✓ Branch 0 taken 2991 times.
✓ Branch 1 taken 12059 times.
 15050 if (li->status_in == status)
260 2991 return;
261
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12059 times.
 12059 av_assert0(!li->status_in);
262 12059 li->status_in = status;
263 12059 li->status_in_pts = pts;
264 12059 link->frame_wanted_out = 0;
265 12059 li->frame_blocked_in = 0;
266 12059 filter_unblock(link->dst);
267 12059 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 7836 static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
275 {
276 7836 FilterLinkInternal * const li = ff_link_internal(link);
277
278
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7836 times.
 7836 av_assert0(!link->frame_wanted_out);
279
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7836 times.
 7836 av_assert0(!li->status_out);
280 7836 li->status_out = status;
281
2/2
✓ Branch 0 taken 6744 times.
✓ Branch 1 taken 1092 times.
 7836 if (pts != AV_NOPTS_VALUE)
282 6744 update_link_current_pts(li, pts);
283 7836 filter_unblock(link->dst);
284 7836 ff_filter_set_ready(link->src, 200);
285 7836 }
286
287 1058 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
288 unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
289 {
290 int ret;
291 1058 unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
292
293 1058 av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
294 "between the filter '%s' and the filter '%s'\n",
295 1058 filt->name, link->src->name, link->dst->name);
296
297 1058 link->dst->inputs[dstpad_idx] = NULL;
298
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1058 times.
 1058 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 1058 link->dst = filt;
306 1058 link->dstpad = &filt->input_pads[filt_srcpad_idx];
307 1058 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 1058 times.
✗ Branch 1 not taken.
 1058 if (link->outcfg.formats)
312 1058 ff_formats_changeref(&link->outcfg.formats,
313 1058 &filt->outputs[filt_dstpad_idx]->outcfg.formats);
314
2/2
✓ Branch 0 taken 594 times.
✓ Branch 1 taken 464 times.
 1058 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 464 times.
 1058 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 464 times.
✓ Branch 1 taken 594 times.
 1058 if (link->outcfg.samplerates)
321 464 ff_formats_changeref(&link->outcfg.samplerates,
322 464 &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
323
2/2
✓ Branch 0 taken 464 times.
✓ Branch 1 taken 594 times.
 1058 if (link->outcfg.channel_layouts)
324 464 ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
325 464 &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
326
327 1058 return 0;
328 }
329
330 32726 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 26245 times.
✓ Branch 1 taken 32726 times.
 58971 for (i = 0; i < filter->nb_inputs; i ++) {
337 26245 AVFilterLink *link = filter->inputs[i];
338 AVFilterLink *inlink;
339 26245 FilterLinkInternal *li = ff_link_internal(link);
340
341
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26245 times.
 26245 if (!link) continue;
342
2/4
✓ Branch 0 taken 26245 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 26245 times.
 26245 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 19652 times.
✓ Branch 1 taken 6593 times.
 26245 inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
349 26245 link->current_pts =
350 26245 link->current_pts_us = AV_NOPTS_VALUE;
351
352
2/4
✓ Branch 0 taken 40 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26205 times.
✗ Branch 3 not taken.
 26245 switch (li->init_state) {
353 40 case AVLINK_INIT:
354 40 continue;
355 ✗ case AVLINK_STARTINIT:
356 ✗ av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
357 ✗ return 0;
358 26205 case AVLINK_UNINIT:
359 26205 li->init_state = AVLINK_STARTINIT;
360
361
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 26205 times.
 26205 if ((ret = ff_filter_config_links(link->src)) < 0)
362 ✗ return ret;
363
364
2/2
✓ Branch 0 taken 13438 times.
✓ Branch 1 taken 12767 times.
 26205 if (!(config_link = link->srcpad->config_props)) {
365
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13438 times.
 13438 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 12767 times.
 12767 } 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 20765 times.
✓ Branch 1 taken 5440 times.
✗ Branch 2 not taken.
 26205 switch (link->type) {
380 20765 case AVMEDIA_TYPE_VIDEO:
381
3/4
✓ Branch 0 taken 15223 times.
✓ Branch 1 taken 5542 times.
✓ Branch 2 taken 15223 times.
✗ Branch 3 not taken.
 20765 if (!link->time_base.num && !link->time_base.den)
382
1/2
✓ Branch 0 taken 15223 times.
✗ Branch 1 not taken.
 15223 link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
383
384
4/4
✓ Branch 0 taken 19707 times.
✓ Branch 1 taken 1058 times.
✓ Branch 2 taken 11141 times.
✓ Branch 3 taken 8566 times.
 20765 if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
385 11141 link->sample_aspect_ratio = inlink ?
386
2/2
✓ Branch 0 taken 11127 times.
✓ Branch 1 taken 14 times.
 11141 inlink->sample_aspect_ratio : (AVRational){1,1};
387
388
2/2
✓ Branch 0 taken 15475 times.
✓ Branch 1 taken 5290 times.
 20765 if (inlink) {
389
3/4
✓ Branch 0 taken 15274 times.
✓ Branch 1 taken 201 times.
✓ Branch 2 taken 15274 times.
✗ Branch 3 not taken.
 15475 if (!link->frame_rate.num && !link->frame_rate.den)
390 15274 link->frame_rate = inlink->frame_rate;
391
2/2
✓ Branch 0 taken 10675 times.
✓ Branch 1 taken 4800 times.
 15475 if (!link->w)
392 10675 link->w = inlink->w;
393
2/2
✓ Branch 0 taken 10675 times.
✓ Branch 1 taken 4800 times.
 15475 if (!link->h)
394 10675 link->h = inlink->h;
395
2/4
✓ Branch 0 taken 5290 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5290 times.
 5290 } 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 20765 break;
402
403 5440 case AVMEDIA_TYPE_AUDIO:
404
2/2
✓ Branch 0 taken 4168 times.
✓ Branch 1 taken 1272 times.
 5440 if (inlink) {
405
3/4
✓ Branch 0 taken 2841 times.
✓ Branch 1 taken 1327 times.
✓ Branch 2 taken 2841 times.
✗ Branch 3 not taken.
 4168 if (!link->time_base.num && !link->time_base.den)
406 2841 link->time_base = inlink->time_base;
407 }
408
409
3/4
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 5426 times.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
 5440 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 19643 times.
✓ Branch 1 taken 6562 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 19643 times.
 26205 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 2217 times.
✓ Branch 1 taken 23988 times.
 26205 if ((config_link = link->dstpad->config_props))
423
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2217 times.
 2217 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 26205 li->init_state = AVLINK_INIT;
431 }
432 }
433
434 32726 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 643071 int ff_request_frame(AVFilterLink *link)
464 {
465 643071 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 643062 times.
 643071 if (li->status_out)
471 9 return li->status_out;
472
2/2
✓ Branch 0 taken 6760 times.
✓ Branch 1 taken 636302 times.
 643062 if (li->status_in) {
473
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6760 times.
 6760 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 6760 link_set_out_status(link, li->status_in, li->status_in_pts);
482 6760 return li->status_out;
483 }
484 }
485 636302 link->frame_wanted_out = 1;
486 636302 ff_filter_set_ready(link->src, 100);
487 636302 return 0;
488 }
489
490 6761 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
491 {
492 unsigned i;
493 6761 int64_t r = INT64_MAX;
494
495
2/2
✓ Branch 0 taken 6760 times.
✓ Branch 1 taken 6761 times.
 13521 for (i = 0; i < ctx->nb_inputs; i++) {
496 6760 FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
497
1/2
✓ Branch 0 taken 6760 times.
✗ Branch 1 not taken.
 6760 if (li->status_out == status)
498 6760 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 6760 times.
✓ Branch 1 taken 1 times.
 6761 if (r < INT64_MAX)
501 6760 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 643405 static int ff_request_frame_to_filter(AVFilterLink *link)
513 {
514 643405 FilterLinkInternal * const li = ff_link_internal(link);
515 643405 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 643405 li->frame_blocked_in = 1;
520
2/2
✓ Branch 0 taken 2653 times.
✓ Branch 1 taken 640752 times.
 643405 if (link->srcpad->request_frame)
521 2653 ret = link->srcpad->request_frame(link);
522
1/2
✓ Branch 0 taken 640752 times.
✗ Branch 1 not taken.
 640752 else if (link->src->inputs[0])
523 640752 ret = ff_request_frame(link->src->inputs[0]);
524
2/2
✓ Branch 0 taken 6761 times.
✓ Branch 1 taken 636644 times.
 643405 if (ret < 0) {
525
2/4
✓ Branch 0 taken 6761 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6761 times.
✗ Branch 3 not taken.
 6761 if (ret != AVERROR(EAGAIN) && ret != li->status_in)
526 6761 ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
527
1/2
✓ Branch 0 taken 6761 times.
✗ Branch 1 not taken.
 6761 if (ret == AVERROR_EOF)
528 6761 ret = 0;
529 }
530 643405 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 12559 unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
617 {
618
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12559 times.
 12559 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 72393 static void *filter_child_next(void *obj, void *prev)
628 {
629 72393 AVFilterContext *ctx = obj;
630
5/8
✓ Branch 0 taken 72387 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 72387 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 72387 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 72387 times.
✗ Branch 7 not taken.
 72393 if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
631 72387 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 45431 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
686 {
687 FFFilterContext *ctx;
688 AVFilterContext *ret;
689 45431 int preinited = 0;
690
691
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45431 times.
 45431 if (!filter)
692 ✗ return NULL;
693
694 45431 ctx = av_mallocz(sizeof(*ctx));
695
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45431 times.
 45431 if (!ctx)
696 ✗ return NULL;
697 45431 ret = &ctx->p;
698
699 45431 ret->av_class = &avfilter_class;
700 45431 ret->filter = filter;
701
1/2
✓ Branch 0 taken 45431 times.
✗ Branch 1 not taken.
 45431 ret->name = inst_name ? av_strdup(inst_name) : NULL;
702
2/2
✓ Branch 0 taken 38940 times.
✓ Branch 1 taken 6491 times.
 45431 if (filter->priv_size) {
703 38940 ret->priv = av_mallocz(filter->priv_size);
704
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38940 times.
 38940 if (!ret->priv)
705 ✗ goto err;
706 }
707
2/2
✓ Branch 0 taken 9180 times.
✓ Branch 1 taken 36251 times.
 45431 if (filter->preinit) {
708
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9180 times.
 9180 if (filter->preinit(ret) < 0)
709 ✗ goto err;
710 9180 preinited = 1;
711 }
712
713 45431 av_opt_set_defaults(ret);
714
2/2
✓ Branch 0 taken 37795 times.
✓ Branch 1 taken 7636 times.
 45431 if (filter->priv_class) {
715 37795 *(const AVClass**)ret->priv = filter->priv_class;
716 37795 av_opt_set_defaults(ret->priv);
717 }
718
719 45431 ctx->execute = default_execute;
720
721 45431 ret->nb_inputs = filter->nb_inputs;
722
2/2
✓ Branch 0 taken 38745 times.
✓ Branch 1 taken 6686 times.
 45431 if (ret->nb_inputs ) {
723 38745 ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs));
724
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38745 times.
 38745 if (!ret->input_pads)
725 ✗ goto err;
726 38745 ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs));
727
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38745 times.
 38745 if (!ret->inputs)
728 ✗ goto err;
729 }
730
731 45431 ret->nb_outputs = filter->nb_outputs;
732
2/2
✓ Branch 0 taken 38833 times.
✓ Branch 1 taken 6598 times.
 45431 if (ret->nb_outputs) {
733 38833 ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
734
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38833 times.
 38833 if (!ret->output_pads)
735 ✗ goto err;
736 38833 ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs));
737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38833 times.
 38833 if (!ret->outputs)
738 ✗ goto err;
739 }
740
741 45431 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 77899 static void free_link(AVFilterLink *link)
758 {
759
2/2
✓ Branch 0 taken 45300 times.
✓ Branch 1 taken 32599 times.
 77899 if (!link)
760 45300 return;
761
762
2/2
✓ Branch 0 taken 32467 times.
✓ Branch 1 taken 132 times.
 32599 if (link->src)
763 32467 link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
764
2/2
✓ Branch 0 taken 32467 times.
✓ Branch 1 taken 132 times.
 32599 if (link->dst)
765 32467 link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
766
767 32599 av_buffer_unref(&link->hw_frames_ctx);
768
769 32599 ff_formats_unref(&link->incfg.formats);
770 32599 ff_formats_unref(&link->outcfg.formats);
771 32599 ff_formats_unref(&link->incfg.color_spaces);
772 32599 ff_formats_unref(&link->outcfg.color_spaces);
773 32599 ff_formats_unref(&link->incfg.color_ranges);
774 32599 ff_formats_unref(&link->outcfg.color_ranges);
775 32599 ff_formats_unref(&link->incfg.samplerates);
776 32599 ff_formats_unref(&link->outcfg.samplerates);
777 32599 ff_channel_layouts_unref(&link->incfg.channel_layouts);
778 32599 ff_channel_layouts_unref(&link->outcfg.channel_layouts);
779 32599 link_free(&link);
780 }
781
782 45431 void avfilter_free(AVFilterContext *filter)
783 {
784 int i;
785
786
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45431 times.
 45431 if (!filter)
787 ✗ return;
788
789
1/2
✓ Branch 0 taken 45431 times.
✗ Branch 1 not taken.
 45431 if (filter->graph)
790 45431 ff_filter_graph_remove_filter(filter->graph, filter);
791
792
2/2
✓ Branch 0 taken 34978 times.
✓ Branch 1 taken 10453 times.
 45431 if (filter->filter->uninit)
793 34978 filter->filter->uninit(filter);
794
795
2/2
✓ Branch 0 taken 38932 times.
✓ Branch 1 taken 45431 times.
 84363 for (i = 0; i < filter->nb_inputs; i++) {
796 38932 free_link(filter->inputs[i]);
797
2/2
✓ Branch 0 taken 78 times.
✓ Branch 1 taken 38854 times.
 38932 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 38967 times.
✓ Branch 1 taken 45431 times.
 84398 for (i = 0; i < filter->nb_outputs; i++) {
801 38967 free_link(filter->outputs[i]);
802
2/2
✓ Branch 0 taken 127 times.
✓ Branch 1 taken 38840 times.
 38967 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 37795 times.
✓ Branch 1 taken 7636 times.
 45431 if (filter->filter->priv_class)
807 37795 av_opt_free(filter->priv);
808
809 45431 av_buffer_unref(&filter->hw_device_ctx);
810
811 45431 av_freep(&filter->name);
812 45431 av_freep(&filter->input_pads);
813 45431 av_freep(&filter->output_pads);
814 45431 av_freep(&filter->inputs);
815 45431 av_freep(&filter->outputs);
816 45431 av_freep(&filter->priv);
817
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45431 times.
 45431 while(filter->command_queue){
818 ✗ command_queue_pop(filter);
819 }
820 45431 av_opt_free(filter);
821 45431 av_expr_free(filter->enable);
822 45431 filter->enable = NULL;
823 45431 av_freep(&filter->var_values);
824 45431 av_free(filter);
825 }
826
827 13641 int ff_filter_get_nb_threads(AVFilterContext *ctx)
828 {
829
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13641 times.
 13641 if (ctx->nb_threads > 0)
830 ✗ return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
831 13641 return ctx->graph->nb_threads;
832 }
833
834 25931 int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
835 AVDictionary **options, const char *args)
836 {
837 25931 const AVOption *o = NULL;
838 int ret;
839 25931 int offset= -1;
840
841
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25931 times.
 25931 if (!args)
842 ✗ return 0;
843
844
2/2
✓ Branch 0 taken 72099 times.
✓ Branch 1 taken 25931 times.
 98030 while (*args) {
845 char *parsed_key, *value;
846 const char *key;
847 72099 const char *shorthand = NULL;
848 72099 int additional_flags = 0;
849
850
4/4
✓ Branch 0 taken 32702 times.
✓ Branch 1 taken 39397 times.
✓ Branch 3 taken 31420 times.
✓ Branch 4 taken 1282 times.
 72099 if (priv_class && (o = av_opt_next(&priv_class, o))) {
851
4/4
✓ Branch 0 taken 29670 times.
✓ Branch 1 taken 1750 times.
✓ Branch 2 taken 2167 times.
✓ Branch 3 taken 27503 times.
 31420 if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
852 3917 continue;
853 27503 offset = o->offset;
854 27503 shorthand = o->name;
855 }
856
857 68182 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 68182 times.
 68182 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 45174 times.
✓ Branch 1 taken 23008 times.
 68182 if (*args)
869 45174 args++;
870
2/2
✓ Branch 0 taken 51122 times.
✓ Branch 1 taken 17060 times.
 68182 if (parsed_key) {
871 51122 key = parsed_key;
872 51122 additional_flags = AV_DICT_DONT_STRDUP_KEY;
873 51122 priv_class = NULL; /* reject all remaining shorthand */
874 } else {
875 17060 key = shorthand;
876 }
877
878 68182 av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
879
880 68182 av_dict_set(options, key, value,
881 additional_flags | AV_DICT_DONT_STRDUP_VAL | AV_DICT_MULTIKEY);
882 }
883
884 25931 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 45431 int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
901 {
902 45431 FFFilterContext *ctxi = fffilterctx(ctx);
903 45431 int ret = 0;
904
905
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45431 times.
 45431 if (ctxi->initialized) {
906 ✗ av_log(ctx, AV_LOG_ERROR, "Filter already initialized\n");
907 ✗ return AVERROR(EINVAL);
908 }
909
910 45431 ret = av_opt_set_dict2(ctx, options, AV_OPT_SEARCH_CHILDREN);
911
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45431 times.
 45431 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 44273 times.
 45431 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 45284 ctx->thread_type = 0;
923 }
924
925
2/2
✓ Branch 0 taken 32948 times.
✓ Branch 1 taken 12483 times.
 45431 if (ctx->filter->init)
926 32948 ret = ctx->filter->init(ctx);
927
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45431 times.
 45431 if (ret < 0)
928 ✗ return ret;
929
930
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 45425 times.
 45431 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 45431 ctxi->initialized = 1;
937
938 45431 return 0;
939 }
940
941 19948 int avfilter_init_str(AVFilterContext *filter, const char *args)
942 {
943 19948 AVDictionary *options = NULL;
944 AVDictionaryEntry *e;
945 19948 int ret = 0;
946
947
3/4
✓ Branch 0 taken 12634 times.
✓ Branch 1 taken 7314 times.
✓ Branch 2 taken 12634 times.
✗ Branch 3 not taken.
 19948 if (args && *args) {
948 12634 ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args);
949
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12634 times.
 12634 if (ret < 0)
950 ✗ goto fail;
951 }
952
953 19948 ret = avfilter_init_dict(filter, &options);
954
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19948 times.
 19948 if (ret < 0)
955 ✗ goto fail;
956
957
1/2
✓ Branch 1 taken 19948 times.
✗ Branch 2 not taken.
 19948 if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
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 19948 fail:
964 19948 av_dict_free(&options);
965
966 19948 return ret;
967 }
968
969 12896 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
970 {
971 12896 return pads[pad_idx].name;
972 }
973
974 25925 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
975 {
976 25925 return pads[pad_idx].type;
977 }
978
979 584668 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
980 {
981 584668 return ff_filter_frame(link->dst->outputs[0], frame);
982 }
983
984 648676 static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
985 {
986 int (*filter_frame)(AVFilterLink *, AVFrame *);
987 648676 AVFilterContext *dstctx = link->dst;
988 648676 AVFilterPad *dst = link->dstpad;
989 int ret;
990
991
2/2
✓ Branch 0 taken 584659 times.
✓ Branch 1 taken 64017 times.
 648676 if (!(filter_frame = dst->filter_frame))
992 584659 filter_frame = default_filter_frame;
993
994
2/2
✓ Branch 0 taken 2281 times.
✓ Branch 1 taken 646395 times.
 648676 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 648676 ff_inlink_process_commands(link, frame);
1001 648676 dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1002
1003
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 648657 times.
 648676 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 648676 ret = filter_frame(link, frame);
1007 648676 link->frame_count_out++;
1008 648676 return ret;
1009
1010 ✗ fail:
1011 ✗ av_frame_free(&frame);
1012 ✗ return ret;
1013 }
1014
1015 1252754 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1016 {
1017 1252754 FilterLinkInternal * const li = ff_link_internal(link);
1018 int ret;
1019 1252754 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 341633 times.
✓ Branch 1 taken 911121 times.
 1252754 if (link->type == AVMEDIA_TYPE_VIDEO) {
1023
2/2
✓ Branch 0 taken 231953 times.
✓ Branch 1 taken 109680 times.
 341633 if (strcmp(link->dst->filter->name, "buffersink") &&
1024
2/2
✓ Branch 0 taken 156278 times.
✓ Branch 1 taken 75675 times.
 231953 strcmp(link->dst->filter->name, "format") &&
1025
2/2
✓ Branch 0 taken 156252 times.
✓ Branch 1 taken 26 times.
 156278 strcmp(link->dst->filter->name, "idet") &&
1026
2/2
✓ Branch 0 taken 69649 times.
✓ Branch 1 taken 86603 times.
 156252 strcmp(link->dst->filter->name, "null") &&
1027 69649 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 341633 frame->sample_aspect_ratio = link->sample_aspect_ratio;
1034 } else {
1035
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 911121 times.
 911121 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 911121 times.
 911121 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 911121 times.
 911121 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 911121 frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1049 link->time_base);
1050 }
1051
1052 1252754 li->frame_blocked_in = link->frame_wanted_out = 0;
1053 1252754 link->frame_count_in++;
1054 1252754 link->sample_count_in += frame->nb_samples;
1055 1252754 filter_unblock(link->dst);
1056 1252754 ret = ff_framequeue_add(&li->fifo, frame);
1057
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1252754 times.
 1252754 if (ret < 0) {
1058 ✗ av_frame_free(&frame);
1059 ✗ return ret;
1060 }
1061 1252754 ff_filter_set_ready(link->dst, 300);
1062 1252754 return 0;
1063
1064 ✗ error:
1065 ✗ av_frame_free(&frame);
1066 ✗ return AVERROR_PATCHWELCOME;
1067 }
1068
1069 1935660 static int samples_ready(FilterLinkInternal *link, unsigned min)
1070 {
1071
2/2
✓ Branch 1 taken 648779 times.
✓ Branch 2 taken 1286881 times.
 2584439 return ff_framequeue_queued_frames(&link->fifo) &&
1072
2/2
✓ Branch 1 taken 104 times.
✓ Branch 2 taken 648675 times.
 648779 (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 648676 static int ff_filter_frame_to_filter(AVFilterLink *link)
1137 {
1138 648676 FilterLinkInternal * const li = ff_link_internal(link);
1139 648676 AVFrame *frame = NULL;
1140 648676 AVFilterContext *dst = link->dst;
1141 int ret;
1142
1143 av_assert1(ff_framequeue_queued_frames(&li->fifo));
1144 1297352 ret = link->min_samples ?
1145
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 648640 times.
 648676 ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1146 648640 ff_inlink_consume_frame(link, &frame);
1147 av_assert1(ret);
1148
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 648676 times.
 648676 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 648676 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 648676 link->frame_count_out--;
1158 648676 ret = ff_filter_frame_framed(link, frame);
1159
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 648676 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 648676 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 648676 ff_filter_set_ready(dst, 300);
1165 }
1166 648676 return ret;
1167 }
1168
1169 6760 static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
1170 {
1171 6760 AVFilterLink *in = &li_in->l;
1172 6760 unsigned out = 0, progress = 0;
1173 int ret;
1174
1175
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6760 times.
 6760 av_assert0(!li_in->status_out);
1176
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6760 times.
 6760 if (!filter->nb_outputs) {
1177 /* not necessary with the current API and sinks */
1178 ✗ return 0;
1179 }
1180
2/2
✓ Branch 0 taken 6760 times.
✓ Branch 1 taken 6760 times.
 13520 while (!li_in->status_out) {
1181 6760 FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1182
1183
1/2
✓ Branch 0 taken 6760 times.
✗ Branch 1 not taken.
 6760 if (!li_out->status_in) {
1184 6760 progress++;
1185 6760 ret = ff_request_frame_to_filter(filter->outputs[out]);
1186
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6760 times.
 6760 if (ret < 0)
1187 ✗ return ret;
1188 }
1189
1/2
✓ Branch 0 taken 6760 times.
✗ Branch 1 not taken.
 6760 if (++out == filter->nb_outputs) {
1190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6760 times.
 6760 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 6760 progress = 0;
1197 6760 out = 0;
1198 }
1199 }
1200 6760 ff_filter_set_ready(filter, 200);
1201 6760 return 0;
1202 }
1203
1204 1944712 static int ff_filter_activate_default(AVFilterContext *filter)
1205 {
1206 unsigned i;
1207
1208
2/2
✓ Branch 0 taken 1944729 times.
✓ Branch 1 taken 1935918 times.
 3880647 for (i = 0; i < filter->nb_outputs; i++) {
1209 1944729 FilterLinkInternal *li = ff_link_internal(filter->outputs[i]);
1210 1944729 int ret = li->status_in;
1211
1212
2/2
✓ Branch 0 taken 8794 times.
✓ Branch 1 taken 1935935 times.
 1944729 if (ret) {
1213
2/2
✓ Branch 0 taken 8794 times.
✓ Branch 1 taken 8794 times.
 17588 for (int j = 0; j < filter->nb_inputs; j++)
1214 8794 ff_inlink_set_status(filter->inputs[j], ret);
1215 8794 return 0;
1216 }
1217 }
1218
1219
2/2
✓ Branch 0 taken 1935660 times.
✓ Branch 1 taken 1287242 times.
 3222902 for (i = 0; i < filter->nb_inputs; i++) {
1220
2/2
✓ Branch 1 taken 648676 times.
✓ Branch 2 taken 1286984 times.
 1935660 if (samples_ready(ff_link_internal(filter->inputs[i]),
1221 1935660 filter->inputs[i]->min_samples)) {
1222 648676 return ff_filter_frame_to_filter(filter->inputs[i]);
1223 }
1224 }
1225
2/2
✓ Branch 0 taken 1286978 times.
✓ Branch 1 taken 1280482 times.
 2567460 for (i = 0; i < filter->nb_inputs; i++) {
1226 1286978 FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1227
4/4
✓ Branch 0 taken 6778 times.
✓ Branch 1 taken 1280200 times.
✓ Branch 2 taken 6760 times.
✓ Branch 3 taken 18 times.
 1286978 if (li->status_in && !li->status_out) {
1228 av_assert1(!ff_framequeue_queued_frames(&li->fifo));
1229 6760 return forward_status_change(filter, li);
1230 }
1231 }
1232
2/2
✓ Branch 0 taken 1280489 times.
✓ Branch 1 taken 643837 times.
 1924326 for (i = 0; i < filter->nb_outputs; i++) {
1233 1280489 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1234
2/2
✓ Branch 0 taken 636837 times.
✓ Branch 1 taken 643652 times.
 1280489 if (filter->outputs[i]->frame_wanted_out &&
1235
2/2
✓ Branch 0 taken 636645 times.
✓ Branch 1 taken 192 times.
 636837 !li->frame_blocked_in) {
1236 636645 return ff_request_frame_to_filter(filter->outputs[i]);
1237 }
1238 }
1239 643837 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 3159509 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 3159509 filter->ready = 0;
1382
2/2
✓ Branch 0 taken 1214797 times.
✓ Branch 1 taken 1944712 times.
 3159509 ret = filter->filter->activate ? filter->filter->activate(filter) :
1383 1944712 ff_filter_activate_default(filter);
1384
2/2
✓ Branch 0 taken 997268 times.
✓ Branch 1 taken 2162241 times.
 3159509 if (ret == FFERROR_NOT_READY)
1385 997268 ret = 0;
1386 3159509 return ret;
1387 }
1388
1389 2597747 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1390 {
1391 2597747 FilterLinkInternal * const li = ff_link_internal(link);
1392 2597747 *rpts = link->current_pts;
1393
2/2
✓ Branch 1 taken 1629 times.
✓ Branch 2 taken 2596118 times.
 2597747 if (ff_framequeue_queued_frames(&li->fifo))
1394 1629 return *rstatus = 0;
1395
2/2
✓ Branch 0 taken 1867 times.
✓ Branch 1 taken 2594251 times.
 2596118 if (li->status_out)
1396 1867 return *rstatus = li->status_out;
1397
2/2
✓ Branch 0 taken 2588953 times.
✓ Branch 1 taken 5298 times.
 2594251 if (!li->status_in)
1398 2588953 return *rstatus = 0;
1399 5298 *rstatus = li->status_out = li->status_in;
1400 5298 update_link_current_pts(li, li->status_in_pts);
1401 5298 *rpts = link->current_pts;
1402 5298 return 1;
1403 }
1404
1405 448331 size_t ff_inlink_queued_frames(AVFilterLink *link)
1406 {
1407 448331 FilterLinkInternal * const li = ff_link_internal(link);
1408 448331 return ff_framequeue_queued_frames(&li->fifo);
1409 }
1410
1411 3619994 int ff_inlink_check_available_frame(AVFilterLink *link)
1412 {
1413 3619994 FilterLinkInternal * const li = ff_link_internal(link);
1414 3619994 return ff_framequeue_queued_frames(&li->fifo) > 0;
1415 }
1416
1417 1691 int ff_inlink_queued_samples(AVFilterLink *link)
1418 {
1419 1691 FilterLinkInternal * const li = ff_link_internal(link);
1420 1691 return ff_framequeue_queued_samples(&li->fifo);
1421 }
1422
1423 3675 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1424 {
1425 3675 FilterLinkInternal * const li = ff_link_internal(link);
1426 3675 uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1427 av_assert1(min);
1428
6/6
✓ Branch 0 taken 1369 times.
✓ Branch 1 taken 2306 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 1304 times.
✓ Branch 4 taken 7 times.
✓ Branch 5 taken 58 times.
 3675 return samples >= min || (li->status_in && samples);
1429 }
1430
1431 1253550 static void consume_update(FilterLinkInternal *li, const AVFrame *frame)
1432 {
1433 1253550 AVFilterLink *const link = &li->l;
1434 1253550 update_link_current_pts(li, frame->pts);
1435 1253550 ff_inlink_process_commands(link, frame);
1436
2/2
✓ Branch 0 taken 1251306 times.
✓ Branch 1 taken 2244 times.
 1253550 if (link == link->dst->inputs[0])
1437 1251306 link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1438 1253550 link->frame_count_out++;
1439 1253550 link->sample_count_out += frame->nb_samples;
1440 1253550 }
1441
1442 3618110 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1443 {
1444 3618110 FilterLinkInternal * const li = ff_link_internal(link);
1445 AVFrame *frame;
1446
1447 3618110 *rframe = NULL;
1448
2/2
✓ Branch 1 taken 2366869 times.
✓ Branch 2 taken 1251241 times.
 3618110 if (!ff_inlink_check_available_frame(link))
1449 2366869 return 0;
1450
1451
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1251238 times.
 1251241 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 1251238 frame = ff_framequeue_take(&li->fifo);
1457 1251238 consume_update(li, frame);
1458 1251238 *rframe = frame;
1459 1251238 return 1;
1460 }
1461
1462 3532 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1463 AVFrame **rframe)
1464 {
1465 3532 FilterLinkInternal * const li = ff_link_internal(link);
1466 AVFrame *frame;
1467 int ret;
1468
1469 av_assert1(min);
1470 3532 *rframe = NULL;
1471
2/2
✓ Branch 1 taken 1220 times.
✓ Branch 2 taken 2312 times.
 3532 if (!ff_inlink_check_available_samples(link, min))
1472 1220 return 0;
1473
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 2286 times.
 2312 if (li->status_in)
1474
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 20 times.
 26 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 5378 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1490 {
1491 5378 AVFrame *frame = *rframe;
1492 AVFrame *out;
1493 int ret;
1494
1495
2/2
✓ Branch 1 taken 2801 times.
✓ Branch 2 taken 2577 times.
 5378 if (av_frame_is_writable(frame))
1496 2801 return 0;
1497 2577 av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1498
1499
1/3
✓ Branch 0 taken 2577 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 2577 switch (link->type) {
1500 2577 case AVMEDIA_TYPE_VIDEO:
1501 2577 out = ff_get_video_buffer(link, link->w, link->h);
1502 2577 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 2577 times.
 2577 if (!out)
1510 ✗ return AVERROR(ENOMEM);
1511
1512 2577 ret = av_frame_copy_props(out, frame);
1513
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2577 times.
 2577 if (ret < 0) {
1514 ✗ av_frame_free(&out);
1515 ✗ return ret;
1516 }
1517
1518 2577 ret = av_frame_copy(out, frame);
1519
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2577 times.
 2577 if (ret < 0) {
1520 ✗ av_frame_free(&out);
1521 ✗ return ret;
1522 }
1523
1524 2577 av_frame_free(&frame);
1525 2577 *rframe = out;
1526 2577 return 0;
1527 }
1528
1529 1902226 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1530 {
1531 1902226 AVFilterCommand *cmd = link->dst->command_queue;
1532
1533
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1902226 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1902226 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 1902226 return 0;
1542 }
1543
1544 1899982 int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1545 {
1546 1899982 AVFilterContext *dstctx = link->dst;
1547 1899982 int64_t pts = frame->pts;
1548 #if FF_API_FRAME_PKT
1549 FF_DISABLE_DEPRECATION_WARNINGS
1550 1899982 int64_t pos = frame->pkt_pos;
1551 FF_ENABLE_DEPRECATION_WARNINGS
1552 #endif
1553
1554
2/2
✓ Branch 0 taken 1899786 times.
✓ Branch 1 taken 196 times.
 1899982 if (!dstctx->enable_str)
1555 1899786 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 599828 void ff_inlink_request_frame(AVFilterLink *link)
1569 {
1570 599828 av_unused FilterLinkInternal *li = ff_link_internal(link);
1571 av_assert1(!li->status_in);
1572 av_assert1(!li->status_out);
1573 599828 link->frame_wanted_out = 1;
1574 599828 ff_filter_set_ready(link->src, 100);
1575 599828 }
1576
1577 10341 void ff_inlink_set_status(AVFilterLink *link, int status)
1578 {
1579 10341 FilterLinkInternal * const li = ff_link_internal(link);
1580
2/2
✓ Branch 0 taken 9265 times.
✓ Branch 1 taken 1076 times.
 10341 if (li->status_out)
1581 9265 return;
1582 1076 link->frame_wanted_out = 0;
1583 1076 li->frame_blocked_in = 0;
1584 1076 link_set_out_status(link, status, AV_NOPTS_VALUE);
1585
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1076 times.
 1076 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 1075 times.
✓ Branch 1 taken 1 times.
 1076 if (!li->status_in)
1590 1075 li->status_in = status;
1591 }
1592
1593 833440 int ff_outlink_get_status(AVFilterLink *link)
1594 {
1595 833440 FilterLinkInternal * const li = ff_link_internal(link);
1596 833440 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