matroskadec: Mute "Unknown entry" log messages for CueRelativePosition entries
[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/channel_layout.h"
26 #include "libavutil/common.h"
27 #include "libavutil/eval.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/rational.h"
33 #include "libavutil/samplefmt.h"
34
35 #include "audio.h"
36 #include "avfilter.h"
37 #include "formats.h"
38 #include "internal.h"
39 #include "audio.h"
40
41 static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame);
42
43 void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
44 {
45     av_unused char buf[16];
46     ff_tlog(ctx,
47             "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
48             ref, ref->buf, ref->data[0],
49             ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
50             ref->pts, av_frame_get_pkt_pos(ref));
51
52     if (ref->width) {
53         ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
54                 ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den,
55                 ref->width, ref->height,
56                 !ref->interlaced_frame     ? 'P' :         /* Progressive  */
57                 ref->top_field_first ? 'T' : 'B',    /* Top / Bottom */
58                 ref->key_frame,
59                 av_get_picture_type_char(ref->pict_type));
60     }
61     if (ref->nb_samples) {
62         ff_tlog(ctx, " cl:%"PRId64"d n:%d r:%d",
63                 ref->channel_layout,
64                 ref->nb_samples,
65                 ref->sample_rate);
66     }
67
68     ff_tlog(ctx, "]%s", end ? "\n" : "");
69 }
70
71 unsigned avfilter_version(void)
72 {
73     av_assert0(LIBAVFILTER_VERSION_MICRO >= 100);
74     return LIBAVFILTER_VERSION_INT;
75 }
76
77 const char *avfilter_configuration(void)
78 {
79     return FFMPEG_CONFIGURATION;
80 }
81
82 const char *avfilter_license(void)
83 {
84 #define LICENSE_PREFIX "libavfilter license: "
85     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
86 }
87
88 void ff_command_queue_pop(AVFilterContext *filter)
89 {
90     AVFilterCommand *c= filter->command_queue;
91     av_freep(&c->arg);
92     av_freep(&c->command);
93     filter->command_queue= c->next;
94     av_free(c);
95 }
96
97 void ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
98                    AVFilterPad **pads, AVFilterLink ***links,
99                    AVFilterPad *newpad)
100 {
101     unsigned i;
102
103     idx = FFMIN(idx, *count);
104
105     *pads  = av_realloc(*pads,  sizeof(AVFilterPad)   * (*count + 1));
106     *links = av_realloc(*links, sizeof(AVFilterLink*) * (*count + 1));
107     memmove(*pads  + idx + 1, *pads  + idx, sizeof(AVFilterPad)   * (*count - idx));
108     memmove(*links + idx + 1, *links + idx, sizeof(AVFilterLink*) * (*count - idx));
109     memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
110     (*links)[idx] = NULL;
111
112     (*count)++;
113     for (i = idx + 1; i < *count; i++)
114         if (*links[i])
115             (*(unsigned *)((uint8_t *) *links[i] + padidx_off))++;
116 }
117
118 int avfilter_link(AVFilterContext *src, unsigned srcpad,
119                   AVFilterContext *dst, unsigned dstpad)
120 {
121     AVFilterLink *link;
122
123     if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
124         src->outputs[srcpad]      || dst->inputs[dstpad])
125         return -1;
126
127     if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
128         av_log(src, AV_LOG_ERROR,
129                "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
130                src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
131                dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
132         return AVERROR(EINVAL);
133     }
134
135     link = av_mallocz(sizeof(*link));
136     if (!link)
137         return AVERROR(ENOMEM);
138
139     src->outputs[srcpad] = dst->inputs[dstpad] = link;
140
141     link->src     = src;
142     link->dst     = dst;
143     link->srcpad  = &src->output_pads[srcpad];
144     link->dstpad  = &dst->input_pads[dstpad];
145     link->type    = src->output_pads[srcpad].type;
146     av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
147     link->format  = -1;
148
149     return 0;
150 }
151
152 void avfilter_link_free(AVFilterLink **link)
153 {
154     if (!*link)
155         return;
156
157     av_frame_free(&(*link)->partial_buf);
158
159     av_freep(link);
160 }
161
162 int avfilter_link_get_channels(AVFilterLink *link)
163 {
164     return link->channels;
165 }
166
167 void avfilter_link_set_closed(AVFilterLink *link, int closed)
168 {
169     link->closed = closed;
170 }
171
172 int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
173                            unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
174 {
175     int ret;
176     unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
177
178     av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
179            "between the filter '%s' and the filter '%s'\n",
180            filt->name, link->src->name, link->dst->name);
181
182     link->dst->inputs[dstpad_idx] = NULL;
183     if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
184         /* failed to link output filter to new filter */
185         link->dst->inputs[dstpad_idx] = link;
186         return ret;
187     }
188
189     /* re-hookup the link to the new destination filter we inserted */
190     link->dst                     = filt;
191     link->dstpad                  = &filt->input_pads[filt_srcpad_idx];
192     filt->inputs[filt_srcpad_idx] = link;
193
194     /* if any information on supported media formats already exists on the
195      * link, we need to preserve that */
196     if (link->out_formats)
197         ff_formats_changeref(&link->out_formats,
198                              &filt->outputs[filt_dstpad_idx]->out_formats);
199     if (link->out_samplerates)
200         ff_formats_changeref(&link->out_samplerates,
201                              &filt->outputs[filt_dstpad_idx]->out_samplerates);
202     if (link->out_channel_layouts)
203         ff_channel_layouts_changeref(&link->out_channel_layouts,
204                                      &filt->outputs[filt_dstpad_idx]->out_channel_layouts);
205
206     return 0;
207 }
208
209 int avfilter_config_links(AVFilterContext *filter)
210 {
211     int (*config_link)(AVFilterLink *);
212     unsigned i;
213     int ret;
214
215     for (i = 0; i < filter->nb_inputs; i ++) {
216         AVFilterLink *link = filter->inputs[i];
217         AVFilterLink *inlink;
218
219         if (!link) continue;
220
221         inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
222         link->current_pts = AV_NOPTS_VALUE;
223
224         switch (link->init_state) {
225         case AVLINK_INIT:
226             continue;
227         case AVLINK_STARTINIT:
228             av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
229             return 0;
230         case AVLINK_UNINIT:
231             link->init_state = AVLINK_STARTINIT;
232
233             if ((ret = avfilter_config_links(link->src)) < 0)
234                 return ret;
235
236             if (!(config_link = link->srcpad->config_props)) {
237                 if (link->src->nb_inputs != 1) {
238                     av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
239                                                     "with more than one input "
240                                                     "must set config_props() "
241                                                     "callbacks on all outputs\n");
242                     return AVERROR(EINVAL);
243                 }
244             } else if ((ret = config_link(link)) < 0) {
245                 av_log(link->src, AV_LOG_ERROR,
246                        "Failed to configure output pad on %s\n",
247                        link->src->name);
248                 return ret;
249             }
250
251             switch (link->type) {
252             case AVMEDIA_TYPE_VIDEO:
253                 if (!link->time_base.num && !link->time_base.den)
254                     link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
255
256                 if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
257                     link->sample_aspect_ratio = inlink ?
258                         inlink->sample_aspect_ratio : (AVRational){1,1};
259
260                 if (inlink && !link->frame_rate.num && !link->frame_rate.den)
261                     link->frame_rate = inlink->frame_rate;
262
263                 if (inlink) {
264                     if (!link->w)
265                         link->w = inlink->w;
266                     if (!link->h)
267                         link->h = inlink->h;
268                 } else if (!link->w || !link->h) {
269                     av_log(link->src, AV_LOG_ERROR,
270                            "Video source filters must set their output link's "
271                            "width and height\n");
272                     return AVERROR(EINVAL);
273                 }
274                 break;
275
276             case AVMEDIA_TYPE_AUDIO:
277                 if (inlink) {
278                     if (!link->time_base.num && !link->time_base.den)
279                         link->time_base = inlink->time_base;
280                 }
281
282                 if (!link->time_base.num && !link->time_base.den)
283                     link->time_base = (AVRational) {1, link->sample_rate};
284             }
285
286             if ((config_link = link->dstpad->config_props))
287                 if ((ret = config_link(link)) < 0) {
288                     av_log(link->src, AV_LOG_ERROR,
289                            "Failed to configure input pad on %s\n",
290                            link->dst->name);
291                     return ret;
292                 }
293
294             link->init_state = AVLINK_INIT;
295         }
296     }
297
298     return 0;
299 }
300
301 void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
302 {
303     if (link->type == AVMEDIA_TYPE_VIDEO) {
304         ff_tlog(ctx,
305                 "link[%p s:%dx%d fmt:%s %s->%s]%s",
306                 link, link->w, link->h,
307                 av_get_pix_fmt_name(link->format),
308                 link->src ? link->src->filter->name : "",
309                 link->dst ? link->dst->filter->name : "",
310                 end ? "\n" : "");
311     } else {
312         char buf[128];
313         av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
314
315         ff_tlog(ctx,
316                 "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
317                 link, (int)link->sample_rate, buf,
318                 av_get_sample_fmt_name(link->format),
319                 link->src ? link->src->filter->name : "",
320                 link->dst ? link->dst->filter->name : "",
321                 end ? "\n" : "");
322     }
323 }
324
325 int ff_request_frame(AVFilterLink *link)
326 {
327     int ret = -1;
328     FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
329
330     if (link->closed)
331         return AVERROR_EOF;
332     av_assert0(!link->frame_requested);
333     link->frame_requested = 1;
334     while (link->frame_requested) {
335         if (link->srcpad->request_frame)
336             ret = link->srcpad->request_frame(link);
337         else if (link->src->inputs[0])
338             ret = ff_request_frame(link->src->inputs[0]);
339         if (ret == AVERROR_EOF && link->partial_buf) {
340             AVFrame *pbuf = link->partial_buf;
341             link->partial_buf = NULL;
342             ret = ff_filter_frame_framed(link, pbuf);
343         }
344         if (ret < 0) {
345             link->frame_requested = 0;
346             if (ret == AVERROR_EOF)
347                 link->closed = 1;
348         } else {
349             av_assert0(!link->frame_requested ||
350                        link->flags & FF_LINK_FLAG_REQUEST_LOOP);
351         }
352     }
353     return ret;
354 }
355
356 int ff_poll_frame(AVFilterLink *link)
357 {
358     int i, min = INT_MAX;
359
360     if (link->srcpad->poll_frame)
361         return link->srcpad->poll_frame(link);
362
363     for (i = 0; i < link->src->nb_inputs; i++) {
364         int val;
365         if (!link->src->inputs[i])
366             return -1;
367         val = ff_poll_frame(link->src->inputs[i]);
368         min = FFMIN(min, val);
369     }
370
371     return min;
372 }
373
374 static const char *const var_names[] = {   "t",   "n",   "pos",        NULL };
375 enum                                   { VAR_T, VAR_N, VAR_POS, VAR_VARS_NB };
376
377 static int set_enable_expr(AVFilterContext *ctx, const char *expr)
378 {
379     int ret;
380     char *expr_dup;
381     AVExpr *old = ctx->enable;
382
383     if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
384         av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
385                "with filter '%s'\n", ctx->filter->name);
386         return AVERROR_PATCHWELCOME;
387     }
388
389     expr_dup = av_strdup(expr);
390     if (!expr_dup)
391         return AVERROR(ENOMEM);
392
393     if (!ctx->var_values) {
394         ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
395         if (!ctx->var_values) {
396             av_free(expr_dup);
397             return AVERROR(ENOMEM);
398         }
399     }
400
401     ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
402                         NULL, NULL, NULL, NULL, 0, ctx->priv);
403     if (ret < 0) {
404         av_log(ctx->priv, AV_LOG_ERROR,
405                "Error when evaluating the expression '%s' for enable\n",
406                expr_dup);
407         av_free(expr_dup);
408         return ret;
409     }
410
411     av_expr_free(old);
412     av_free(ctx->enable_str);
413     ctx->enable_str = expr_dup;
414     return 0;
415 }
416
417 void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
418 {
419     if (pts == AV_NOPTS_VALUE)
420         return;
421     link->current_pts = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
422     /* TODO use duration */
423     if (link->graph && link->age_index >= 0)
424         ff_avfilter_graph_update_heap(link->graph, link);
425 }
426
427 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
428 {
429     if(!strcmp(cmd, "ping")){
430         char local_res[256] = {0};
431
432         if (!res) {
433             res = local_res;
434             res_len = sizeof(local_res);
435         }
436         av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
437         if (res == local_res)
438             av_log(filter, AV_LOG_INFO, "%s", res);
439         return 0;
440     }else if(!strcmp(cmd, "enable")) {
441         return set_enable_expr(filter, arg);
442     }else if(filter->filter->process_command) {
443         return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
444     }
445     return AVERROR(ENOSYS);
446 }
447
448 static AVFilter *first_filter;
449
450 AVFilter *avfilter_get_by_name(const char *name)
451 {
452     const AVFilter *f = NULL;
453
454     if (!name)
455         return NULL;
456
457     while ((f = avfilter_next(f)))
458         if (!strcmp(f->name, name))
459             return (AVFilter *)f;
460
461     return NULL;
462 }
463
464 int avfilter_register(AVFilter *filter)
465 {
466     AVFilter **f = &first_filter;
467     int i;
468
469     /* the filter must select generic or internal exclusively */
470     av_assert0((filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE) != AVFILTER_FLAG_SUPPORT_TIMELINE);
471
472     for(i=0; filter->inputs && filter->inputs[i].name; i++) {
473         const AVFilterPad *input = &filter->inputs[i];
474         av_assert0(     !input->filter_frame
475                     || (!input->start_frame && !input->end_frame));
476     }
477
478     filter->next = NULL;
479
480     while(avpriv_atomic_ptr_cas((void * volatile *)f, NULL, filter))
481         f = &(*f)->next;
482
483     return 0;
484 }
485
486 const AVFilter *avfilter_next(const AVFilter *prev)
487 {
488     return prev ? prev->next : first_filter;
489 }
490
491 #if FF_API_OLD_FILTER_REGISTER
492 AVFilter **av_filter_next(AVFilter **filter)
493 {
494     return filter ? &(*filter)->next : &first_filter;
495 }
496
497 void avfilter_uninit(void)
498 {
499 }
500 #endif
501
502 int avfilter_pad_count(const AVFilterPad *pads)
503 {
504     int count;
505
506     if (!pads)
507         return 0;
508
509     for (count = 0; pads->name; count++)
510         pads++;
511     return count;
512 }
513
514 static const char *default_filter_name(void *filter_ctx)
515 {
516     AVFilterContext *ctx = filter_ctx;
517     return ctx->name ? ctx->name : ctx->filter->name;
518 }
519
520 static void *filter_child_next(void *obj, void *prev)
521 {
522     AVFilterContext *ctx = obj;
523     if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
524         return ctx->priv;
525     return NULL;
526 }
527
528 static const AVClass *filter_child_class_next(const AVClass *prev)
529 {
530     const AVFilter *f = NULL;
531
532     /* find the filter that corresponds to prev */
533     while (prev && (f = avfilter_next(f)))
534         if (f->priv_class == prev)
535             break;
536
537     /* could not find filter corresponding to prev */
538     if (prev && !f)
539         return NULL;
540
541     /* find next filter with specific options */
542     while ((f = avfilter_next(f)))
543         if (f->priv_class)
544             return f->priv_class;
545
546     return NULL;
547 }
548
549 #define OFFSET(x) offsetof(AVFilterContext, x)
550 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
551 static const AVOption avfilter_options[] = {
552     { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
553         { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
554         { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" },
555     { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
556     { NULL },
557 };
558
559 static const AVClass avfilter_class = {
560     .class_name = "AVFilter",
561     .item_name  = default_filter_name,
562     .version    = LIBAVUTIL_VERSION_INT,
563     .category   = AV_CLASS_CATEGORY_FILTER,
564     .child_next = filter_child_next,
565     .child_class_next = filter_child_class_next,
566     .option           = avfilter_options,
567 };
568
569 static int default_execute(AVFilterContext *ctx, action_func *func, void *arg,
570                            int *ret, int nb_jobs)
571 {
572     int i;
573
574     for (i = 0; i < nb_jobs; i++) {
575         int r = func(ctx, arg, i, nb_jobs);
576         if (ret)
577             ret[i] = r;
578     }
579     return 0;
580 }
581
582 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
583 {
584     AVFilterContext *ret;
585
586     if (!filter)
587         return NULL;
588
589     ret = av_mallocz(sizeof(AVFilterContext));
590     if (!ret)
591         return NULL;
592
593     ret->av_class = &avfilter_class;
594     ret->filter   = filter;
595     ret->name     = inst_name ? av_strdup(inst_name) : NULL;
596     if (filter->priv_size) {
597         ret->priv     = av_mallocz(filter->priv_size);
598         if (!ret->priv)
599             goto err;
600     }
601
602     av_opt_set_defaults(ret);
603     if (filter->priv_class) {
604         *(const AVClass**)ret->priv = filter->priv_class;
605         av_opt_set_defaults(ret->priv);
606     }
607
608     ret->internal = av_mallocz(sizeof(*ret->internal));
609     if (!ret->internal)
610         goto err;
611     ret->internal->execute = default_execute;
612
613     ret->nb_inputs = avfilter_pad_count(filter->inputs);
614     if (ret->nb_inputs ) {
615         ret->input_pads   = av_malloc(sizeof(AVFilterPad) * ret->nb_inputs);
616         if (!ret->input_pads)
617             goto err;
618         memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
619         ret->inputs       = av_mallocz(sizeof(AVFilterLink*) * ret->nb_inputs);
620         if (!ret->inputs)
621             goto err;
622     }
623
624     ret->nb_outputs = avfilter_pad_count(filter->outputs);
625     if (ret->nb_outputs) {
626         ret->output_pads  = av_malloc(sizeof(AVFilterPad) * ret->nb_outputs);
627         if (!ret->output_pads)
628             goto err;
629         memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
630         ret->outputs      = av_mallocz(sizeof(AVFilterLink*) * ret->nb_outputs);
631         if (!ret->outputs)
632             goto err;
633     }
634 #if FF_API_FOO_COUNT
635 FF_DISABLE_DEPRECATION_WARNINGS
636     ret->output_count = ret->nb_outputs;
637     ret->input_count  = ret->nb_inputs;
638 FF_ENABLE_DEPRECATION_WARNINGS
639 #endif
640
641     return ret;
642
643 err:
644     av_freep(&ret->inputs);
645     av_freep(&ret->input_pads);
646     ret->nb_inputs = 0;
647     av_freep(&ret->outputs);
648     av_freep(&ret->output_pads);
649     ret->nb_outputs = 0;
650     av_freep(&ret->priv);
651     av_freep(&ret->internal);
652     av_free(ret);
653     return NULL;
654 }
655
656 #if FF_API_AVFILTER_OPEN
657 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
658 {
659     *filter_ctx = ff_filter_alloc(filter, inst_name);
660     return *filter_ctx ? 0 : AVERROR(ENOMEM);
661 }
662 #endif
663
664 static void free_link(AVFilterLink *link)
665 {
666     if (!link)
667         return;
668
669     if (link->src)
670         link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
671     if (link->dst)
672         link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
673
674     ff_formats_unref(&link->in_formats);
675     ff_formats_unref(&link->out_formats);
676     ff_formats_unref(&link->in_samplerates);
677     ff_formats_unref(&link->out_samplerates);
678     ff_channel_layouts_unref(&link->in_channel_layouts);
679     ff_channel_layouts_unref(&link->out_channel_layouts);
680     avfilter_link_free(&link);
681 }
682
683 void avfilter_free(AVFilterContext *filter)
684 {
685     int i;
686
687     if (!filter)
688         return;
689
690     if (filter->graph)
691         ff_filter_graph_remove_filter(filter->graph, filter);
692
693     if (filter->filter->uninit)
694         filter->filter->uninit(filter);
695
696     for (i = 0; i < filter->nb_inputs; i++) {
697         free_link(filter->inputs[i]);
698     }
699     for (i = 0; i < filter->nb_outputs; i++) {
700         free_link(filter->outputs[i]);
701     }
702
703     if (filter->filter->priv_class)
704         av_opt_free(filter->priv);
705
706     av_freep(&filter->name);
707     av_freep(&filter->input_pads);
708     av_freep(&filter->output_pads);
709     av_freep(&filter->inputs);
710     av_freep(&filter->outputs);
711     av_freep(&filter->priv);
712     while(filter->command_queue){
713         ff_command_queue_pop(filter);
714     }
715     av_opt_free(filter);
716     av_expr_free(filter->enable);
717     filter->enable = NULL;
718     av_freep(&filter->var_values);
719     av_freep(&filter->internal);
720     av_free(filter);
721 }
722
723 static int process_options(AVFilterContext *ctx, AVDictionary **options,
724                            const char *args)
725 {
726     const AVOption *o = NULL;
727     int ret, count = 0;
728     char *av_uninit(parsed_key), *av_uninit(value);
729     const char *key;
730     int offset= -1;
731
732     if (!args)
733         return 0;
734
735     while (*args) {
736         const char *shorthand = NULL;
737
738         o = av_opt_next(ctx->priv, o);
739         if (o) {
740             if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
741                 continue;
742             offset = o->offset;
743             shorthand = o->name;
744         }
745
746         ret = av_opt_get_key_value(&args, "=", ":",
747                                    shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
748                                    &parsed_key, &value);
749         if (ret < 0) {
750             if (ret == AVERROR(EINVAL))
751                 av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
752             else
753                 av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
754                        av_err2str(ret));
755             return ret;
756         }
757         if (*args)
758             args++;
759         if (parsed_key) {
760             key = parsed_key;
761             while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
762         } else {
763             key = shorthand;
764         }
765
766         av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
767
768         if (av_opt_find(ctx, key, NULL, 0, 0)) {
769             ret = av_opt_set(ctx, key, value, 0);
770             if (ret < 0) {
771                 av_free(value);
772                 av_free(parsed_key);
773                 return ret;
774             }
775         } else {
776         av_dict_set(options, key, value, 0);
777         if ((ret = av_opt_set(ctx->priv, key, value, 0)) < 0) {
778             if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {
779             if (ret == AVERROR_OPTION_NOT_FOUND)
780                 av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
781             av_free(value);
782             av_free(parsed_key);
783             return ret;
784             }
785         }
786         }
787
788         av_free(value);
789         av_free(parsed_key);
790         count++;
791     }
792
793     if (ctx->enable_str) {
794         ret = set_enable_expr(ctx, ctx->enable_str);
795         if (ret < 0)
796             return ret;
797     }
798     return count;
799 }
800
801 #if FF_API_AVFILTER_INIT_FILTER
802 int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque)
803 {
804     return avfilter_init_str(filter, args);
805 }
806 #endif
807
808 int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
809 {
810     int ret = 0;
811
812     ret = av_opt_set_dict(ctx, options);
813     if (ret < 0) {
814         av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
815         return ret;
816     }
817
818     if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
819         ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
820         ctx->graph->internal->thread_execute) {
821         ctx->thread_type       = AVFILTER_THREAD_SLICE;
822         ctx->internal->execute = ctx->graph->internal->thread_execute;
823     } else {
824         ctx->thread_type = 0;
825     }
826
827     if (ctx->filter->priv_class) {
828         ret = av_opt_set_dict(ctx->priv, options);
829         if (ret < 0) {
830             av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
831             return ret;
832         }
833     }
834
835     if (ctx->filter->init_opaque)
836         ret = ctx->filter->init_opaque(ctx, NULL);
837     else if (ctx->filter->init)
838         ret = ctx->filter->init(ctx);
839     else if (ctx->filter->init_dict)
840         ret = ctx->filter->init_dict(ctx, options);
841
842     return ret;
843 }
844
845 int avfilter_init_str(AVFilterContext *filter, const char *args)
846 {
847     AVDictionary *options = NULL;
848     AVDictionaryEntry *e;
849     int ret = 0;
850
851     if (args && *args) {
852         if (!filter->filter->priv_class) {
853             av_log(filter, AV_LOG_ERROR, "This filter does not take any "
854                    "options, but options were provided: %s.\n", args);
855             return AVERROR(EINVAL);
856         }
857
858 #if FF_API_OLD_FILTER_OPTS
859             if (   !strcmp(filter->filter->name, "format")     ||
860                    !strcmp(filter->filter->name, "noformat")   ||
861                    !strcmp(filter->filter->name, "frei0r")     ||
862                    !strcmp(filter->filter->name, "frei0r_src") ||
863                    !strcmp(filter->filter->name, "ocv")        ||
864                    !strcmp(filter->filter->name, "pan")        ||
865                    !strcmp(filter->filter->name, "pp")         ||
866                    !strcmp(filter->filter->name, "aevalsrc")) {
867             /* a hack for compatibility with the old syntax
868              * replace colons with |s */
869             char *copy = av_strdup(args);
870             char *p    = copy;
871             int nb_leading = 0; // number of leading colons to skip
872             int deprecated = 0;
873
874             if (!copy) {
875                 ret = AVERROR(ENOMEM);
876                 goto fail;
877             }
878
879             if (!strcmp(filter->filter->name, "frei0r") ||
880                 !strcmp(filter->filter->name, "ocv"))
881                 nb_leading = 1;
882             else if (!strcmp(filter->filter->name, "frei0r_src"))
883                 nb_leading = 3;
884
885             while (nb_leading--) {
886                 p = strchr(p, ':');
887                 if (!p) {
888                     p = copy + strlen(copy);
889                     break;
890                 }
891                 p++;
892             }
893
894             deprecated = strchr(p, ':') != NULL;
895
896             if (!strcmp(filter->filter->name, "aevalsrc")) {
897                 deprecated = 0;
898                 while ((p = strchr(p, ':')) && p[1] != ':') {
899                     const char *epos = strchr(p + 1, '=');
900                     const char *spos = strchr(p + 1, ':');
901                     const int next_token_is_opt = epos && (!spos || epos < spos);
902                     if (next_token_is_opt) {
903                         p++;
904                         break;
905                     }
906                     /* next token does not contain a '=', assume a channel expression */
907                     deprecated = 1;
908                     *p++ = '|';
909                 }
910                 if (p && *p == ':') { // double sep '::' found
911                     deprecated = 1;
912                     memmove(p, p + 1, strlen(p));
913                 }
914             } else
915             while ((p = strchr(p, ':')))
916                 *p++ = '|';
917
918             if (deprecated)
919                 av_log(filter, AV_LOG_WARNING, "This syntax is deprecated. Use "
920                        "'|' to separate the list items.\n");
921
922             av_log(filter, AV_LOG_DEBUG, "compat: called with args=[%s]\n", copy);
923             ret = process_options(filter, &options, copy);
924             av_freep(&copy);
925
926             if (ret < 0)
927                 goto fail;
928 #endif
929         } else {
930 #if CONFIG_MP_FILTER
931             if (!strcmp(filter->filter->name, "mp")) {
932                 char *escaped;
933
934                 if (!strncmp(args, "filter=", 7))
935                     args += 7;
936                 ret = av_escape(&escaped, args, ":=", AV_ESCAPE_MODE_BACKSLASH, 0);
937                 if (ret < 0) {
938                     av_log(filter, AV_LOG_ERROR, "Unable to escape MPlayer filters arg '%s'\n", args);
939                     goto fail;
940                 }
941                 ret = process_options(filter, &options, escaped);
942                 av_free(escaped);
943             } else
944 #endif
945             ret = process_options(filter, &options, args);
946             if (ret < 0)
947                 goto fail;
948         }
949     }
950
951     ret = avfilter_init_dict(filter, &options);
952     if (ret < 0)
953         goto fail;
954
955     if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
956         av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
957         ret = AVERROR_OPTION_NOT_FOUND;
958         goto fail;
959     }
960
961 fail:
962     av_dict_free(&options);
963
964     return ret;
965 }
966
967 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
968 {
969     return pads[pad_idx].name;
970 }
971
972 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
973 {
974     return pads[pad_idx].type;
975 }
976
977 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
978 {
979     return ff_filter_frame(link->dst->outputs[0], frame);
980 }
981
982 static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
983 {
984     int (*filter_frame)(AVFilterLink *, AVFrame *);
985     AVFilterContext *dstctx = link->dst;
986     AVFilterPad *dst = link->dstpad;
987     AVFrame *out;
988     int ret;
989     AVFilterCommand *cmd= link->dst->command_queue;
990     int64_t pts;
991
992     if (link->closed) {
993         av_frame_free(&frame);
994         return AVERROR_EOF;
995     }
996
997     if (!(filter_frame = dst->filter_frame))
998         filter_frame = default_filter_frame;
999
1000     /* copy the frame if needed */
1001     if (dst->needs_writable && !av_frame_is_writable(frame)) {
1002         av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1003
1004         /* Maybe use ff_copy_buffer_ref instead? */
1005         switch (link->type) {
1006         case AVMEDIA_TYPE_VIDEO:
1007             out = ff_get_video_buffer(link, link->w, link->h);
1008             break;
1009         case AVMEDIA_TYPE_AUDIO:
1010             out = ff_get_audio_buffer(link, frame->nb_samples);
1011             break;
1012         default: return AVERROR(EINVAL);
1013         }
1014         if (!out) {
1015             av_frame_free(&frame);
1016             return AVERROR(ENOMEM);
1017         }
1018         av_frame_copy_props(out, frame);
1019
1020         switch (link->type) {
1021         case AVMEDIA_TYPE_VIDEO:
1022             av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1023                           frame->format, frame->width, frame->height);
1024             break;
1025         case AVMEDIA_TYPE_AUDIO:
1026             av_samples_copy(out->extended_data, frame->extended_data,
1027                             0, 0, frame->nb_samples,
1028                             av_get_channel_layout_nb_channels(frame->channel_layout),
1029                             frame->format);
1030             break;
1031         default: return AVERROR(EINVAL);
1032         }
1033
1034         av_frame_free(&frame);
1035     } else
1036         out = frame;
1037
1038     while(cmd && cmd->time <= out->pts * av_q2d(link->time_base)){
1039         av_log(link->dst, AV_LOG_DEBUG,
1040                "Processing command time:%f command:%s arg:%s\n",
1041                cmd->time, cmd->command, cmd->arg);
1042         avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1043         ff_command_queue_pop(link->dst);
1044         cmd= link->dst->command_queue;
1045     }
1046
1047     pts = out->pts;
1048     if (dstctx->enable_str) {
1049         int64_t pos = av_frame_get_pkt_pos(out);
1050         dstctx->var_values[VAR_N] = link->frame_count;
1051         dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1052         dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1053
1054         dstctx->is_disabled = !av_expr_eval(dstctx->enable, dstctx->var_values, NULL);
1055         if (dstctx->is_disabled &&
1056             (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
1057             filter_frame = default_filter_frame;
1058     }
1059     ret = filter_frame(link, out);
1060     link->frame_count++;
1061     link->frame_requested = 0;
1062     ff_update_link_current_pts(link, pts);
1063     return ret;
1064 }
1065
1066 static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFrame *frame)
1067 {
1068     int insamples = frame->nb_samples, inpos = 0, nb_samples;
1069     AVFrame *pbuf = link->partial_buf;
1070     int nb_channels = av_frame_get_channels(frame);
1071     int ret = 0;
1072
1073     link->flags |= FF_LINK_FLAG_REQUEST_LOOP;
1074     /* Handle framing (min_samples, max_samples) */
1075     while (insamples) {
1076         if (!pbuf) {
1077             AVRational samples_tb = { 1, link->sample_rate };
1078             pbuf = ff_get_audio_buffer(link, link->partial_buf_size);
1079             if (!pbuf) {
1080                 av_log(link->dst, AV_LOG_WARNING,
1081                        "Samples dropped due to memory allocation failure.\n");
1082                 return 0;
1083             }
1084             av_frame_copy_props(pbuf, frame);
1085             pbuf->pts = frame->pts +
1086                         av_rescale_q(inpos, samples_tb, link->time_base);
1087             pbuf->nb_samples = 0;
1088         }
1089         nb_samples = FFMIN(insamples,
1090                            link->partial_buf_size - pbuf->nb_samples);
1091         av_samples_copy(pbuf->extended_data, frame->extended_data,
1092                         pbuf->nb_samples, inpos,
1093                         nb_samples, nb_channels, link->format);
1094         inpos                   += nb_samples;
1095         insamples               -= nb_samples;
1096         pbuf->nb_samples += nb_samples;
1097         if (pbuf->nb_samples >= link->min_samples) {
1098             ret = ff_filter_frame_framed(link, pbuf);
1099             pbuf = NULL;
1100         }
1101     }
1102     av_frame_free(&frame);
1103     link->partial_buf = pbuf;
1104     return ret;
1105 }
1106
1107 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1108 {
1109     FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
1110
1111     /* Consistency checks */
1112     if (link->type == AVMEDIA_TYPE_VIDEO) {
1113         if (strcmp(link->dst->filter->name, "scale")) {
1114             av_assert1(frame->format                 == link->format);
1115             av_assert1(frame->width               == link->w);
1116             av_assert1(frame->height               == link->h);
1117         }
1118     } else {
1119         av_assert1(frame->format                == link->format);
1120         av_assert1(av_frame_get_channels(frame) == link->channels);
1121         av_assert1(frame->channel_layout        == link->channel_layout);
1122         av_assert1(frame->sample_rate           == link->sample_rate);
1123     }
1124
1125     /* Go directly to actual filtering if possible */
1126     if (link->type == AVMEDIA_TYPE_AUDIO &&
1127         link->min_samples &&
1128         (link->partial_buf ||
1129          frame->nb_samples < link->min_samples ||
1130          frame->nb_samples > link->max_samples)) {
1131         return ff_filter_frame_needs_framing(link, frame);
1132     } else {
1133         return ff_filter_frame_framed(link, frame);
1134     }
1135 }
1136
1137 const AVClass *avfilter_get_class(void)
1138 {
1139     return &avfilter_class;
1140 }