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