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