FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/avfilter.c
Date: 2024-04-19 17:50:32
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 1252760 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 1252760 }
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 1265602 static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
223 {
224 1265602 AVFilterLink *const link = &li->l;
225
226
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 1265583 times.
1265602 if (pts == AV_NOPTS_VALUE)
227 19 return;
228 1265583 link->current_pts = pts;
229 1265583 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 1265583 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 371623 times.
✓ Branch 3 taken 893960 times.
1265583 if (link->graph && li->age_index >= 0)
232 371623 ff_avfilter_graph_update_heap(link->graph, li);
233 }
234
235 3170340 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
236 {
237 3170340 filter->ready = FFMAX(filter->ready, priority);
238 3170340 }
239
240 /**
241 * Clear frame_blocked_in on all outputs.
242 * This is necessary whenever something changes on input.
243 */
244 1921343 static void filter_unblock(AVFilterContext *filter)
245 {
246 unsigned i;
247
248
2/2
✓ Branch 0 taken 1551466 times.
✓ Branch 1 taken 1921343 times.
3472809 for (i = 0; i < filter->nb_outputs; i++) {
249 1551466 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
250 1551466 li->frame_blocked_in = 0;
251 }
252 1921343 }
253
254
255 15054 void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
256 {
257 15054 FilterLinkInternal * const li = ff_link_internal(link);
258
259
2/2
✓ Branch 0 taken 2992 times.
✓ Branch 1 taken 12062 times.
15054 if (li->status_in == status)
260 2992 return;
261
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12062 times.
12062 av_assert0(!li->status_in);
262 12062 li->status_in = status;
263 12062 li->status_in_pts = pts;
264 12062 link->frame_wanted_out = 0;
265 12062 li->frame_blocked_in = 0;
266 12062 filter_unblock(link->dst);
267 12062 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 7838 static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
275 {
276 7838 FilterLinkInternal * const li = ff_link_internal(link);
277
278
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7838 times.
7838 av_assert0(!link->frame_wanted_out);
279
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7838 times.
7838 av_assert0(!li->status_out);
280 7838 li->status_out = status;
281
2/2
✓ Branch 0 taken 6746 times.
✓ Branch 1 taken 1092 times.
7838 if (pts != AV_NOPTS_VALUE)
282 6746 update_link_current_pts(li, pts);
283 7838 filter_unblock(link->dst);
284 7838 ff_filter_set_ready(link->src, 200);
285 7838 }
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 643089 int ff_request_frame(AVFilterLink *link)
464 {
465 643089 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 643080 times.
643089 if (li->status_out)
471 9 return li->status_out;
472
2/2
✓ Branch 0 taken 6762 times.
✓ Branch 1 taken 636318 times.
643080 if (li->status_in) {
473
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6762 times.
6762 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 6762 link_set_out_status(link, li->status_in, li->status_in_pts);
482 6762 return li->status_out;
483 }
484 }
485 636318 link->frame_wanted_out = 1;
486 636318 ff_filter_set_ready(link->src, 100);
487 636318 return 0;
488 }
489
490 6763 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
491 {
492 unsigned i;
493 6763 int64_t r = INT64_MAX;
494
495
2/2
✓ Branch 0 taken 6762 times.
✓ Branch 1 taken 6763 times.
13525 for (i = 0; i < ctx->nb_inputs; i++) {
496 6762 FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
497
1/2
✓ Branch 0 taken 6762 times.
✗ Branch 1 not taken.
6762 if (li->status_out == status)
498 6762 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 6762 times.
✓ Branch 1 taken 1 times.
6763 if (r < INT64_MAX)
501 6762 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 643423 static int ff_request_frame_to_filter(AVFilterLink *link)
513 {
514 643423 FilterLinkInternal * const li = ff_link_internal(link);
515 643423 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 643423 li->frame_blocked_in = 1;
520
2/2
✓ Branch 0 taken 2653 times.
✓ Branch 1 taken 640770 times.
643423 if (link->srcpad->request_frame)
521 2653 ret = link->srcpad->request_frame(link);
522
1/2
✓ Branch 0 taken 640770 times.
✗ Branch 1 not taken.
640770 else if (link->src->inputs[0])
523 640770 ret = ff_request_frame(link->src->inputs[0]);
524
2/2
✓ Branch 0 taken 6763 times.
✓ Branch 1 taken 636660 times.
643423 if (ret < 0) {
525
2/4
✓ Branch 0 taken 6763 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6763 times.
✗ Branch 3 not taken.
6763 if (ret != AVERROR(EAGAIN) && ret != li->status_in)
526 6763 ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
527
1/2
✓ Branch 0 taken 6763 times.
✗ Branch 1 not taken.
6763 if (ret == AVERROR_EOF)
528 6763 ret = 0;
529 }
530 643423 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 584675 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
980 {
981 584675 return ff_filter_frame(link->dst->outputs[0], frame);
982 }
983
984 648683 static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
985 {
986 int (*filter_frame)(AVFilterLink *, AVFrame *);
987 648683 AVFilterContext *dstctx = link->dst;
988 648683 AVFilterPad *dst = link->dstpad;
989 int ret;
990
991
2/2
✓ Branch 0 taken 584666 times.
✓ Branch 1 taken 64017 times.
648683 if (!(filter_frame = dst->filter_frame))
992 584666 filter_frame = default_filter_frame;
993
994
2/2
✓ Branch 0 taken 2281 times.
✓ Branch 1 taken 646402 times.
648683 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 648683 ff_inlink_process_commands(link, frame);
1001 648683 dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1002
1003
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 648664 times.
648683 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 648683 ret = filter_frame(link, frame);
1007 648683 link->frame_count_out++;
1008 648683 return ret;
1009
1010 fail:
1011 av_frame_free(&frame);
1012 return ret;
1013 }
1014
1015 1252760 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1016 {
1017 1252760 FilterLinkInternal * const li = ff_link_internal(link);
1018 int ret;
1019 1252760 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 341641 times.
✓ Branch 1 taken 911119 times.
1252760 if (link->type == AVMEDIA_TYPE_VIDEO) {
1023
2/2
✓ Branch 0 taken 231958 times.
✓ Branch 1 taken 109683 times.
341641 if (strcmp(link->dst->filter->name, "buffersink") &&
1024
2/2
✓ Branch 0 taken 156283 times.
✓ Branch 1 taken 75675 times.
231958 strcmp(link->dst->filter->name, "format") &&
1025
2/2
✓ Branch 0 taken 156257 times.
✓ Branch 1 taken 26 times.
156283 strcmp(link->dst->filter->name, "idet") &&
1026
2/2
✓ Branch 0 taken 69651 times.
✓ Branch 1 taken 86606 times.
156257 strcmp(link->dst->filter->name, "null") &&
1027 69651 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 341641 frame->sample_aspect_ratio = link->sample_aspect_ratio;
1034 } else {
1035
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 911119 times.
911119 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 911119 times.
911119 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 911119 times.
911119 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 911119 frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1049 link->time_base);
1050 }
1051
1052 1252760 li->frame_blocked_in = link->frame_wanted_out = 0;
1053 1252760 link->frame_count_in++;
1054 1252760 link->sample_count_in += frame->nb_samples;
1055 1252760 filter_unblock(link->dst);
1056 1252760 ret = ff_framequeue_add(&li->fifo, frame);
1057
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1252760 times.
1252760 if (ret < 0) {
1058 av_frame_free(&frame);
1059 return ret;
1060 }
1061 1252760 ff_filter_set_ready(link->dst, 300);
1062 1252760 return 0;
1063
1064 error:
1065 av_frame_free(&frame);
1066 return AVERROR_PATCHWELCOME;
1067 }
1068
1069 1935688 static int samples_ready(FilterLinkInternal *link, unsigned min)
1070 {
1071
2/2
✓ Branch 1 taken 648786 times.
✓ Branch 2 taken 1286902 times.
2584474 return ff_framequeue_queued_frames(&link->fifo) &&
1072
2/2
✓ Branch 1 taken 104 times.
✓ Branch 2 taken 648682 times.
648786 (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 648683 static int ff_filter_frame_to_filter(AVFilterLink *link)
1137 {
1138 648683 FilterLinkInternal * const li = ff_link_internal(link);
1139 648683 AVFrame *frame = NULL;
1140 648683 AVFilterContext *dst = link->dst;
1141 int ret;
1142
1143 av_assert1(ff_framequeue_queued_frames(&li->fifo));
1144 1297366 ret = link->min_samples ?
1145
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 648647 times.
648683 ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1146 648647 ff_inlink_consume_frame(link, &frame);
1147 av_assert1(ret);
1148
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 648683 times.
648683 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 648683 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 648683 link->frame_count_out--;
1158 648683 ret = ff_filter_frame_framed(link, frame);
1159
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 648683 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
648683 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 648683 ff_filter_set_ready(dst, 300);
1165 }
1166 648683 return ret;
1167 }
1168
1169 6762 static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
1170 {
1171 6762 AVFilterLink *in = &li_in->l;
1172 6762 unsigned out = 0, progress = 0;
1173 int ret;
1174
1175
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6762 times.
6762 av_assert0(!li_in->status_out);
1176
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6762 times.
6762 if (!filter->nb_outputs) {
1177 /* not necessary with the current API and sinks */
1178 return 0;
1179 }
1180
2/2
✓ Branch 0 taken 6762 times.
✓ Branch 1 taken 6762 times.
13524 while (!li_in->status_out) {
1181 6762 FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1182
1183
1/2
✓ Branch 0 taken 6762 times.
✗ Branch 1 not taken.
6762 if (!li_out->status_in) {
1184 6762 progress++;
1185 6762 ret = ff_request_frame_to_filter(filter->outputs[out]);
1186
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6762 times.
6762 if (ret < 0)
1187 return ret;
1188 }
1189
1/2
✓ Branch 0 taken 6762 times.
✗ Branch 1 not taken.
6762 if (++out == filter->nb_outputs) {
1190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6762 times.
6762 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 6762 progress = 0;
1197 6762 out = 0;
1198 }
1199 }
1200 6762 ff_filter_set_ready(filter, 200);
1201 6762 return 0;
1202 }
1203
1204 1944744 static int ff_filter_activate_default(AVFilterContext *filter)
1205 {
1206 unsigned i;
1207
1208
2/2
✓ Branch 0 taken 1944761 times.
✓ Branch 1 taken 1935946 times.
3880707 for (i = 0; i < filter->nb_outputs; i++) {
1209 1944761 FilterLinkInternal *li = ff_link_internal(filter->outputs[i]);
1210 1944761 int ret = li->status_in;
1211
1212
2/2
✓ Branch 0 taken 8798 times.
✓ Branch 1 taken 1935963 times.
1944761 if (ret) {
1213
2/2
✓ Branch 0 taken 8798 times.
✓ Branch 1 taken 8798 times.
17596 for (int j = 0; j < filter->nb_inputs; j++)
1214 8798 ff_inlink_set_status(filter->inputs[j], ret);
1215 8798 return 0;
1216 }
1217 }
1218
1219
2/2
✓ Branch 0 taken 1935688 times.
✓ Branch 1 taken 1287263 times.
3222951 for (i = 0; i < filter->nb_inputs; i++) {
1220
2/2
✓ Branch 1 taken 648683 times.
✓ Branch 2 taken 1287005 times.
1935688 if (samples_ready(ff_link_internal(filter->inputs[i]),
1221 1935688 filter->inputs[i]->min_samples)) {
1222 648683 return ff_filter_frame_to_filter(filter->inputs[i]);
1223 }
1224 }
1225
2/2
✓ Branch 0 taken 1286999 times.
✓ Branch 1 taken 1280501 times.
2567500 for (i = 0; i < filter->nb_inputs; i++) {
1226 1286999 FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1227
4/4
✓ Branch 0 taken 6780 times.
✓ Branch 1 taken 1280219 times.
✓ Branch 2 taken 6762 times.
✓ Branch 3 taken 18 times.
1286999 if (li->status_in && !li->status_out) {
1228 av_assert1(!ff_framequeue_queued_frames(&li->fifo));
1229 6762 return forward_status_change(filter, li);
1230 }
1231 }
1232
2/2
✓ Branch 0 taken 1280508 times.
✓ Branch 1 taken 643840 times.
1924348 for (i = 0; i < filter->nb_outputs; i++) {
1233 1280508 FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1234
2/2
✓ Branch 0 taken 636853 times.
✓ Branch 1 taken 643655 times.
1280508 if (filter->outputs[i]->frame_wanted_out &&
1235
2/2
✓ Branch 0 taken 636661 times.
✓ Branch 1 taken 192 times.
636853 !li->frame_blocked_in) {
1236 636661 return ff_request_frame_to_filter(filter->outputs[i]);
1237 }
1238 }
1239 643840 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 3159517 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 3159517 filter->ready = 0;
1382
2/2
✓ Branch 0 taken 1214773 times.
✓ Branch 1 taken 1944744 times.
3159517 ret = filter->filter->activate ? filter->filter->activate(filter) :
1383 1944744 ff_filter_activate_default(filter);
1384
2/2
✓ Branch 0 taken 997267 times.
✓ Branch 1 taken 2162250 times.
3159517 if (ret == FFERROR_NOT_READY)
1385 997267 ret = 0;
1386 3159517 return ret;
1387 }
1388
1389 2597642 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1390 {
1391 2597642 FilterLinkInternal * const li = ff_link_internal(link);
1392 2597642 *rpts = link->current_pts;
1393
2/2
✓ Branch 1 taken 1632 times.
✓ Branch 2 taken 2596010 times.
2597642 if (ff_framequeue_queued_frames(&li->fifo))
1394 1632 return *rstatus = 0;
1395
2/2
✓ Branch 0 taken 1782 times.
✓ Branch 1 taken 2594228 times.
2596010 if (li->status_out)
1396 1782 return *rstatus = li->status_out;
1397
2/2
✓ Branch 0 taken 2588929 times.
✓ Branch 1 taken 5299 times.
2594228 if (!li->status_in)
1398 2588929 return *rstatus = 0;
1399 5299 *rstatus = li->status_out = li->status_in;
1400 5299 update_link_current_pts(li, li->status_in_pts);
1401 5299 *rpts = link->current_pts;
1402 5299 return 1;
1403 }
1404
1405 448307 size_t ff_inlink_queued_frames(AVFilterLink *link)
1406 {
1407 448307 FilterLinkInternal * const li = ff_link_internal(link);
1408 448307 return ff_framequeue_queued_frames(&li->fifo);
1409 }
1410
1411 3619927 int ff_inlink_check_available_frame(AVFilterLink *link)
1412 {
1413 3619927 FilterLinkInternal * const li = ff_link_internal(link);
1414 3619927 return ff_framequeue_queued_frames(&li->fifo) > 0;
1415 }
1416
1417 1685 int ff_inlink_queued_samples(AVFilterLink *link)
1418 {
1419 1685 FilterLinkInternal * const li = ff_link_internal(link);
1420 1685 return ff_framequeue_queued_samples(&li->fifo);
1421 }
1422
1423 3706 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1424 {
1425 3706 FilterLinkInternal * const li = ff_link_internal(link);
1426 3706 uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1427 av_assert1(min);
1428
6/6
✓ Branch 0 taken 1400 times.
✓ Branch 1 taken 2306 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 1335 times.
✓ Branch 4 taken 7 times.
✓ Branch 5 taken 58 times.
3706 return samples >= min || (li->status_in && samples);
1429 }
1430
1431 1253557 static void consume_update(FilterLinkInternal *li, const AVFrame *frame)
1432 {
1433 1253557 AVFilterLink *const link = &li->l;
1434 1253557 update_link_current_pts(li, frame->pts);
1435 1253557 ff_inlink_process_commands(link, frame);
1436
2/2
✓ Branch 0 taken 1251317 times.
✓ Branch 1 taken 2240 times.
1253557 if (link == link->dst->inputs[0])
1437 1251317 link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1438 1253557 link->frame_count_out++;
1439 1253557 link->sample_count_out += frame->nb_samples;
1440 1253557 }
1441
1442 3618043 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1443 {
1444 3618043 FilterLinkInternal * const li = ff_link_internal(link);
1445 AVFrame *frame;
1446
1447 3618043 *rframe = NULL;
1448
2/2
✓ Branch 1 taken 2366795 times.
✓ Branch 2 taken 1251248 times.
3618043 if (!ff_inlink_check_available_frame(link))
1449 2366795 return 0;
1450
1451
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1251245 times.
1251248 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 1251245 frame = ff_framequeue_take(&li->fifo);
1457 1251245 consume_update(li, frame);
1458 1251245 *rframe = frame;
1459 1251245 return 1;
1460 }
1461
1462 3536 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1463 AVFrame **rframe)
1464 {
1465 3536 FilterLinkInternal * const li = ff_link_internal(link);
1466 AVFrame *frame;
1467 int ret;
1468
1469 av_assert1(min);
1470 3536 *rframe = NULL;
1471
2/2
✓ Branch 1 taken 1224 times.
✓ Branch 2 taken 2312 times.
3536 if (!ff_inlink_check_available_samples(link, min))
1472 1224 return 0;
1473
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 2303 times.
2312 if (li->status_in)
1474
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 3 times.
9 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 5391 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1490 {
1491 5391 AVFrame *frame = *rframe;
1492 AVFrame *out;
1493 int ret;
1494
1495
2/2
✓ Branch 1 taken 2803 times.
✓ Branch 2 taken 2588 times.
5391 if (av_frame_is_writable(frame))
1496 2803 return 0;
1497 2588 av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1498
1499
1/3
✓ Branch 0 taken 2588 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
2588 switch (link->type) {
1500 2588 case AVMEDIA_TYPE_VIDEO:
1501 2588 out = ff_get_video_buffer(link, link->w, link->h);
1502 2588 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 2588 times.
2588 if (!out)
1510 return AVERROR(ENOMEM);
1511
1512 2588 ret = av_frame_copy_props(out, frame);
1513
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2588 times.
2588 if (ret < 0) {
1514 av_frame_free(&out);
1515 return ret;
1516 }
1517
1518 2588 ret = av_frame_copy(out, frame);
1519
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2588 times.
2588 if (ret < 0) {
1520 av_frame_free(&out);
1521 return ret;
1522 }
1523
1524 2588 av_frame_free(&frame);
1525 2588 *rframe = out;
1526 2588 return 0;
1527 }
1528
1529 1902240 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1530 {
1531 1902240 AVFilterCommand *cmd = link->dst->command_queue;
1532
1533
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1902240 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
1902240 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 1902240 return 0;
1542 }
1543
1544 1900000 int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1545 {
1546 1900000 AVFilterContext *dstctx = link->dst;
1547 1900000 int64_t pts = frame->pts;
1548 #if FF_API_FRAME_PKT
1549 FF_DISABLE_DEPRECATION_WARNINGS
1550 1900000 int64_t pos = frame->pkt_pos;
1551 FF_ENABLE_DEPRECATION_WARNINGS
1552 #endif
1553
1554
2/2
✓ Branch 0 taken 1899804 times.
✓ Branch 1 taken 196 times.
1900000 if (!dstctx->enable_str)
1555 1899804 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 599808 void ff_inlink_request_frame(AVFilterLink *link)
1569 {
1570 599808 av_unused FilterLinkInternal *li = ff_link_internal(link);
1571 av_assert1(!li->status_in);
1572 av_assert1(!li->status_out);
1573 599808 link->frame_wanted_out = 1;
1574 599808 ff_filter_set_ready(link->src, 100);
1575 599808 }
1576
1577 10345 void ff_inlink_set_status(AVFilterLink *link, int status)
1578 {
1579 10345 FilterLinkInternal * const li = ff_link_internal(link);
1580
2/2
✓ Branch 0 taken 9269 times.
✓ Branch 1 taken 1076 times.
10345 if (li->status_out)
1581 9269 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 833409 int ff_outlink_get_status(AVFilterLink *link)
1594 {
1595 833409 FilterLinkInternal * const li = ff_link_internal(link);
1596 833409 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