Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * filter layer | ||
3 | * Copyright (c) 2007 Bobby Bingham | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | #include "libavutil/avassert.h" | ||
23 | #include "libavutil/avstring.h" | ||
24 | #include "libavutil/bprint.h" | ||
25 | #include "libavutil/buffer.h" | ||
26 | #include "libavutil/channel_layout.h" | ||
27 | #include "libavutil/common.h" | ||
28 | #include "libavutil/eval.h" | ||
29 | #include "libavutil/frame.h" | ||
30 | #include "libavutil/hwcontext.h" | ||
31 | #include "libavutil/internal.h" | ||
32 | #include "libavutil/mem.h" | ||
33 | #include "libavutil/opt.h" | ||
34 | #include "libavutil/pixdesc.h" | ||
35 | #include "libavutil/rational.h" | ||
36 | #include "libavutil/samplefmt.h" | ||
37 | |||
38 | #include "audio.h" | ||
39 | #include "avfilter.h" | ||
40 | #include "avfilter_internal.h" | ||
41 | #include "filters.h" | ||
42 | #include "formats.h" | ||
43 | #include "framequeue.h" | ||
44 | #include "framepool.h" | ||
45 | #include "video.h" | ||
46 | |||
47 | 1534355 | static void tlog_ref(void *ctx, AVFrame *ref, int end) | |
48 | { | ||
49 | #ifdef TRACE | ||
50 | ff_tlog(ctx, | ||
51 | "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64, | ||
52 | ref, ref->buf, ref->data[0], | ||
53 | ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3], | ||
54 | ref->pts); | ||
55 | |||
56 | if (ref->width) { | ||
57 | ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c", | ||
58 | ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den, | ||
59 | ref->width, ref->height, | ||
60 | !(ref->flags & AV_FRAME_FLAG_INTERLACED) ? 'P' : /* Progressive */ | ||
61 | (ref->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 'T' : 'B', /* Top / Bottom */ | ||
62 | !!(ref->flags & AV_FRAME_FLAG_KEY), | ||
63 | av_get_picture_type_char(ref->pict_type)); | ||
64 | } | ||
65 | if (ref->nb_samples) { | ||
66 | AVBPrint bprint; | ||
67 | |||
68 | av_bprint_init(&bprint, 1, AV_BPRINT_SIZE_UNLIMITED); | ||
69 | av_channel_layout_describe_bprint(&ref->ch_layout, &bprint); | ||
70 | ff_tlog(ctx, " cl:%s n:%d r:%d", | ||
71 | bprint.str, | ||
72 | ref->nb_samples, | ||
73 | ref->sample_rate); | ||
74 | av_bprint_finalize(&bprint, NULL); | ||
75 | } | ||
76 | |||
77 | ff_tlog(ctx, "]%s", end ? "\n" : ""); | ||
78 | #endif | ||
79 | 1534355 | } | |
80 | |||
81 | ✗ | static void command_queue_pop(AVFilterContext *filter) | |
82 | { | ||
83 | ✗ | FFFilterContext *ctxi = fffilterctx(filter); | |
84 | ✗ | AVFilterCommand *c = ctxi->command_queue; | |
85 | ✗ | av_freep(&c->arg); | |
86 | ✗ | av_freep(&c->command); | |
87 | ✗ | ctxi->command_queue = c->next; | |
88 | ✗ | av_free(c); | |
89 | ✗ | } | |
90 | |||
91 | /** | ||
92 | * Append a new pad. | ||
93 | * | ||
94 | * @param count Pointer to the number of pads in the list | ||
95 | * @param pads Pointer to the pointer to the beginning of the list of pads | ||
96 | * @param links Pointer to the pointer to the beginning of the list of links | ||
97 | * @param newpad The new pad to add. A copy is made when adding. | ||
98 | * @return >= 0 in case of success, a negative AVERROR code on error | ||
99 | */ | ||
100 | 520 | static int append_pad(unsigned *count, AVFilterPad **pads, | |
101 | AVFilterLink ***links, AVFilterPad *newpad) | ||
102 | { | ||
103 | AVFilterLink **newlinks; | ||
104 | AVFilterPad *newpads; | ||
105 | 520 | unsigned idx = *count; | |
106 | |||
107 | 520 | newpads = av_realloc_array(*pads, idx + 1, sizeof(*newpads)); | |
108 | 520 | newlinks = av_realloc_array(*links, idx + 1, sizeof(*newlinks)); | |
109 |
1/2✓ Branch 0 taken 520 times.
✗ Branch 1 not taken.
|
520 | if (newpads) |
110 | 520 | *pads = newpads; | |
111 |
1/2✓ Branch 0 taken 520 times.
✗ Branch 1 not taken.
|
520 | if (newlinks) |
112 | 520 | *links = newlinks; | |
113 |
2/4✓ Branch 0 taken 520 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 520 times.
|
520 | if (!newpads || !newlinks) { |
114 | ✗ | if (newpad->flags & AVFILTERPAD_FLAG_FREE_NAME) | |
115 | ✗ | av_freep(&newpad->name); | |
116 | ✗ | return AVERROR(ENOMEM); | |
117 | } | ||
118 | |||
119 | 520 | memcpy(*pads + idx, newpad, sizeof(AVFilterPad)); | |
120 | 520 | (*links)[idx] = NULL; | |
121 | |||
122 | 520 | (*count)++; | |
123 | |||
124 | 520 | return 0; | |
125 | } | ||
126 | |||
127 | 235 | int ff_append_inpad(AVFilterContext *f, AVFilterPad *p) | |
128 | { | ||
129 | 235 | return append_pad(&f->nb_inputs, &f->input_pads, &f->inputs, p); | |
130 | } | ||
131 | |||
132 | 216 | int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p) | |
133 | { | ||
134 | 216 | p->flags |= AVFILTERPAD_FLAG_FREE_NAME; | |
135 | 216 | return ff_append_inpad(f, p); | |
136 | } | ||
137 | |||
138 | 285 | int ff_append_outpad(AVFilterContext *f, AVFilterPad *p) | |
139 | { | ||
140 | 285 | return append_pad(&f->nb_outputs, &f->output_pads, &f->outputs, p); | |
141 | } | ||
142 | |||
143 | 144 | int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p) | |
144 | { | ||
145 | 144 | p->flags |= AVFILTERPAD_FLAG_FREE_NAME; | |
146 | 144 | return ff_append_outpad(f, p); | |
147 | } | ||
148 | |||
149 | 46649 | 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 46649 times.
|
46649 | av_assert0(src->graph); |
156 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46649 times.
|
46649 | av_assert0(dst->graph); |
157 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46649 times.
|
46649 | av_assert0(src->graph == dst->graph); |
158 | |||
159 |
2/4✓ Branch 0 taken 46649 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46649 times.
✗ Branch 3 not taken.
|
46649 | if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad || |
160 |
2/4✓ Branch 0 taken 46649 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 46649 times.
|
46649 | src->outputs[srcpad] || dst->inputs[dstpad]) |
161 | ✗ | return AVERROR(EINVAL); | |
162 | |||
163 |
1/2✓ Branch 1 taken 46649 times.
✗ Branch 2 not taken.
|
46649 | if (!(fffilterctx(src)->state_flags & AV_CLASS_STATE_INITIALIZED) || |
164 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 46649 times.
|
46649 | !(fffilterctx(dst)->state_flags & AV_CLASS_STATE_INITIALIZED)) { |
165 | ✗ | av_log(src, AV_LOG_ERROR, "Filters must be initialized before linking.\n"); | |
166 | ✗ | return AVERROR(EINVAL); | |
167 | } | ||
168 | |||
169 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46649 times.
|
46649 | if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) { |
170 | ✗ | av_log(src, AV_LOG_ERROR, | |
171 | "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n", | ||
172 | ✗ | src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"), | |
173 | ✗ | dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?")); | |
174 | ✗ | return AVERROR(EINVAL); | |
175 | } | ||
176 | |||
177 | 46649 | li = av_mallocz(sizeof(*li)); | |
178 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46649 times.
|
46649 | if (!li) |
179 | ✗ | return AVERROR(ENOMEM); | |
180 | 46649 | link = &li->l.pub; | |
181 | |||
182 | 46649 | src->outputs[srcpad] = dst->inputs[dstpad] = link; | |
183 | |||
184 | 46649 | link->src = src; | |
185 | 46649 | link->dst = dst; | |
186 | 46649 | link->srcpad = &src->output_pads[srcpad]; | |
187 | 46649 | link->dstpad = &dst->input_pads[dstpad]; | |
188 | 46649 | link->type = src->output_pads[srcpad].type; | |
189 | 46649 | li->l.graph = src->graph; | |
190 | av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1); | ||
191 | 46649 | link->format = -1; | |
192 | 46649 | link->colorspace = AVCOL_SPC_UNSPECIFIED; | |
193 | 46649 | ff_framequeue_init(&li->fifo, &fffiltergraph(src->graph)->frame_queues); | |
194 | |||
195 | 46649 | return 0; | |
196 | } | ||
197 | |||
198 | 46781 | static void link_free(AVFilterLink **link) | |
199 | { | ||
200 | FilterLinkInternal *li; | ||
201 | |||
202 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46781 times.
|
46781 | if (!*link) |
203 | ✗ | return; | |
204 | 46781 | li = ff_link_internal(*link); | |
205 | |||
206 | 46781 | ff_framequeue_free(&li->fifo); | |
207 | 46781 | ff_frame_pool_uninit(&li->frame_pool); | |
208 | 46781 | av_channel_layout_uninit(&(*link)->ch_layout); | |
209 | 46781 | av_frame_side_data_free(&(*link)->side_data, &(*link)->nb_side_data); | |
210 | |||
211 | 46781 | av_buffer_unref(&li->l.hw_frames_ctx); | |
212 | |||
213 | 46781 | av_freep(link); | |
214 | } | ||
215 | |||
216 | 1545652 | static void update_link_current_pts(FilterLinkInternal *li, int64_t pts) | |
217 | { | ||
218 | 1545652 | AVFilterLink *const link = &li->l.pub; | |
219 | |||
220 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1545647 times.
|
1545652 | if (pts == AV_NOPTS_VALUE) |
221 | 5 | return; | |
222 | 1545647 | li->l.current_pts = pts; | |
223 | 1545647 | li->l.current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q); | |
224 | /* TODO use duration */ | ||
225 |
3/4✓ Branch 0 taken 1545647 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 420210 times.
✓ Branch 3 taken 1125437 times.
|
1545647 | if (li->l.graph && li->age_index >= 0) |
226 | 420210 | ff_avfilter_graph_update_heap(li->l.graph, li); | |
227 | } | ||
228 | |||
229 | 3828859 | void ff_filter_set_ready(AVFilterContext *filter, unsigned priority) | |
230 | { | ||
231 | 3828859 | FFFilterContext *ctxi = fffilterctx(filter); | |
232 | 3828859 | ctxi->ready = FFMAX(ctxi->ready, priority); | |
233 | 3828859 | } | |
234 | |||
235 | /** | ||
236 | * Clear frame_blocked_in on all outputs. | ||
237 | * This is necessary whenever something changes on input. | ||
238 | */ | ||
239 | 2285046 | static void filter_unblock(AVFilterContext *filter) | |
240 | { | ||
241 | unsigned i; | ||
242 | |||
243 |
2/2✓ Branch 0 taken 1864832 times.
✓ Branch 1 taken 2285046 times.
|
4149878 | for (i = 0; i < filter->nb_outputs; i++) { |
244 | 1864832 | FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]); | |
245 | 1864832 | li->frame_blocked_in = 0; | |
246 | } | ||
247 | 2285046 | } | |
248 | |||
249 | |||
250 | 19351 | void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts) | |
251 | { | ||
252 | 19351 | FilterLinkInternal * const li = ff_link_internal(link); | |
253 | |||
254 |
2/2✓ Branch 0 taken 5520 times.
✓ Branch 1 taken 13831 times.
|
19351 | if (li->status_in == status) |
255 | 5520 | return; | |
256 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13831 times.
|
13831 | av_assert0(!li->status_in); |
257 | 13831 | li->status_in = status; | |
258 | 13831 | li->status_in_pts = pts; | |
259 | 13831 | li->frame_wanted_out = 0; | |
260 | 13831 | li->frame_blocked_in = 0; | |
261 | 13831 | filter_unblock(link->dst); | |
262 | 13831 | ff_filter_set_ready(link->dst, 200); | |
263 | } | ||
264 | |||
265 | /** | ||
266 | * Set the status field of a link from the destination filter. | ||
267 | * The pts should probably be left unset (AV_NOPTS_VALUE). | ||
268 | */ | ||
269 | 8381 | static void link_set_out_status(AVFilterLink *link, int status, int64_t pts) | |
270 | { | ||
271 | 8381 | FilterLinkInternal * const li = ff_link_internal(link); | |
272 | |||
273 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8381 times.
|
8381 | av_assert0(!li->frame_wanted_out); |
274 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8381 times.
|
8381 | av_assert0(!li->status_out); |
275 | 8381 | li->status_out = status; | |
276 |
2/2✓ Branch 0 taken 5981 times.
✓ Branch 1 taken 2400 times.
|
8381 | if (pts != AV_NOPTS_VALUE) |
277 | 5981 | update_link_current_pts(li, pts); | |
278 | 8381 | filter_unblock(link->dst); | |
279 | 8381 | ff_filter_set_ready(link->src, 200); | |
280 | 8381 | } | |
281 | |||
282 | 1253 | int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, | |
283 | unsigned filt_srcpad_idx, unsigned filt_dstpad_idx) | ||
284 | { | ||
285 | int ret; | ||
286 | 1253 | unsigned dstpad_idx = link->dstpad - link->dst->input_pads; | |
287 | |||
288 | 1253 | av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' " | |
289 | "between the filter '%s' and the filter '%s'\n", | ||
290 | 1253 | filt->name, link->src->name, link->dst->name); | |
291 | |||
292 | 1253 | link->dst->inputs[dstpad_idx] = NULL; | |
293 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1253 times.
|
1253 | if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) { |
294 | /* failed to link output filter to new filter */ | ||
295 | ✗ | link->dst->inputs[dstpad_idx] = link; | |
296 | ✗ | return ret; | |
297 | } | ||
298 | |||
299 | /* re-hookup the link to the new destination filter we inserted */ | ||
300 | 1253 | link->dst = filt; | |
301 | 1253 | link->dstpad = &filt->input_pads[filt_srcpad_idx]; | |
302 | 1253 | filt->inputs[filt_srcpad_idx] = link; | |
303 | |||
304 | /* if any information on supported media formats already exists on the | ||
305 | * link, we need to preserve that */ | ||
306 |
1/2✓ Branch 0 taken 1253 times.
✗ Branch 1 not taken.
|
1253 | if (link->outcfg.formats) |
307 | 1253 | ff_formats_changeref(&link->outcfg.formats, | |
308 | 1253 | &filt->outputs[filt_dstpad_idx]->outcfg.formats); | |
309 |
2/2✓ Branch 0 taken 622 times.
✓ Branch 1 taken 631 times.
|
1253 | if (link->outcfg.color_spaces) |
310 | 622 | ff_formats_changeref(&link->outcfg.color_spaces, | |
311 | 622 | &filt->outputs[filt_dstpad_idx]->outcfg.color_spaces); | |
312 |
2/2✓ Branch 0 taken 622 times.
✓ Branch 1 taken 631 times.
|
1253 | if (link->outcfg.color_ranges) |
313 | 622 | ff_formats_changeref(&link->outcfg.color_ranges, | |
314 | 622 | &filt->outputs[filt_dstpad_idx]->outcfg.color_ranges); | |
315 |
2/2✓ Branch 0 taken 622 times.
✓ Branch 1 taken 631 times.
|
1253 | if (link->outcfg.alpha_modes) |
316 | 622 | ff_formats_changeref(&link->outcfg.alpha_modes, | |
317 | 622 | &filt->outputs[filt_dstpad_idx]->outcfg.alpha_modes); | |
318 |
2/2✓ Branch 0 taken 631 times.
✓ Branch 1 taken 622 times.
|
1253 | if (link->outcfg.samplerates) |
319 | 631 | ff_formats_changeref(&link->outcfg.samplerates, | |
320 | 631 | &filt->outputs[filt_dstpad_idx]->outcfg.samplerates); | |
321 |
2/2✓ Branch 0 taken 631 times.
✓ Branch 1 taken 622 times.
|
1253 | if (link->outcfg.channel_layouts) |
322 | 631 | ff_channel_layouts_changeref(&link->outcfg.channel_layouts, | |
323 | 631 | &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts); | |
324 | |||
325 | 1253 | return 0; | |
326 | } | ||
327 | |||
328 | 44683 | int ff_filter_config_links(AVFilterContext *filter) | |
329 | { | ||
330 | int (*config_link)(AVFilterLink *); | ||
331 | unsigned i; | ||
332 | int ret; | ||
333 | |||
334 |
2/2✓ Branch 0 taken 36561 times.
✓ Branch 1 taken 44683 times.
|
81244 | for (i = 0; i < filter->nb_inputs; i ++) { |
335 | 36561 | AVFilterLink *link = filter->inputs[i]; | |
336 | AVFilterLink *inlink; | ||
337 | 36561 | FilterLinkInternal *li = ff_link_internal(link); | |
338 | FilterLinkInternal *li_in; | ||
339 | |||
340 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 36561 times.
|
36561 | if (!link) continue; |
341 |
2/4✓ Branch 0 taken 36561 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 36561 times.
|
36561 | if (!link->src || !link->dst) { |
342 | ✗ | av_log(filter, AV_LOG_ERROR, | |
343 | "Not all input and output are properly linked (%d).\n", i); | ||
344 | ✗ | return AVERROR(EINVAL); | |
345 | } | ||
346 | |||
347 |
2/2✓ Branch 0 taken 28259 times.
✓ Branch 1 taken 8302 times.
|
36561 | inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL; |
348 |
2/2✓ Branch 0 taken 28259 times.
✓ Branch 1 taken 8302 times.
|
36561 | li_in = inlink ? ff_link_internal(inlink) : NULL; |
349 | 36561 | li->l.current_pts = | |
350 | 36561 | li->l.current_pts_us = AV_NOPTS_VALUE; | |
351 | |||
352 |
2/4✓ Branch 0 taken 109 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 36452 times.
✗ Branch 3 not taken.
|
36561 | switch (li->init_state) { |
353 | 109 | case AVLINK_INIT: | |
354 | 109 | continue; | |
355 | ✗ | case AVLINK_STARTINIT: | |
356 | ✗ | av_log(filter, AV_LOG_INFO, "circular filter chain detected\n"); | |
357 | ✗ | return 0; | |
358 | 36452 | case AVLINK_UNINIT: | |
359 | 36452 | li->init_state = AVLINK_STARTINIT; | |
360 | |||
361 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 36452 times.
|
36452 | if ((ret = ff_filter_config_links(link->src)) < 0) |
362 | ✗ | return ret; | |
363 | |||
364 |
2/2✓ Branch 0 taken 19092 times.
✓ Branch 1 taken 17360 times.
|
36452 | if (!(config_link = link->srcpad->config_props)) { |
365 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19092 times.
|
19092 | if (link->src->nb_inputs != 1) { |
366 | ✗ | av_log(link->src, AV_LOG_ERROR, "Source filters and filters " | |
367 | "with more than one input " | ||
368 | "must set config_props() " | ||
369 | "callbacks on all outputs\n"); | ||
370 | ✗ | return AVERROR(EINVAL); | |
371 | } | ||
372 | } | ||
373 | |||
374 | /* Copy side data before link->srcpad->config_props() is called, so the filter | ||
375 | * may remove it for the next filter in the chain */ | ||
376 |
5/6✓ Branch 0 taken 28182 times.
✓ Branch 1 taken 8270 times.
✓ Branch 2 taken 273 times.
✓ Branch 3 taken 27909 times.
✓ Branch 4 taken 273 times.
✗ Branch 5 not taken.
|
36452 | if (inlink && inlink->nb_side_data && !link->nb_side_data) { |
377 |
2/2✓ Branch 0 taken 299 times.
✓ Branch 1 taken 273 times.
|
572 | for (int j = 0; j < inlink->nb_side_data; j++) { |
378 | 299 | ret = av_frame_side_data_clone(&link->side_data, &link->nb_side_data, | |
379 | 299 | inlink->side_data[j], 0); | |
380 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 299 times.
|
299 | if (ret < 0) { |
381 | ✗ | av_frame_side_data_free(&link->side_data, &link->nb_side_data); | |
382 | ✗ | return ret; | |
383 | } | ||
384 | } | ||
385 | } | ||
386 | |||
387 |
3/4✓ Branch 0 taken 17360 times.
✓ Branch 1 taken 19092 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 17360 times.
|
36452 | if (config_link && (ret = config_link(link)) < 0) { |
388 | ✗ | av_log(link->src, AV_LOG_ERROR, | |
389 | "Failed to configure output pad on %s\n", | ||
390 | ✗ | link->src->name); | |
391 | ✗ | return ret; | |
392 | } | ||
393 | |||
394 |
2/3✓ Branch 0 taken 30527 times.
✓ Branch 1 taken 5925 times.
✗ Branch 2 not taken.
|
36452 | switch (link->type) { |
395 | 30527 | case AVMEDIA_TYPE_VIDEO: | |
396 |
3/4✓ Branch 0 taken 23374 times.
✓ Branch 1 taken 7153 times.
✓ Branch 2 taken 23374 times.
✗ Branch 3 not taken.
|
30527 | if (!link->time_base.num && !link->time_base.den) |
397 |
1/2✓ Branch 0 taken 23374 times.
✗ Branch 1 not taken.
|
23374 | link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q; |
398 | |||
399 |
4/4✓ Branch 0 taken 26223 times.
✓ Branch 1 taken 4304 times.
✓ Branch 2 taken 16623 times.
✓ Branch 3 taken 9600 times.
|
30527 | if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den) |
400 | 16623 | link->sample_aspect_ratio = inlink ? | |
401 |
2/2✓ Branch 0 taken 16608 times.
✓ Branch 1 taken 15 times.
|
16623 | inlink->sample_aspect_ratio : (AVRational){1,1}; |
402 | |||
403 |
2/2✓ Branch 0 taken 23627 times.
✓ Branch 1 taken 6900 times.
|
30527 | if (inlink) { |
404 |
3/4✓ Branch 0 taken 23417 times.
✓ Branch 1 taken 210 times.
✓ Branch 2 taken 23417 times.
✗ Branch 3 not taken.
|
23627 | if (!li->l.frame_rate.num && !li->l.frame_rate.den) |
405 | 23417 | li->l.frame_rate = li_in->l.frame_rate; | |
406 |
2/2✓ Branch 0 taken 16126 times.
✓ Branch 1 taken 7501 times.
|
23627 | if (!link->w) |
407 | 16126 | link->w = inlink->w; | |
408 |
2/2✓ Branch 0 taken 16126 times.
✓ Branch 1 taken 7501 times.
|
23627 | if (!link->h) |
409 | 16126 | link->h = inlink->h; | |
410 |
2/4✓ Branch 0 taken 6900 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6900 times.
|
6900 | } else if (!link->w || !link->h) { |
411 | ✗ | av_log(link->src, AV_LOG_ERROR, | |
412 | "Video source filters must set their output link's " | ||
413 | "width and height\n"); | ||
414 | ✗ | return AVERROR(EINVAL); | |
415 | } | ||
416 | 30527 | break; | |
417 | |||
418 | 5925 | case AVMEDIA_TYPE_AUDIO: | |
419 |
2/2✓ Branch 0 taken 4555 times.
✓ Branch 1 taken 1370 times.
|
5925 | if (inlink) { |
420 |
3/4✓ Branch 0 taken 3054 times.
✓ Branch 1 taken 1501 times.
✓ Branch 2 taken 3054 times.
✗ Branch 3 not taken.
|
4555 | if (!link->time_base.num && !link->time_base.den) |
421 | 3054 | link->time_base = inlink->time_base; | |
422 | } | ||
423 | |||
424 |
3/4✓ Branch 0 taken 83 times.
✓ Branch 1 taken 5842 times.
✓ Branch 2 taken 83 times.
✗ Branch 3 not taken.
|
5925 | if (!link->time_base.num && !link->time_base.den) |
425 | 83 | link->time_base = (AVRational) {1, link->sample_rate}; | |
426 | } | ||
427 | |||
428 |
2/2✓ Branch 0 taken 28182 times.
✓ Branch 1 taken 8270 times.
|
36452 | if (link->src->nb_inputs && |
429 |
1/2✓ Branch 1 taken 28182 times.
✗ Branch 2 not taken.
|
28182 | !(fffilter(link->src->filter)->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) { |
430 | 28182 | FilterLink *l0 = ff_filter_link(link->src->inputs[0]); | |
431 | |||
432 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28182 times.
|
28182 | av_assert0(!li->l.hw_frames_ctx && |
433 | "should not be set by non-hwframe-aware filter"); | ||
434 | |||
435 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28182 times.
|
28182 | if (l0->hw_frames_ctx) { |
436 | ✗ | li->l.hw_frames_ctx = av_buffer_ref(l0->hw_frames_ctx); | |
437 | ✗ | if (!li->l.hw_frames_ctx) | |
438 | ✗ | return AVERROR(ENOMEM); | |
439 | } | ||
440 | } | ||
441 | |||
442 |
2/2✓ Branch 0 taken 4825 times.
✓ Branch 1 taken 31627 times.
|
36452 | if ((config_link = link->dstpad->config_props)) |
443 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4825 times.
|
4825 | if ((ret = config_link(link)) < 0) { |
444 | ✗ | av_log(link->dst, AV_LOG_ERROR, | |
445 | "Failed to configure input pad on %s\n", | ||
446 | ✗ | link->dst->name); | |
447 | ✗ | return ret; | |
448 | } | ||
449 | |||
450 | 36452 | li->init_state = AVLINK_INIT; | |
451 | } | ||
452 | } | ||
453 | |||
454 | 44683 | return 0; | |
455 | } | ||
456 | |||
457 | #ifdef TRACE | ||
458 | void ff_tlog_link(void *ctx, AVFilterLink *link, int end) | ||
459 | { | ||
460 | if (link->type == AVMEDIA_TYPE_VIDEO) { | ||
461 | ff_tlog(ctx, | ||
462 | "link[%p s:%dx%d fmt:%s %s->%s]%s", | ||
463 | link, link->w, link->h, | ||
464 | av_get_pix_fmt_name(link->format), | ||
465 | link->src ? link->src->filter->name : "", | ||
466 | link->dst ? link->dst->filter->name : "", | ||
467 | end ? "\n" : ""); | ||
468 | } else { | ||
469 | char buf[128]; | ||
470 | av_channel_layout_describe(&link->ch_layout, buf, sizeof(buf)); | ||
471 | |||
472 | ff_tlog(ctx, | ||
473 | "link[%p r:%d cl:%s fmt:%s %s->%s]%s", | ||
474 | link, (int)link->sample_rate, buf, | ||
475 | av_get_sample_fmt_name(link->format), | ||
476 | link->src ? link->src->filter->name : "", | ||
477 | link->dst ? link->dst->filter->name : "", | ||
478 | end ? "\n" : ""); | ||
479 | } | ||
480 | } | ||
481 | #endif | ||
482 | |||
483 | 728653 | int ff_request_frame(AVFilterLink *link) | |
484 | { | ||
485 | 728653 | FilterLinkInternal * const li = ff_link_internal(link); | |
486 | |||
487 | FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1); | ||
488 | |||
489 | av_assert1(!fffilter(link->dst->filter)->activate); | ||
490 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 728644 times.
|
728653 | if (li->status_out) |
491 | 9 | return li->status_out; | |
492 |
2/2✓ Branch 0 taken 5982 times.
✓ Branch 1 taken 722662 times.
|
728644 | if (li->status_in) { |
493 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 5982 times.
|
5982 | if (ff_framequeue_queued_frames(&li->fifo)) { |
494 | av_assert1(!li->frame_wanted_out); | ||
495 | av_assert1(fffilterctx(link->dst)->ready >= 300); | ||
496 | ✗ | return 0; | |
497 | } else { | ||
498 | /* Acknowledge status change. Filters using ff_request_frame() will | ||
499 | handle the change automatically. Filters can also check the | ||
500 | status directly but none do yet. */ | ||
501 | 5982 | link_set_out_status(link, li->status_in, li->status_in_pts); | |
502 | 5982 | return li->status_out; | |
503 | } | ||
504 | } | ||
505 | 722662 | li->frame_wanted_out = 1; | |
506 | 722662 | ff_filter_set_ready(link->src, 100); | |
507 | 722662 | return 0; | |
508 | } | ||
509 | |||
510 | 5977 | static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base) | |
511 | { | ||
512 | unsigned i; | ||
513 | 5977 | int64_t r = INT64_MAX; | |
514 | |||
515 |
2/2✓ Branch 0 taken 5976 times.
✓ Branch 1 taken 5977 times.
|
11953 | for (i = 0; i < ctx->nb_inputs; i++) { |
516 | 5976 | FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]); | |
517 |
1/2✓ Branch 0 taken 5976 times.
✗ Branch 1 not taken.
|
5976 | if (li->status_out == status) |
518 | 5976 | r = FFMIN(r, av_rescale_q(li->l.current_pts, ctx->inputs[i]->time_base, link_time_base)); | |
519 | } | ||
520 |
2/2✓ Branch 0 taken 5976 times.
✓ Branch 1 taken 1 times.
|
5977 | if (r < INT64_MAX) |
521 | 5976 | return r; | |
522 | 1 | av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n"); | |
523 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | for (i = 0; i < ctx->nb_inputs; i++) { |
524 | ✗ | FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]); | |
525 | ✗ | r = FFMIN(r, av_rescale_q(li->status_in_pts, ctx->inputs[i]->time_base, link_time_base)); | |
526 | } | ||
527 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (r < INT64_MAX) |
528 | ✗ | return r; | |
529 | 1 | return AV_NOPTS_VALUE; | |
530 | } | ||
531 | |||
532 | 728965 | static int request_frame_to_filter(AVFilterLink *link) | |
533 | { | ||
534 | 728965 | FilterLinkInternal * const li = ff_link_internal(link); | |
535 | 728965 | int ret = -1; | |
536 | |||
537 | FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1); | ||
538 | /* Assume the filter is blocked, let the method clear it if not */ | ||
539 | 728965 | li->frame_blocked_in = 1; | |
540 |
2/2✓ Branch 0 taken 2021 times.
✓ Branch 1 taken 726944 times.
|
728965 | if (link->srcpad->request_frame) |
541 | 2021 | ret = link->srcpad->request_frame(link); | |
542 |
1/2✓ Branch 0 taken 726944 times.
✗ Branch 1 not taken.
|
726944 | else if (link->src->inputs[0]) |
543 | 726944 | ret = ff_request_frame(link->src->inputs[0]); | |
544 |
2/2✓ Branch 0 taken 5977 times.
✓ Branch 1 taken 722988 times.
|
728965 | if (ret < 0) { |
545 |
2/4✓ Branch 0 taken 5977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5977 times.
✗ Branch 3 not taken.
|
5977 | if (ret != AVERROR(EAGAIN) && ret != li->status_in) |
546 | 5977 | ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base)); | |
547 |
1/2✓ Branch 0 taken 5977 times.
✗ Branch 1 not taken.
|
5977 | if (ret == AVERROR_EOF) |
548 | 5977 | ret = 0; | |
549 | } | ||
550 | 728965 | return ret; | |
551 | } | ||
552 | |||
553 | static const char *const var_names[] = { | ||
554 | "t", | ||
555 | "n", | ||
556 | "w", | ||
557 | "h", | ||
558 | NULL | ||
559 | }; | ||
560 | |||
561 | enum { | ||
562 | VAR_T, | ||
563 | VAR_N, | ||
564 | VAR_W, | ||
565 | VAR_H, | ||
566 | VAR_VARS_NB | ||
567 | }; | ||
568 | |||
569 | 6 | static int set_enable_expr(FFFilterContext *ctxi, const char *expr) | |
570 | { | ||
571 | 6 | AVFilterContext *ctx = &ctxi->p; | |
572 | int ret; | ||
573 | char *expr_dup; | ||
574 | 6 | AVExpr *old = ctxi->enable; | |
575 | |||
576 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) { |
577 | ✗ | av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported " | |
578 | ✗ | "with filter '%s'\n", ctx->filter->name); | |
579 | ✗ | return AVERROR_PATCHWELCOME; | |
580 | } | ||
581 | |||
582 | 6 | expr_dup = av_strdup(expr); | |
583 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (!expr_dup) |
584 | ✗ | return AVERROR(ENOMEM); | |
585 | |||
586 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | if (!ctxi->var_values) { |
587 | 6 | ctxi->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctxi->var_values)); | |
588 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (!ctxi->var_values) { |
589 | ✗ | av_free(expr_dup); | |
590 | ✗ | return AVERROR(ENOMEM); | |
591 | } | ||
592 | } | ||
593 | |||
594 | 6 | ret = av_expr_parse(&ctxi->enable, expr_dup, var_names, | |
595 | NULL, NULL, NULL, NULL, 0, ctx->priv); | ||
596 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (ret < 0) { |
597 | ✗ | av_log(ctx->priv, AV_LOG_ERROR, | |
598 | "Error when evaluating the expression '%s' for enable\n", | ||
599 | expr_dup); | ||
600 | ✗ | av_free(expr_dup); | |
601 | ✗ | return ret; | |
602 | } | ||
603 | |||
604 | 6 | av_expr_free(old); | |
605 | 6 | av_free(ctx->enable_str); | |
606 | 6 | ctx->enable_str = expr_dup; | |
607 | 6 | return 0; | |
608 | } | ||
609 | |||
610 | ✗ | int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags) | |
611 | { | ||
612 | ✗ | if(!strcmp(cmd, "ping")){ | |
613 | ✗ | char local_res[256] = {0}; | |
614 | |||
615 | ✗ | if (!res) { | |
616 | ✗ | res = local_res; | |
617 | ✗ | res_len = sizeof(local_res); | |
618 | } | ||
619 | ✗ | av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name); | |
620 | ✗ | if (res == local_res) | |
621 | ✗ | av_log(filter, AV_LOG_INFO, "%s", res); | |
622 | ✗ | return 0; | |
623 | ✗ | }else if(!strcmp(cmd, "enable")) { | |
624 | ✗ | return set_enable_expr(fffilterctx(filter), arg); | |
625 | ✗ | }else if (fffilter(filter->filter)->process_command) { | |
626 | ✗ | return fffilter(filter->filter)->process_command(filter, cmd, arg, res, res_len, flags); | |
627 | } | ||
628 | ✗ | return AVERROR(ENOSYS); | |
629 | } | ||
630 | |||
631 | 14843 | unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output) | |
632 | { | ||
633 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14843 times.
|
14843 | return is_output ? fffilter(filter)->nb_outputs : fffilter(filter)->nb_inputs; |
634 | } | ||
635 | |||
636 | 582 | static const char *default_filter_name(void *filter_ctx) | |
637 | { | ||
638 | 582 | AVFilterContext *ctx = filter_ctx; | |
639 |
1/2✓ Branch 0 taken 582 times.
✗ Branch 1 not taken.
|
582 | return ctx->name ? ctx->name : ctx->filter->name; |
640 | } | ||
641 | |||
642 | 55960 | static void *filter_child_next(void *obj, void *prev) | |
643 | { | ||
644 | 55960 | AVFilterContext *ctx = obj; | |
645 |
5/8✓ Branch 0 taken 55954 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 55954 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 55954 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 55954 times.
✗ Branch 7 not taken.
|
55960 | if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv) |
646 | 55954 | return ctx->priv; | |
647 | 6 | return NULL; | |
648 | } | ||
649 | |||
650 | ✗ | static const AVClass *filter_child_class_iterate(void **iter) | |
651 | { | ||
652 | const AVFilter *f; | ||
653 | |||
654 | ✗ | while ((f = av_filter_iterate(iter))) | |
655 | ✗ | if (f->priv_class) | |
656 | ✗ | return f->priv_class; | |
657 | |||
658 | ✗ | return NULL; | |
659 | } | ||
660 | |||
661 | #define OFFSET(x) offsetof(AVFilterContext, x) | ||
662 | #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | ||
663 | #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM | ||
664 | static const AVOption avfilter_options[] = { | ||
665 | { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS, | ||
666 | { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, .unit = "thread_type" }, | ||
667 | { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" }, | ||
668 | { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = TFLAGS }, | ||
669 | { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT, | ||
670 | { .i64 = 0 }, 0, INT_MAX, FLAGS, .unit = "threads" }, | ||
671 | {"auto", "autodetect a suitable number of threads to use", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, .flags = FLAGS, .unit = "threads"}, | ||
672 | { "extra_hw_frames", "Number of extra hardware frames to allocate for the user", | ||
673 | OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS }, | ||
674 | { NULL }, | ||
675 | }; | ||
676 | |||
677 | static const AVClass avfilter_class = { | ||
678 | .class_name = "AVFilter", | ||
679 | .item_name = default_filter_name, | ||
680 | .version = LIBAVUTIL_VERSION_INT, | ||
681 | .category = AV_CLASS_CATEGORY_FILTER, | ||
682 | .child_next = filter_child_next, | ||
683 | .child_class_iterate = filter_child_class_iterate, | ||
684 | .option = avfilter_options, | ||
685 | .state_flags_offset = offsetof(FFFilterContext, state_flags), | ||
686 | }; | ||
687 | |||
688 | 1277 | static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, | |
689 | int *ret, int nb_jobs) | ||
690 | { | ||
691 | int i; | ||
692 | |||
693 |
2/2✓ Branch 0 taken 1277 times.
✓ Branch 1 taken 1277 times.
|
2554 | for (i = 0; i < nb_jobs; i++) { |
694 | 1277 | int r = func(ctx, arg, i, nb_jobs); | |
695 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1277 times.
|
1277 | if (ret) |
696 | ✗ | ret[i] = r; | |
697 | } | ||
698 | 1277 | return 0; | |
699 | } | ||
700 | |||
701 | 62880 | AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name) | |
702 | { | ||
703 | FFFilterContext *ctx; | ||
704 | AVFilterContext *ret; | ||
705 | 62880 | const FFFilter *const fi = fffilter(filter); | |
706 | 62880 | int preinited = 0; | |
707 | |||
708 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62880 times.
|
62880 | if (!filter) |
709 | ✗ | return NULL; | |
710 | |||
711 | 62880 | ctx = av_mallocz(sizeof(*ctx)); | |
712 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62880 times.
|
62880 | if (!ctx) |
713 | ✗ | return NULL; | |
714 | 62880 | ret = &ctx->p; | |
715 | |||
716 | 62880 | ret->av_class = &avfilter_class; | |
717 | 62880 | ret->filter = filter; | |
718 |
1/2✓ Branch 0 taken 62880 times.
✗ Branch 1 not taken.
|
62880 | ret->name = inst_name ? av_strdup(inst_name) : NULL; |
719 |
2/2✓ Branch 0 taken 56129 times.
✓ Branch 1 taken 6751 times.
|
62880 | if (fi->priv_size) { |
720 | 56129 | ret->priv = av_mallocz(fi->priv_size); | |
721 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 56129 times.
|
56129 | if (!ret->priv) |
722 | ✗ | goto err; | |
723 | } | ||
724 |
2/2✓ Branch 0 taken 13508 times.
✓ Branch 1 taken 49372 times.
|
62880 | if (fi->preinit) { |
725 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 13508 times.
|
13508 | if (fi->preinit(ret) < 0) |
726 | ✗ | goto err; | |
727 | 13508 | preinited = 1; | |
728 | } | ||
729 | |||
730 | 62880 | av_opt_set_defaults(ret); | |
731 |
2/2✓ Branch 0 taken 54872 times.
✓ Branch 1 taken 8008 times.
|
62880 | if (filter->priv_class) { |
732 | 54872 | *(const AVClass**)ret->priv = filter->priv_class; | |
733 | 54872 | av_opt_set_defaults(ret->priv); | |
734 | } | ||
735 | |||
736 | 62880 | ctx->execute = default_execute; | |
737 | |||
738 | 62880 | ret->nb_inputs = fi->nb_inputs; | |
739 |
2/2✓ Branch 0 taken 53333 times.
✓ Branch 1 taken 9547 times.
|
62880 | if (ret->nb_inputs ) { |
740 | 53333 | ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs)); | |
741 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 53333 times.
|
53333 | if (!ret->input_pads) |
742 | ✗ | goto err; | |
743 | 53333 | ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs)); | |
744 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 53333 times.
|
53333 | if (!ret->inputs) |
745 | ✗ | goto err; | |
746 | } | ||
747 | |||
748 | 62880 | ret->nb_outputs = fi->nb_outputs; | |
749 |
2/2✓ Branch 0 taken 54560 times.
✓ Branch 1 taken 8320 times.
|
62880 | if (ret->nb_outputs) { |
750 | 54560 | ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs)); | |
751 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 54560 times.
|
54560 | if (!ret->output_pads) |
752 | ✗ | goto err; | |
753 | 54560 | ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs)); | |
754 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 54560 times.
|
54560 | if (!ret->outputs) |
755 | ✗ | goto err; | |
756 | } | ||
757 | |||
758 | 62880 | return ret; | |
759 | |||
760 | ✗ | err: | |
761 | ✗ | if (preinited) | |
762 | ✗ | fi->uninit(ret); | |
763 | ✗ | av_freep(&ret->inputs); | |
764 | ✗ | av_freep(&ret->input_pads); | |
765 | ✗ | ret->nb_inputs = 0; | |
766 | ✗ | av_freep(&ret->outputs); | |
767 | ✗ | av_freep(&ret->output_pads); | |
768 | ✗ | ret->nb_outputs = 0; | |
769 | ✗ | av_freep(&ret->priv); | |
770 | ✗ | av_free(ret); | |
771 | ✗ | return NULL; | |
772 | } | ||
773 | |||
774 | 108505 | static void free_link(AVFilterLink *link) | |
775 | { | ||
776 |
2/2✓ Branch 0 taken 61724 times.
✓ Branch 1 taken 46781 times.
|
108505 | if (!link) |
777 | 61724 | return; | |
778 | |||
779 |
2/2✓ Branch 0 taken 46649 times.
✓ Branch 1 taken 132 times.
|
46781 | if (link->src) |
780 | 46649 | link->src->outputs[link->srcpad - link->src->output_pads] = NULL; | |
781 |
2/2✓ Branch 0 taken 46649 times.
✓ Branch 1 taken 132 times.
|
46781 | if (link->dst) |
782 | 46649 | link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL; | |
783 | |||
784 | 46781 | ff_formats_unref(&link->incfg.formats); | |
785 | 46781 | ff_formats_unref(&link->outcfg.formats); | |
786 | 46781 | ff_formats_unref(&link->incfg.color_spaces); | |
787 | 46781 | ff_formats_unref(&link->outcfg.color_spaces); | |
788 | 46781 | ff_formats_unref(&link->incfg.color_ranges); | |
789 | 46781 | ff_formats_unref(&link->outcfg.color_ranges); | |
790 | 46781 | ff_formats_unref(&link->incfg.alpha_modes); | |
791 | 46781 | ff_formats_unref(&link->outcfg.alpha_modes); | |
792 | 46781 | ff_formats_unref(&link->incfg.samplerates); | |
793 | 46781 | ff_formats_unref(&link->outcfg.samplerates); | |
794 | 46781 | ff_channel_layouts_unref(&link->incfg.channel_layouts); | |
795 | 46781 | ff_channel_layouts_unref(&link->outcfg.channel_layouts); | |
796 | 46781 | link_free(&link); | |
797 | } | ||
798 | |||
799 | 62880 | void avfilter_free(AVFilterContext *filter) | |
800 | { | ||
801 | FFFilterContext *ctxi; | ||
802 | int i; | ||
803 | |||
804 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62880 times.
|
62880 | if (!filter) |
805 | ✗ | return; | |
806 | 62880 | ctxi = fffilterctx(filter); | |
807 | |||
808 |
1/2✓ Branch 0 taken 62880 times.
✗ Branch 1 not taken.
|
62880 | if (filter->graph) |
809 | 62880 | ff_filter_graph_remove_filter(filter->graph, filter); | |
810 | |||
811 |
2/2✓ Branch 1 taken 48894 times.
✓ Branch 2 taken 13986 times.
|
62880 | if (fffilter(filter->filter)->uninit) |
812 | 48894 | fffilter(filter->filter)->uninit(filter); | |
813 | |||
814 |
2/2✓ Branch 0 taken 53660 times.
✓ Branch 1 taken 62880 times.
|
116540 | for (i = 0; i < filter->nb_inputs; i++) { |
815 | 53660 | free_link(filter->inputs[i]); | |
816 |
2/2✓ Branch 0 taken 216 times.
✓ Branch 1 taken 53444 times.
|
53660 | if (filter->input_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME) |
817 | 216 | av_freep(&filter->input_pads[i].name); | |
818 | } | ||
819 |
2/2✓ Branch 0 taken 54845 times.
✓ Branch 1 taken 62880 times.
|
117725 | for (i = 0; i < filter->nb_outputs; i++) { |
820 | 54845 | free_link(filter->outputs[i]); | |
821 |
2/2✓ Branch 0 taken 280 times.
✓ Branch 1 taken 54565 times.
|
54845 | if (filter->output_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME) |
822 | 280 | av_freep(&filter->output_pads[i].name); | |
823 | } | ||
824 | |||
825 |
2/2✓ Branch 0 taken 54872 times.
✓ Branch 1 taken 8008 times.
|
62880 | if (filter->filter->priv_class) |
826 | 54872 | av_opt_free(filter->priv); | |
827 | |||
828 | 62880 | av_buffer_unref(&filter->hw_device_ctx); | |
829 | |||
830 | 62880 | av_freep(&filter->name); | |
831 | 62880 | av_freep(&filter->input_pads); | |
832 | 62880 | av_freep(&filter->output_pads); | |
833 | 62880 | av_freep(&filter->inputs); | |
834 | 62880 | av_freep(&filter->outputs); | |
835 | 62880 | av_freep(&filter->priv); | |
836 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62880 times.
|
62880 | while (ctxi->command_queue) |
837 | ✗ | command_queue_pop(filter); | |
838 | 62880 | av_opt_free(filter); | |
839 | 62880 | av_expr_free(ctxi->enable); | |
840 | 62880 | ctxi->enable = NULL; | |
841 | 62880 | av_freep(&ctxi->var_values); | |
842 | 62880 | av_free(filter); | |
843 | } | ||
844 | |||
845 | 18871 | int ff_filter_get_nb_threads(AVFilterContext *ctx) | |
846 | { | ||
847 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18871 times.
|
18871 | if (ctx->nb_threads > 0) |
848 | ✗ | return FFMIN(ctx->nb_threads, ctx->graph->nb_threads); | |
849 | 18871 | return ctx->graph->nb_threads; | |
850 | } | ||
851 | |||
852 | 33571 | int ff_filter_opt_parse(void *logctx, const AVClass *priv_class, | |
853 | AVDictionary **options, const char *args) | ||
854 | { | ||
855 | 33571 | const AVOption *o = NULL; | |
856 | int ret; | ||
857 | 33571 | int offset= -1; | |
858 | |||
859 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 33571 times.
|
33571 | if (!args) |
860 | ✗ | return 0; | |
861 | |||
862 |
2/2✓ Branch 0 taken 57698 times.
✓ Branch 1 taken 33571 times.
|
91269 | while (*args) { |
863 | char *parsed_key, *value; | ||
864 | const char *key; | ||
865 | 57698 | const char *shorthand = NULL; | |
866 | 57698 | int additional_flags = 0; | |
867 | |||
868 |
4/4✓ Branch 0 taken 44926 times.
✓ Branch 1 taken 12772 times.
✓ Branch 3 taken 43644 times.
✓ Branch 4 taken 1282 times.
|
57698 | if (priv_class && (o = av_opt_next(&priv_class, o))) { |
869 |
4/4✓ Branch 0 taken 41874 times.
✓ Branch 1 taken 1770 times.
✓ Branch 2 taken 4468 times.
✓ Branch 3 taken 37406 times.
|
43644 | if (o->type == AV_OPT_TYPE_CONST || o->offset == offset) |
870 | 6238 | continue; | |
871 | 37406 | offset = o->offset; | |
872 | 37406 | shorthand = o->name; | |
873 | } | ||
874 | |||
875 | 51460 | ret = av_opt_get_key_value(&args, "=", ":", | |
876 | shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0, | ||
877 | &parsed_key, &value); | ||
878 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 51460 times.
|
51460 | if (ret < 0) { |
879 | ✗ | if (ret == AVERROR(EINVAL)) | |
880 | ✗ | av_log(logctx, AV_LOG_ERROR, "No option name near '%s'\n", args); | |
881 | else | ||
882 | ✗ | av_log(logctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args, | |
883 | ✗ | av_err2str(ret)); | |
884 | ✗ | return ret; | |
885 | } | ||
886 |
2/2✓ Branch 0 taken 26750 times.
✓ Branch 1 taken 24710 times.
|
51460 | if (*args) |
887 | 26750 | args++; | |
888 |
2/2✓ Branch 0 taken 30770 times.
✓ Branch 1 taken 20690 times.
|
51460 | if (parsed_key) { |
889 | 30770 | key = parsed_key; | |
890 | 30770 | additional_flags = AV_DICT_DONT_STRDUP_KEY; | |
891 | 30770 | priv_class = NULL; /* reject all remaining shorthand */ | |
892 | } else { | ||
893 | 20690 | key = shorthand; | |
894 | } | ||
895 | |||
896 | 51460 | av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value); | |
897 | |||
898 | 51460 | av_dict_set(options, key, value, | |
899 | additional_flags | AV_DICT_DONT_STRDUP_VAL | AV_DICT_MULTIKEY); | ||
900 | } | ||
901 | |||
902 | 33571 | return 0; | |
903 | } | ||
904 | |||
905 | ✗ | int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, | |
906 | const char *arg, char *res, int res_len, int flags) | ||
907 | { | ||
908 | const AVOption *o; | ||
909 | |||
910 | ✗ | if (!ctx->filter->priv_class) | |
911 | ✗ | return 0; | |
912 | ✗ | o = av_opt_find2(ctx->priv, cmd, NULL, AV_OPT_FLAG_RUNTIME_PARAM | AV_OPT_FLAG_FILTERING_PARAM, AV_OPT_SEARCH_CHILDREN, NULL); | |
913 | ✗ | if (!o) | |
914 | ✗ | return AVERROR(ENOSYS); | |
915 | ✗ | return av_opt_set(ctx->priv, cmd, arg, 0); | |
916 | } | ||
917 | |||
918 | 62880 | int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options) | |
919 | { | ||
920 | 62880 | FFFilterContext *ctxi = fffilterctx(ctx); | |
921 | 62880 | int ret = 0; | |
922 | |||
923 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62880 times.
|
62880 | if (ctxi->state_flags & AV_CLASS_STATE_INITIALIZED) { |
924 | ✗ | av_log(ctx, AV_LOG_ERROR, "Filter already initialized\n"); | |
925 | ✗ | return AVERROR(EINVAL); | |
926 | } | ||
927 | |||
928 | 62880 | ret = av_opt_set_dict2(ctx, options, AV_OPT_SEARCH_CHILDREN); | |
929 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62880 times.
|
62880 | if (ret < 0) { |
930 | ✗ | av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n"); | |
931 | ✗ | return ret; | |
932 | } | ||
933 | |||
934 |
2/2✓ Branch 0 taken 1230 times.
✓ Branch 1 taken 61650 times.
|
62880 | if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS && |
935 |
2/2✓ Branch 0 taken 147 times.
✓ Branch 1 taken 1083 times.
|
1230 | ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE && |
936 |
1/2✓ Branch 1 taken 147 times.
✗ Branch 2 not taken.
|
147 | fffiltergraph(ctx->graph)->thread_execute) { |
937 | 147 | ctx->thread_type = AVFILTER_THREAD_SLICE; | |
938 | 147 | ctxi->execute = fffiltergraph(ctx->graph)->thread_execute; | |
939 | } else { | ||
940 | 62733 | ctx->thread_type = 0; | |
941 | } | ||
942 | |||
943 |
2/2✓ Branch 1 taken 49629 times.
✓ Branch 2 taken 13251 times.
|
62880 | if (fffilter(ctx->filter)->init) |
944 | 49629 | ret = fffilter(ctx->filter)->init(ctx); | |
945 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62880 times.
|
62880 | if (ret < 0) |
946 | ✗ | return ret; | |
947 | |||
948 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 62874 times.
|
62880 | if (ctx->enable_str) { |
949 | 6 | ret = set_enable_expr(ctxi, ctx->enable_str); | |
950 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (ret < 0) |
951 | ✗ | return ret; | |
952 | } | ||
953 | |||
954 | 62880 | ctxi->state_flags |= AV_CLASS_STATE_INITIALIZED; | |
955 | |||
956 | 62880 | return 0; | |
957 | } | ||
958 | |||
959 | 20506 | int avfilter_init_str(AVFilterContext *filter, const char *args) | |
960 | { | ||
961 | 20506 | AVDictionary *options = NULL; | |
962 | const AVDictionaryEntry *e; | ||
963 | 20506 | int ret = 0; | |
964 | |||
965 |
3/4✓ Branch 0 taken 10250 times.
✓ Branch 1 taken 10256 times.
✓ Branch 2 taken 10250 times.
✗ Branch 3 not taken.
|
20506 | if (args && *args) { |
966 | 10250 | ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args); | |
967 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10250 times.
|
10250 | if (ret < 0) |
968 | ✗ | goto fail; | |
969 | } | ||
970 | |||
971 | 20506 | ret = avfilter_init_dict(filter, &options); | |
972 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20506 times.
|
20506 | if (ret < 0) |
973 | ✗ | goto fail; | |
974 | |||
975 |
1/2✓ Branch 1 taken 20506 times.
✗ Branch 2 not taken.
|
20506 | if ((e = av_dict_iterate(options, NULL))) { |
976 | ✗ | av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key); | |
977 | ✗ | ret = AVERROR_OPTION_NOT_FOUND; | |
978 | ✗ | goto fail; | |
979 | } | ||
980 | |||
981 | 20506 | fail: | |
982 | 20506 | av_dict_free(&options); | |
983 | |||
984 | 20506 | return ret; | |
985 | } | ||
986 | |||
987 | 15069 | const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx) | |
988 | { | ||
989 | 15069 | return pads[pad_idx].name; | |
990 | } | ||
991 | |||
992 | 30428 | enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx) | |
993 | { | ||
994 | 30428 | return pads[pad_idx].type; | |
995 | } | ||
996 | |||
997 | ✗ | AVBufferRef *avfilter_link_get_hw_frames_ctx(AVFilterLink *link) | |
998 | { | ||
999 | ✗ | FilterLink *plink = ff_filter_link(link); | |
1000 | ✗ | if (plink->hw_frames_ctx) | |
1001 | ✗ | return av_buffer_ref(plink->hw_frames_ctx); | |
1002 | |||
1003 | ✗ | return NULL; | |
1004 | } | ||
1005 | |||
1006 | 709234 | static int default_filter_frame(AVFilterLink *link, AVFrame *frame) | |
1007 | { | ||
1008 | 709234 | return ff_filter_frame(link->dst->outputs[0], frame); | |
1009 | } | ||
1010 | |||
1011 | /** | ||
1012 | * Evaluate the timeline expression of the link for the time and properties | ||
1013 | * of the frame. | ||
1014 | * @return >0 if enabled, 0 if disabled | ||
1015 | * @note It does not update link->dst->is_disabled. | ||
1016 | */ | ||
1017 | 2257949 | static int evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame) | |
1018 | { | ||
1019 | 2257949 | FilterLink *l = ff_filter_link(link); | |
1020 | 2257949 | AVFilterContext *dstctx = link->dst; | |
1021 | 2257949 | FFFilterContext *dsti = fffilterctx(dstctx); | |
1022 | 2257949 | int64_t pts = frame->pts; | |
1023 | |||
1024 |
2/2✓ Branch 0 taken 2257751 times.
✓ Branch 1 taken 198 times.
|
2257949 | if (!dstctx->enable_str) |
1025 | 2257751 | return 1; | |
1026 | |||
1027 | 198 | dsti->var_values[VAR_N] = l->frame_count_out; | |
1028 |
1/2✓ Branch 0 taken 198 times.
✗ Branch 1 not taken.
|
198 | dsti->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base); |
1029 | 198 | dsti->var_values[VAR_W] = link->w; | |
1030 | 198 | dsti->var_values[VAR_H] = link->h; | |
1031 | |||
1032 | 198 | return fabs(av_expr_eval(dsti->enable, dsti->var_values, NULL)) >= 0.5; | |
1033 | } | ||
1034 | |||
1035 | 728479 | static int filter_frame_framed(AVFilterLink *link, AVFrame *frame) | |
1036 | { | ||
1037 | 728479 | FilterLink *l = ff_filter_link(link); | |
1038 | int (*filter_frame)(AVFilterLink *, AVFrame *); | ||
1039 | 728479 | AVFilterContext *dstctx = link->dst; | |
1040 | 728479 | AVFilterPad *dst = link->dstpad; | |
1041 | int ret; | ||
1042 | |||
1043 |
2/2✓ Branch 0 taken 709225 times.
✓ Branch 1 taken 19254 times.
|
728479 | if (!(filter_frame = dst->filter_frame)) |
1044 | 709225 | filter_frame = default_filter_frame; | |
1045 | |||
1046 |
2/2✓ Branch 0 taken 2553 times.
✓ Branch 1 taken 725926 times.
|
728479 | if (dst->flags & AVFILTERPAD_FLAG_NEEDS_WRITABLE) { |
1047 | 2553 | ret = ff_inlink_make_frame_writable(link, &frame); | |
1048 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2553 times.
|
2553 | if (ret < 0) |
1049 | ✗ | goto fail; | |
1050 | } | ||
1051 | |||
1052 | 728479 | ff_inlink_process_commands(link, frame); | |
1053 | 728479 | dstctx->is_disabled = !evaluate_timeline_at_frame(link, frame); | |
1054 | |||
1055 |
2/2✓ Branch 0 taken 19 times.
✓ Branch 1 taken 728460 times.
|
728479 | if (dstctx->is_disabled && |
1056 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 10 times.
|
19 | (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC)) |
1057 | 9 | filter_frame = default_filter_frame; | |
1058 | 728479 | ret = filter_frame(link, frame); | |
1059 | 728479 | l->frame_count_out++; | |
1060 | 728479 | return ret; | |
1061 | |||
1062 | ✗ | fail: | |
1063 | ✗ | av_frame_free(&frame); | |
1064 | ✗ | return ret; | |
1065 | } | ||
1066 | |||
1067 | 1534355 | int ff_filter_frame(AVFilterLink *link, AVFrame *frame) | |
1068 | { | ||
1069 | 1534355 | FilterLinkInternal * const li = ff_link_internal(link); | |
1070 | int ret; | ||
1071 | 1534355 | FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); tlog_ref(NULL, frame, 1); | |
1072 | |||
1073 | /* Consistency checks */ | ||
1074 |
2/2✓ Branch 0 taken 572938 times.
✓ Branch 1 taken 961417 times.
|
1534355 | if (link->type == AVMEDIA_TYPE_VIDEO) { |
1075 |
2/2✓ Branch 0 taken 425360 times.
✓ Branch 1 taken 147578 times.
|
572938 | if (strcmp(link->dst->filter->name, "buffersink") && |
1076 |
2/2✓ Branch 0 taken 253519 times.
✓ Branch 1 taken 171841 times.
|
425360 | strcmp(link->dst->filter->name, "format") && |
1077 |
2/2✓ Branch 0 taken 253492 times.
✓ Branch 1 taken 27 times.
|
253519 | strcmp(link->dst->filter->name, "idet") && |
1078 |
2/2✓ Branch 0 taken 162637 times.
✓ Branch 1 taken 90855 times.
|
253492 | strcmp(link->dst->filter->name, "null") && |
1079 |
2/2✓ Branch 0 taken 54635 times.
✓ Branch 1 taken 108002 times.
|
162637 | strcmp(link->dst->filter->name, "scale") && |
1080 |
1/2✓ Branch 0 taken 54635 times.
✗ Branch 1 not taken.
|
54635 | strcmp(link->dst->filter->name, "libplacebo")) { |
1081 | av_assert1(frame->format == link->format); | ||
1082 | av_assert1(frame->width == link->w); | ||
1083 | av_assert1(frame->height == link->h); | ||
1084 | 54635 | if (av_pix_fmt_desc_get(link->format)->flags & AV_PIX_FMT_FLAG_ALPHA) | |
1085 | av_assert1(frame->alpha_mode == link->alpha_mode); | ||
1086 | } | ||
1087 | |||
1088 | 572938 | frame->sample_aspect_ratio = link->sample_aspect_ratio; | |
1089 | } else { | ||
1090 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 961417 times.
|
961417 | if (frame->format != link->format) { |
1091 | ✗ | av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n"); | |
1092 | ✗ | goto error; | |
1093 | } | ||
1094 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 961417 times.
|
961417 | if (av_channel_layout_compare(&frame->ch_layout, &link->ch_layout)) { |
1095 | ✗ | av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n"); | |
1096 | ✗ | goto error; | |
1097 | } | ||
1098 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 961417 times.
|
961417 | if (frame->sample_rate != link->sample_rate) { |
1099 | ✗ | av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n"); | |
1100 | ✗ | goto error; | |
1101 | } | ||
1102 | |||
1103 | 961417 | frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate }, | |
1104 | link->time_base); | ||
1105 | } | ||
1106 | |||
1107 | 1534355 | li->frame_blocked_in = li->frame_wanted_out = 0; | |
1108 | 1534355 | li->l.frame_count_in++; | |
1109 | 1534355 | li->l.sample_count_in += frame->nb_samples; | |
1110 | 1534355 | filter_unblock(link->dst); | |
1111 | 1534355 | ret = ff_framequeue_add(&li->fifo, frame); | |
1112 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1534355 times.
|
1534355 | if (ret < 0) { |
1113 | ✗ | av_frame_free(&frame); | |
1114 | ✗ | return ret; | |
1115 | } | ||
1116 | 1534355 | ff_filter_set_ready(link->dst, 300); | |
1117 | 1534355 | return 0; | |
1118 | |||
1119 | ✗ | error: | |
1120 | ✗ | av_frame_free(&frame); | |
1121 | ✗ | return AVERROR_PATCHWELCOME; | |
1122 | } | ||
1123 | |||
1124 | 2180734 | static int samples_ready(FilterLinkInternal *link, unsigned min) | |
1125 | { | ||
1126 |
2/2✓ Branch 1 taken 728613 times.
✓ Branch 2 taken 1452121 times.
|
2909347 | return ff_framequeue_queued_frames(&link->fifo) && |
1127 |
2/2✓ Branch 1 taken 135 times.
✓ Branch 2 taken 728478 times.
|
728613 | (ff_framequeue_queued_samples(&link->fifo) >= min || |
1128 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 134 times.
|
135 | link->status_in); |
1129 | } | ||
1130 | |||
1131 | 2449 | static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max, | |
1132 | AVFrame **rframe) | ||
1133 | { | ||
1134 | 2449 | FilterLink *l = &li->l; | |
1135 | 2449 | AVFilterLink *link = &l->pub; | |
1136 | AVFrame *frame0, *frame, *buf; | ||
1137 | unsigned nb_samples, nb_frames, i, p; | ||
1138 | int ret; | ||
1139 | |||
1140 | /* Note: this function relies on no format changes and must only be | ||
1141 | called with enough samples. */ | ||
1142 | av_assert1(samples_ready(li, l->min_samples)); | ||
1143 | 2449 | frame0 = frame = ff_framequeue_peek(&li->fifo, 0); | |
1144 |
6/6✓ Branch 0 taken 934 times.
✓ Branch 1 taken 1515 times.
✓ Branch 2 taken 820 times.
✓ Branch 3 taken 114 times.
✓ Branch 4 taken 547 times.
✓ Branch 5 taken 273 times.
|
2449 | if (!li->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) { |
1145 | 547 | *rframe = ff_framequeue_take(&li->fifo); | |
1146 | 547 | return 0; | |
1147 | } | ||
1148 | 1902 | nb_frames = 0; | |
1149 | 1902 | nb_samples = 0; | |
1150 | while (1) { | ||
1151 |
2/2✓ Branch 0 taken 1516 times.
✓ Branch 1 taken 1461 times.
|
2977 | if (nb_samples + frame->nb_samples > max) { |
1152 |
2/2✓ Branch 0 taken 1515 times.
✓ Branch 1 taken 1 times.
|
1516 | if (nb_samples < min) |
1153 | 1515 | nb_samples = max; | |
1154 | 1516 | break; | |
1155 | } | ||
1156 | 1461 | nb_samples += frame->nb_samples; | |
1157 | 1461 | nb_frames++; | |
1158 |
2/2✓ Branch 1 taken 386 times.
✓ Branch 2 taken 1075 times.
|
1461 | if (nb_frames == ff_framequeue_queued_frames(&li->fifo)) |
1159 | 386 | break; | |
1160 | 1075 | frame = ff_framequeue_peek(&li->fifo, nb_frames); | |
1161 | } | ||
1162 | |||
1163 | 1902 | buf = ff_get_audio_buffer(link, nb_samples); | |
1164 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1902 times.
|
1902 | if (!buf) |
1165 | ✗ | return AVERROR(ENOMEM); | |
1166 | 1902 | ret = av_frame_copy_props(buf, frame0); | |
1167 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1902 times.
|
1902 | if (ret < 0) { |
1168 | ✗ | av_frame_free(&buf); | |
1169 | ✗ | return ret; | |
1170 | } | ||
1171 | |||
1172 | 1902 | p = 0; | |
1173 |
2/2✓ Branch 0 taken 1461 times.
✓ Branch 1 taken 1902 times.
|
3363 | for (i = 0; i < nb_frames; i++) { |
1174 | 1461 | frame = ff_framequeue_take(&li->fifo); | |
1175 | 1461 | av_samples_copy(buf->extended_data, frame->extended_data, p, 0, | |
1176 | 1461 | frame->nb_samples, link->ch_layout.nb_channels, link->format); | |
1177 | 1461 | p += frame->nb_samples; | |
1178 | 1461 | av_frame_free(&frame); | |
1179 | } | ||
1180 |
2/2✓ Branch 0 taken 1515 times.
✓ Branch 1 taken 387 times.
|
1902 | if (p < nb_samples) { |
1181 | 1515 | unsigned n = nb_samples - p; | |
1182 | 1515 | frame = ff_framequeue_peek(&li->fifo, 0); | |
1183 | 1515 | av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n, | |
1184 | 1515 | link->ch_layout.nb_channels, link->format); | |
1185 | 1515 | ff_framequeue_skip_samples(&li->fifo, n, link->time_base); | |
1186 | } | ||
1187 | |||
1188 | 1902 | *rframe = buf; | |
1189 | 1902 | return 0; | |
1190 | } | ||
1191 | |||
1192 | 728479 | static int filter_frame_to_filter(AVFilterLink *link) | |
1193 | { | ||
1194 | 728479 | FilterLinkInternal * const li = ff_link_internal(link); | |
1195 | 728479 | AVFrame *frame = NULL; | |
1196 | 728479 | AVFilterContext *dst = link->dst; | |
1197 | int ret; | ||
1198 | |||
1199 | av_assert1(ff_framequeue_queued_frames(&li->fifo)); | ||
1200 | 1456958 | ret = li->l.min_samples ? | |
1201 |
2/2✓ Branch 0 taken 36 times.
✓ Branch 1 taken 728443 times.
|
728479 | ff_inlink_consume_samples(link, li->l.min_samples, li->l.max_samples, &frame) : |
1202 | 728443 | ff_inlink_consume_frame(link, &frame); | |
1203 | av_assert1(ret); | ||
1204 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 728479 times.
|
728479 | if (ret < 0) { |
1205 | av_assert1(!frame); | ||
1206 | ✗ | return ret; | |
1207 | } | ||
1208 | /* The filter will soon have received a new frame, that may allow it to | ||
1209 | produce one or more: unblock its outputs. */ | ||
1210 | 728479 | filter_unblock(dst); | |
1211 | /* AVFilterPad.filter_frame() expect frame_count_out to have the value | ||
1212 | before the frame; filter_frame_framed() will re-increment it. */ | ||
1213 | 728479 | li->l.frame_count_out--; | |
1214 | 728479 | ret = filter_frame_framed(link, frame); | |
1215 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 728479 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
728479 | if (ret < 0 && ret != li->status_out) { |
1216 | ✗ | link_set_out_status(link, ret, AV_NOPTS_VALUE); | |
1217 | } else { | ||
1218 | /* Run once again, to see if several frames were available, or if | ||
1219 | the input status has also changed, or any other reason. */ | ||
1220 | 728479 | ff_filter_set_ready(dst, 300); | |
1221 | } | ||
1222 | 728479 | return ret; | |
1223 | } | ||
1224 | |||
1225 | 5982 | static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in) | |
1226 | { | ||
1227 | 5982 | AVFilterLink *in = &li_in->l.pub; | |
1228 | 5982 | unsigned out = 0, progress = 0; | |
1229 | int ret; | ||
1230 | |||
1231 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5982 times.
|
5982 | av_assert0(!li_in->status_out); |
1232 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5981 times.
|
5982 | if (!filter->nb_outputs) { |
1233 | /* not necessary with the current API and sinks */ | ||
1234 | 1 | return 0; | |
1235 | } | ||
1236 |
2/2✓ Branch 0 taken 5981 times.
✓ Branch 1 taken 5981 times.
|
11962 | while (!li_in->status_out) { |
1237 | 5981 | FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]); | |
1238 | |||
1239 |
1/2✓ Branch 0 taken 5981 times.
✗ Branch 1 not taken.
|
5981 | if (!li_out->status_in) { |
1240 | 5981 | progress++; | |
1241 | 5981 | ret = request_frame_to_filter(filter->outputs[out]); | |
1242 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5981 times.
|
5981 | if (ret < 0) |
1243 | ✗ | return ret; | |
1244 | } | ||
1245 |
1/2✓ Branch 0 taken 5981 times.
✗ Branch 1 not taken.
|
5981 | if (++out == filter->nb_outputs) { |
1246 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5981 times.
|
5981 | if (!progress) { |
1247 | /* Every output already closed: input no longer interesting | ||
1248 | (example: overlay in shortest mode, other input closed). */ | ||
1249 | ✗ | link_set_out_status(in, li_in->status_in, li_in->status_in_pts); | |
1250 | ✗ | return 0; | |
1251 | } | ||
1252 | 5981 | progress = 0; | |
1253 | 5981 | out = 0; | |
1254 | } | ||
1255 | } | ||
1256 | 5981 | ff_filter_set_ready(filter, 200); | |
1257 | 5981 | return 0; | |
1258 | } | ||
1259 | |||
1260 | 2187813 | static int filter_activate_default(AVFilterContext *filter) | |
1261 | { | ||
1262 | unsigned i; | ||
1263 | 2187813 | int nb_eofs = 0; | |
1264 | |||
1265 |
2/2✓ Branch 0 taken 2187758 times.
✓ Branch 1 taken 2187813 times.
|
4375571 | for (i = 0; i < filter->nb_outputs; i++) |
1266 | 2187758 | nb_eofs += ff_outlink_get_status(filter->outputs[i]) == AVERROR_EOF; | |
1267 |
4/4✓ Branch 0 taken 2187758 times.
✓ Branch 1 taken 55 times.
✓ Branch 2 taken 6804 times.
✓ Branch 3 taken 2180954 times.
|
2187813 | if (filter->nb_outputs && nb_eofs == filter->nb_outputs) { |
1268 |
2/2✓ Branch 0 taken 6804 times.
✓ Branch 1 taken 6804 times.
|
13608 | for (int j = 0; j < filter->nb_inputs; j++) |
1269 | 6804 | ff_inlink_set_status(filter->inputs[j], AVERROR_EOF); | |
1270 | 6804 | return 0; | |
1271 | } | ||
1272 | |||
1273 |
2/2✓ Branch 0 taken 2180734 times.
✓ Branch 1 taken 1452530 times.
|
3633264 | for (i = 0; i < filter->nb_inputs; i++) { |
1274 | 2180734 | FilterLinkInternal *li = ff_link_internal(filter->inputs[i]); | |
1275 |
2/2✓ Branch 1 taken 728479 times.
✓ Branch 2 taken 1452255 times.
|
2180734 | if (samples_ready(li, li->l.min_samples)) { |
1276 | 728479 | return filter_frame_to_filter(filter->inputs[i]); | |
1277 | } | ||
1278 | } | ||
1279 |
2/2✓ Branch 0 taken 1452255 times.
✓ Branch 1 taken 1446548 times.
|
2898803 | for (i = 0; i < filter->nb_inputs; i++) { |
1280 | 1452255 | FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]); | |
1281 |
4/4✓ Branch 0 taken 6011 times.
✓ Branch 1 taken 1446244 times.
✓ Branch 2 taken 5982 times.
✓ Branch 3 taken 29 times.
|
1452255 | if (li->status_in && !li->status_out) { |
1282 | av_assert1(!ff_framequeue_queued_frames(&li->fifo)); | ||
1283 | 5982 | return forward_status_change(filter, li); | |
1284 | } | ||
1285 | } | ||
1286 |
2/2✓ Branch 0 taken 1446521 times.
✓ Branch 1 taken 728030 times.
|
2174551 | for (i = 0; i < filter->nb_outputs; i++) { |
1287 | 1446521 | FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]); | |
1288 |
2/2✓ Branch 0 taken 722984 times.
✓ Branch 1 taken 723537 times.
|
1446521 | if (li->frame_wanted_out && |
1289 |
2/2✓ Branch 0 taken 718518 times.
✓ Branch 1 taken 4466 times.
|
722984 | !li->frame_blocked_in) { |
1290 | 718518 | return request_frame_to_filter(filter->outputs[i]); | |
1291 | } | ||
1292 | } | ||
1293 |
2/2✓ Branch 0 taken 728003 times.
✓ Branch 1 taken 723564 times.
|
1451567 | for (i = 0; i < filter->nb_outputs; i++) { |
1294 | 728003 | FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]); | |
1295 |
2/2✓ Branch 0 taken 4466 times.
✓ Branch 1 taken 723537 times.
|
728003 | if (li->frame_wanted_out) |
1296 | 4466 | return request_frame_to_filter(filter->outputs[i]); | |
1297 | } | ||
1298 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 723537 times.
|
723564 | if (!filter->nb_outputs) { |
1299 | 27 | ff_inlink_request_frame(filter->inputs[0]); | |
1300 | 27 | return 0; | |
1301 | } | ||
1302 | 723537 | return FFERROR_NOT_READY; | |
1303 | } | ||
1304 | |||
1305 | /* | ||
1306 | Filter scheduling and activation | ||
1307 | |||
1308 | When a filter is activated, it must: | ||
1309 | - if possible, output a frame; | ||
1310 | - else, if relevant, forward the input status change; | ||
1311 | - else, check outputs for wanted frames and forward the requests. | ||
1312 | |||
1313 | The following AVFilterLink fields are used for activation: | ||
1314 | |||
1315 | - frame_wanted_out: | ||
1316 | |||
1317 | This field indicates if a frame is needed on this input of the | ||
1318 | destination filter. A positive value indicates that a frame is needed | ||
1319 | to process queued frames or internal data or to satisfy the | ||
1320 | application; a zero value indicates that a frame is not especially | ||
1321 | needed but could be processed anyway; a negative value indicates that a | ||
1322 | frame would just be queued. | ||
1323 | |||
1324 | It is set by filters using ff_request_frame() or ff_request_no_frame(), | ||
1325 | when requested by the application through a specific API or when it is | ||
1326 | set on one of the outputs. | ||
1327 | |||
1328 | It is cleared when a frame is sent from the source using | ||
1329 | ff_filter_frame(). | ||
1330 | |||
1331 | It is also cleared when a status change is sent from the source using | ||
1332 | ff_avfilter_link_set_in_status(). | ||
1333 | |||
1334 | - frame_blocked_in: | ||
1335 | |||
1336 | This field means that the source filter can not generate a frame as is. | ||
1337 | Its goal is to avoid repeatedly calling the request_frame() method on | ||
1338 | the same link. | ||
1339 | |||
1340 | It is set by the framework on all outputs of a filter before activating it. | ||
1341 | |||
1342 | It is automatically cleared by ff_filter_frame(). | ||
1343 | |||
1344 | It is also automatically cleared by ff_avfilter_link_set_in_status(). | ||
1345 | |||
1346 | It is also cleared on all outputs (using filter_unblock()) when | ||
1347 | something happens on an input: processing a frame or changing the | ||
1348 | status. | ||
1349 | |||
1350 | - fifo: | ||
1351 | |||
1352 | Contains the frames queued on a filter input. If it contains frames and | ||
1353 | frame_wanted_out is not set, then the filter can be activated. If that | ||
1354 | result in the filter not able to use these frames, the filter must set | ||
1355 | frame_wanted_out to ask for more frames. | ||
1356 | |||
1357 | - status_in and status_in_pts: | ||
1358 | |||
1359 | Status (EOF or error code) of the link and timestamp of the status | ||
1360 | change (in link time base, same as frames) as seen from the input of | ||
1361 | the link. The status change is considered happening after the frames | ||
1362 | queued in fifo. | ||
1363 | |||
1364 | It is set by the source filter using ff_avfilter_link_set_in_status(). | ||
1365 | |||
1366 | - status_out: | ||
1367 | |||
1368 | Status of the link as seen from the output of the link. The status | ||
1369 | change is considered having already happened. | ||
1370 | |||
1371 | It is set by the destination filter using | ||
1372 | link_set_out_status(). | ||
1373 | |||
1374 | Filters are activated according to the ready field, set using the | ||
1375 | ff_filter_set_ready(). Eventually, a priority queue will be used. | ||
1376 | ff_filter_set_ready() is called whenever anything could cause progress to | ||
1377 | be possible. Marking a filter ready when it is not is not a problem, | ||
1378 | except for the small overhead it causes. | ||
1379 | |||
1380 | Conditions that cause a filter to be marked ready are: | ||
1381 | |||
1382 | - frames added on an input link; | ||
1383 | |||
1384 | - changes in the input or output status of an input link; | ||
1385 | |||
1386 | - requests for a frame on an output link; | ||
1387 | |||
1388 | - after any actual processing using the legacy methods (filter_frame(), | ||
1389 | and request_frame() to acknowledge status changes), to run once more | ||
1390 | and check if enough input was present for several frames. | ||
1391 | |||
1392 | Examples of scenarios to consider: | ||
1393 | |||
1394 | - buffersrc: activate if frame_wanted_out to notify the application; | ||
1395 | activate when the application adds a frame to push it immediately. | ||
1396 | |||
1397 | - testsrc: activate only if frame_wanted_out to produce and push a frame. | ||
1398 | |||
1399 | - concat (not at stitch points): can process a frame on any output. | ||
1400 | Activate if frame_wanted_out on output to forward on the corresponding | ||
1401 | input. Activate when a frame is present on input to process it | ||
1402 | immediately. | ||
1403 | |||
1404 | - framesync: needs at least one frame on each input; extra frames on the | ||
1405 | wrong input will accumulate. When a frame is first added on one input, | ||
1406 | set frame_wanted_out<0 on it to avoid getting more (would trigger | ||
1407 | testsrc) and frame_wanted_out>0 on the other to allow processing it. | ||
1408 | |||
1409 | Activation of old filters: | ||
1410 | |||
1411 | In order to activate a filter implementing the legacy filter_frame() and | ||
1412 | request_frame() methods, perform the first possible of the following | ||
1413 | actions: | ||
1414 | |||
1415 | - If an input has frames in fifo and frame_wanted_out == 0, dequeue a | ||
1416 | frame and call filter_frame(). | ||
1417 | |||
1418 | Rationale: filter frames as soon as possible instead of leaving them | ||
1419 | queued; frame_wanted_out < 0 is not possible since the old API does not | ||
1420 | set it nor provides any similar feedback; frame_wanted_out > 0 happens | ||
1421 | when min_samples > 0 and there are not enough samples queued. | ||
1422 | |||
1423 | - If an input has status_in set but not status_out, try to call | ||
1424 | request_frame() on one of the outputs in the hope that it will trigger | ||
1425 | request_frame() on the input with status_in and acknowledge it. This is | ||
1426 | awkward and fragile, filters with several inputs or outputs should be | ||
1427 | updated to direct activation as soon as possible. | ||
1428 | |||
1429 | - If an output has frame_wanted_out > 0 and not frame_blocked_in, call | ||
1430 | request_frame(). | ||
1431 | |||
1432 | Rationale: checking frame_blocked_in is necessary to avoid requesting | ||
1433 | repeatedly on a blocked input if another is not blocked (example: | ||
1434 | [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2). | ||
1435 | |||
1436 | - If an output has frame_wanted_out > 0 call request_frame(). | ||
1437 | |||
1438 | Rationale: even if all inputs are blocked an activate callback should | ||
1439 | request a frame on some if its inputs if a frame is requested on any of | ||
1440 | its output. | ||
1441 | |||
1442 | - Request a frame on the input for sinks. | ||
1443 | |||
1444 | Rationale: sinks using the old api have no way to request a frame on their | ||
1445 | input, so we need to do it for them. | ||
1446 | */ | ||
1447 | |||
1448 | 3814936 | int ff_filter_activate(AVFilterContext *filter) | |
1449 | { | ||
1450 | 3814936 | FFFilterContext *ctxi = fffilterctx(filter); | |
1451 | 3814936 | const FFFilter *const fi = fffilter(filter->filter); | |
1452 | int ret; | ||
1453 | |||
1454 | /* Generic timeline support is not yet implemented but should be easy */ | ||
1455 | av_assert1(!(fi->p.flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC && | ||
1456 | fi->activate)); | ||
1457 | 3814936 | ctxi->ready = 0; | |
1458 |
2/2✓ Branch 0 taken 1627123 times.
✓ Branch 1 taken 2187813 times.
|
3814936 | ret = fi->activate ? fi->activate(filter) : filter_activate_default(filter); |
1459 |
2/2✓ Branch 0 taken 724410 times.
✓ Branch 1 taken 3090526 times.
|
3814936 | if (ret == FFERROR_NOT_READY) |
1460 | 724410 | ret = 0; | |
1461 | 3814936 | return ret; | |
1462 | } | ||
1463 | |||
1464 | 3496382 | int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts) | |
1465 | { | ||
1466 | 3496382 | FilterLinkInternal * const li = ff_link_internal(link); | |
1467 | 3496382 | *rpts = li->l.current_pts; | |
1468 |
2/2✓ Branch 1 taken 2173 times.
✓ Branch 2 taken 3494209 times.
|
3496382 | if (ff_framequeue_queued_frames(&li->fifo)) |
1469 | 2173 | return *rstatus = 0; | |
1470 |
2/2✓ Branch 0 taken 7875 times.
✓ Branch 1 taken 3486334 times.
|
3494209 | if (li->status_out) |
1471 | 7875 | return *rstatus = li->status_out; | |
1472 |
2/2✓ Branch 0 taken 3478495 times.
✓ Branch 1 taken 7839 times.
|
3486334 | if (!li->status_in) |
1473 | 3478495 | return *rstatus = 0; | |
1474 | 7839 | *rstatus = li->status_out = li->status_in; | |
1475 | 7839 | update_link_current_pts(li, li->status_in_pts); | |
1476 | 7839 | *rpts = li->l.current_pts; | |
1477 | 7839 | return 1; | |
1478 | } | ||
1479 | |||
1480 | 1934 | size_t ff_inlink_queued_frames(AVFilterLink *link) | |
1481 | { | ||
1482 | 1934 | FilterLinkInternal * const li = ff_link_internal(link); | |
1483 | 1934 | return ff_framequeue_queued_frames(&li->fifo); | |
1484 | } | ||
1485 | |||
1486 | 5019269 | int ff_inlink_check_available_frame(AVFilterLink *link) | |
1487 | { | ||
1488 | 5019269 | FilterLinkInternal * const li = ff_link_internal(link); | |
1489 | 5019269 | return ff_framequeue_queued_frames(&li->fifo) > 0; | |
1490 | } | ||
1491 | |||
1492 | 2773 | int ff_inlink_queued_samples(AVFilterLink *link) | |
1493 | { | ||
1494 | 2773 | FilterLinkInternal * const li = ff_link_internal(link); | |
1495 | 2773 | return ff_framequeue_queued_samples(&li->fifo); | |
1496 | } | ||
1497 | |||
1498 | 4544 | int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min) | |
1499 | { | ||
1500 | 4544 | FilterLinkInternal * const li = ff_link_internal(link); | |
1501 | 4544 | uint64_t samples = ff_framequeue_queued_samples(&li->fifo); | |
1502 | av_assert1(min); | ||
1503 |
6/6✓ Branch 0 taken 2101 times.
✓ Branch 1 taken 2443 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 2036 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 59 times.
|
4544 | return samples >= min || (li->status_in && samples); |
1504 | } | ||
1505 | |||
1506 | 1531832 | static void consume_update(FilterLinkInternal *li, const AVFrame *frame) | |
1507 | { | ||
1508 | 1531832 | AVFilterLink *const link = &li->l.pub; | |
1509 | 1531832 | update_link_current_pts(li, frame->pts); | |
1510 | 1531832 | ff_inlink_process_commands(link, frame); | |
1511 |
2/2✓ Branch 0 taken 1529470 times.
✓ Branch 1 taken 2362 times.
|
1531832 | if (link == link->dst->inputs[0]) |
1512 | 1529470 | link->dst->is_disabled = !evaluate_timeline_at_frame(link, frame); | |
1513 | 1531832 | li->l.frame_count_out++; | |
1514 | 1531832 | li->l.sample_count_out += frame->nb_samples; | |
1515 | 1531832 | } | |
1516 | |||
1517 | 5017384 | int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe) | |
1518 | { | ||
1519 | 5017384 | FilterLinkInternal * const li = ff_link_internal(link); | |
1520 | AVFrame *frame; | ||
1521 | |||
1522 | 5017384 | *rframe = NULL; | |
1523 |
2/2✓ Branch 1 taken 3487997 times.
✓ Branch 2 taken 1529387 times.
|
5017384 | if (!ff_inlink_check_available_frame(link)) |
1524 | 3487997 | return 0; | |
1525 | |||
1526 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1529383 times.
|
1529387 | if (li->fifo.samples_skipped) { |
1527 | 4 | frame = ff_framequeue_peek(&li->fifo, 0); | |
1528 | 4 | return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe); | |
1529 | } | ||
1530 | |||
1531 | 1529383 | frame = ff_framequeue_take(&li->fifo); | |
1532 | 1529383 | consume_update(li, frame); | |
1533 | 1529383 | *rframe = frame; | |
1534 | 1529383 | return 1; | |
1535 | } | ||
1536 | |||
1537 | 4544 | int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, | |
1538 | AVFrame **rframe) | ||
1539 | { | ||
1540 | 4544 | FilterLinkInternal * const li = ff_link_internal(link); | |
1541 | AVFrame *frame; | ||
1542 | int ret; | ||
1543 | |||
1544 | av_assert1(min); | ||
1545 | 4544 | *rframe = NULL; | |
1546 |
2/2✓ Branch 1 taken 2095 times.
✓ Branch 2 taken 2449 times.
|
4544 | if (!ff_inlink_check_available_samples(link, min)) |
1547 | 2095 | return 0; | |
1548 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 2439 times.
|
2449 | if (li->status_in) |
1549 |
2/2✓ Branch 1 taken 6 times.
✓ Branch 2 taken 4 times.
|
10 | min = FFMIN(min, ff_framequeue_queued_samples(&li->fifo)); |
1550 | 2449 | ret = take_samples(li, min, max, &frame); | |
1551 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2449 times.
|
2449 | if (ret < 0) |
1552 | ✗ | return ret; | |
1553 | 2449 | consume_update(li, frame); | |
1554 | 2449 | *rframe = frame; | |
1555 | 2449 | return 1; | |
1556 | } | ||
1557 | |||
1558 | 210 | AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx) | |
1559 | { | ||
1560 | 210 | FilterLinkInternal * const li = ff_link_internal(link); | |
1561 | 210 | return ff_framequeue_peek(&li->fifo, idx); | |
1562 | } | ||
1563 | |||
1564 | 4751 | int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe) | |
1565 | { | ||
1566 | 4751 | AVFrame *frame = *rframe; | |
1567 | AVFrame *out; | ||
1568 | int ret; | ||
1569 | |||
1570 |
2/2✓ Branch 1 taken 2226 times.
✓ Branch 2 taken 2525 times.
|
4751 | if (av_frame_is_writable(frame)) |
1571 | 2226 | return 0; | |
1572 | 2525 | av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n"); | |
1573 | |||
1574 |
1/3✓ Branch 0 taken 2525 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
|
2525 | switch (link->type) { |
1575 | 2525 | case AVMEDIA_TYPE_VIDEO: | |
1576 | 2525 | out = ff_get_video_buffer(link, link->w, link->h); | |
1577 | 2525 | break; | |
1578 | ✗ | case AVMEDIA_TYPE_AUDIO: | |
1579 | ✗ | out = ff_get_audio_buffer(link, frame->nb_samples); | |
1580 | ✗ | break; | |
1581 | ✗ | default: | |
1582 | ✗ | return AVERROR(EINVAL); | |
1583 | } | ||
1584 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2525 times.
|
2525 | if (!out) |
1585 | ✗ | return AVERROR(ENOMEM); | |
1586 | |||
1587 | 2525 | ret = av_frame_copy_props(out, frame); | |
1588 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2525 times.
|
2525 | if (ret < 0) { |
1589 | ✗ | av_frame_free(&out); | |
1590 | ✗ | return ret; | |
1591 | } | ||
1592 | |||
1593 | 2525 | ret = av_frame_copy(out, frame); | |
1594 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2525 times.
|
2525 | if (ret < 0) { |
1595 | ✗ | av_frame_free(&out); | |
1596 | ✗ | return ret; | |
1597 | } | ||
1598 | |||
1599 | 2525 | av_frame_free(&frame); | |
1600 | 2525 | *rframe = out; | |
1601 | 2525 | return 0; | |
1602 | } | ||
1603 | |||
1604 | 2260311 | int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame) | |
1605 | { | ||
1606 | 2260311 | FFFilterContext *ctxi = fffilterctx(link->dst); | |
1607 | 2260311 | AVFilterCommand *cmd = ctxi->command_queue; | |
1608 | |||
1609 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 2260311 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
2260311 | while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){ |
1610 | ✗ | av_log(link->dst, AV_LOG_DEBUG, | |
1611 | "Processing command time:%f command:%s arg:%s\n", | ||
1612 | cmd->time, cmd->command, cmd->arg); | ||
1613 | ✗ | avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags); | |
1614 | ✗ | command_queue_pop(link->dst); | |
1615 | ✗ | cmd = ctxi->command_queue; | |
1616 | } | ||
1617 | 2260311 | return 0; | |
1618 | } | ||
1619 | |||
1620 | 809190 | void ff_inlink_request_frame(AVFilterLink *link) | |
1621 | { | ||
1622 | 809190 | av_unused FilterLinkInternal *li = ff_link_internal(link); | |
1623 | av_assert1(!li->status_in); | ||
1624 | av_assert1(!li->status_out); | ||
1625 | 809190 | li->frame_wanted_out = 1; | |
1626 | 809190 | ff_filter_set_ready(link->src, 100); | |
1627 | 809190 | } | |
1628 | |||
1629 | 10815 | void ff_inlink_set_status(AVFilterLink *link, int status) | |
1630 | { | ||
1631 | 10815 | FilterLinkInternal * const li = ff_link_internal(link); | |
1632 |
2/2✓ Branch 0 taken 8416 times.
✓ Branch 1 taken 2399 times.
|
10815 | if (li->status_out) |
1633 | 8416 | return; | |
1634 | 2399 | li->frame_wanted_out = 0; | |
1635 | 2399 | li->frame_blocked_in = 0; | |
1636 | 2399 | link_set_out_status(link, status, AV_NOPTS_VALUE); | |
1637 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2399 times.
|
2399 | while (ff_framequeue_queued_frames(&li->fifo)) { |
1638 | ✗ | AVFrame *frame = ff_framequeue_take(&li->fifo); | |
1639 | ✗ | av_frame_free(&frame); | |
1640 | } | ||
1641 |
2/2✓ Branch 0 taken 2396 times.
✓ Branch 1 taken 3 times.
|
2399 | if (!li->status_in) |
1642 | 2396 | li->status_in = status; | |
1643 | } | ||
1644 | |||
1645 | 3353778 | int ff_outlink_get_status(AVFilterLink *link) | |
1646 | { | ||
1647 | 3353778 | FilterLinkInternal * const li = ff_link_internal(link); | |
1648 | 3353778 | return li->status_in; | |
1649 | } | ||
1650 | |||
1651 | 1478 | int ff_inoutlink_check_flow(AVFilterLink *inlink, AVFilterLink *outlink) | |
1652 | { | ||
1653 | 1478 | FilterLinkInternal * const li_in = ff_link_internal(inlink); | |
1654 |
1/2✓ Branch 1 taken 887 times.
✗ Branch 2 not taken.
|
2365 | return ff_outlink_frame_wanted(outlink) || |
1655 |
2/2✓ Branch 0 taken 887 times.
✓ Branch 1 taken 591 times.
|
2365 | ff_inlink_check_available_frame(inlink) || |
1656 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 860 times.
|
887 | li_in->status_out; |
1657 | } | ||
1658 | |||
1659 | |||
1660 | ✗ | const AVClass *avfilter_get_class(void) | |
1661 | { | ||
1662 | ✗ | return &avfilter_class; | |
1663 | } | ||
1664 | |||
1665 | ✗ | int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link, | |
1666 | int default_pool_size) | ||
1667 | { | ||
1668 | ✗ | FilterLink *l = ff_filter_link(link); | |
1669 | AVHWFramesContext *frames; | ||
1670 | |||
1671 | // Must already be set by caller. | ||
1672 | ✗ | av_assert0(l->hw_frames_ctx); | |
1673 | |||
1674 | ✗ | frames = (AVHWFramesContext*)l->hw_frames_ctx->data; | |
1675 | |||
1676 | ✗ | if (frames->initial_pool_size == 0) { | |
1677 | // Dynamic allocation is necessarily supported. | ||
1678 | ✗ | } else if (avctx->extra_hw_frames >= 0) { | |
1679 | ✗ | frames->initial_pool_size += avctx->extra_hw_frames; | |
1680 | } else { | ||
1681 | ✗ | frames->initial_pool_size = default_pool_size; | |
1682 | } | ||
1683 | |||
1684 | ✗ | return 0; | |
1685 | } | ||
1686 | |||
1687 | 440195 | int ff_outlink_frame_wanted(AVFilterLink *link) | |
1688 | { | ||
1689 | 440195 | FilterLinkInternal * const li = ff_link_internal(link); | |
1690 | 440195 | return li->frame_wanted_out; | |
1691 | } | ||
1692 | |||
1693 | 4858 | int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, | |
1694 | void *arg, int *ret, int nb_jobs) | ||
1695 | { | ||
1696 | 4858 | return fffilterctx(ctx)->execute(ctx, func, arg, ret, nb_jobs); | |
1697 | } | ||
1698 |