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