git.sesse.net Git - ffmpeg/blob - 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     "anullsrc",
 680     "aresample",
 681     "asendcmd",
 682     "asetnsamples",
 683     "astreamsync",
 684     "atempo",
 685     "bbox",
 686     "blackdetect",
 687     "buffer"
 688     "flite",
 689     "hue",
 690     "mp",
 691     "pan",
 692     "removelogo",
 693     "scale",
 694     "sendcmd",
 695     "setdar",
 696     "setsar",
 697     "smptebars",
 698 };
 699
 700 static int filter_use_deprecated_init(const char *name)
 701 {
 702     int i;
 703     for (i = 0; i < FF_ARRAY_ELEMS(filters_left_to_update); i++)
 704         if (!strcmp(name, filters_left_to_update[i]))
 705             return 1;
 706     return 0;
 707 }
 708
 709 int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque)
 710 {
 711     AVDictionary *options = NULL;
 712     AVDictionaryEntry *e;
 713     int ret=0;
 714     int deprecated_init = filter_use_deprecated_init(filter->filter->name);
 715
 716     // TODO: remove old shorthand
 717     if (filter->filter->shorthand) {
 718         av_assert0(filter->priv);
 719         av_assert0(filter->filter->priv_class);
 720         *(const AVClass **)filter->priv = filter->filter->priv_class;
 721         av_opt_set_defaults(filter->priv);
 722         ret = av_opt_set_from_string(filter->priv, args,
 723                                      filter->filter->shorthand, "=", ":");
 724         if (ret < 0)
 725             return ret;
 726         args = NULL;
 727     }
 728
 729     if (!deprecated_init && args && *args) {
 730         if (!filter->filter->priv_class) {
 731             av_log(filter, AV_LOG_ERROR, "This filter does not take any "
 732                    "options, but options were provided: %s.\n", args);
 733             return AVERROR(EINVAL);
 734         }
 735
 736 #if FF_API_OLD_FILTER_OPTS
 737         if (!strcmp(filter->filter->name, "scale") &&
 738             strchr(args, ':') < strchr(args, '=')) {
 739             /* old w:h:flags=<flags> syntax */
 740             char *copy = av_strdup(args);
 741             char *p;
 742
 743             av_log(filter, AV_LOG_WARNING, "The <w>:<h>:flags=<flags> option "
 744                    "syntax is deprecated. Use either <w>:<h>:<flags> or "
 745                    "w=<w>:h=<h>:flags=<flags>.\n");
 746
 747             if (!copy) {
 748                 ret = AVERROR(ENOMEM);
 749                 goto fail;
 750             }
 751
 752             p = strrchr(copy, ':');
 753             if (p) {
 754                 *p++ = 0;
 755                 ret = av_dict_parse_string(&options, p, "=", ":", 0);
 756             }
 757             if (ret >= 0)
 758                 ret = process_options(filter, &options, copy);
 759             av_freep(&copy);
 760
 761             if (ret < 0)
 762                 goto fail;
 763         } else if (!strcmp(filter->filter->name, "format")     ||
 764                    !strcmp(filter->filter->name, "noformat")   ||
 765                    !strcmp(filter->filter->name, "frei0r")     ||
 766                    !strcmp(filter->filter->name, "frei0r_src") ||
 767                    !strcmp(filter->filter->name, "ocv")) {
 768             /* a hack for compatibility with the old syntax
 769              * replace colons with |s */
 770             char *copy = av_strdup(args);
 771             char *p    = copy;
 772             int nb_leading = 0; // number of leading colons to skip
 773
 774             if (!copy) {
 775                 ret = AVERROR(ENOMEM);
 776                 goto fail;
 777             }
 778
 779             if (!strcmp(filter->filter->name, "frei0r") ||
 780                 !strcmp(filter->filter->name, "ocv"))
 781                 nb_leading = 1;
 782             else if (!strcmp(filter->filter->name, "frei0r_src"))
 783                 nb_leading = 3;
 784
 785             while (nb_leading--) {
 786                 p = strchr(p, ':');
 787                 if (!p) {
 788                     p = copy + strlen(copy);
 789                     break;
 790                 }
 791                 p++;
 792             }
 793
 794             if (strchr(p, ':')) {
 795                 av_log(filter, AV_LOG_WARNING, "This syntax is deprecated. Use "
 796                        "'|' to separate the list items.\n");
 797             }
 798
 799             while ((p = strchr(p, ':')))
 800                 *p++ = '|';
 801
 802             ret = process_options(filter, &options, copy);
 803             av_freep(&copy);
 804
 805             if (ret < 0)
 806                 goto fail;
 807 #endif
 808         } else {
 809             ret = process_options(filter, &options, args);
 810             if (ret < 0)
 811                 goto fail;
 812         }
 813     }
 814
 815     if (!deprecated_init && filter->filter->priv_class) {
 816         ret = av_opt_set_dict(filter->priv, &options);
 817         if (ret < 0) {
 818             av_log(filter, AV_LOG_ERROR, "Error applying options to the filter.\n");
 819             goto fail;
 820         }
 821     }
 822
 823     if (filter->filter->init_opaque)
 824         ret = filter->filter->init_opaque(filter, args, opaque);
 825     else if (filter->filter->init)
 826         ret = filter->filter->init(filter, args);
 827     else if (filter->filter->init_dict)
 828         ret = filter->filter->init_dict(filter, &options);
 829     if (ret < 0)
 830         goto fail;
 831
 832     if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 833         av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
 834         ret = AVERROR_OPTION_NOT_FOUND;
 835         goto fail;
 836     }
 837
 838 fail:
 839     av_dict_free(&options);
 840
 841     return ret;
 842 }
 843
 844 const char *avfilter_pad_get_name(AVFilterPad *pads, int pad_idx)
 845 {
 846     return pads[pad_idx].name;
 847 }
 848
 849 enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx)
 850 {
 851     return pads[pad_idx].type;
 852 }
 853
 854 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
 855 {
 856     return ff_filter_frame(link->dst->outputs[0], frame);
 857 }
 858
 859 static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
 860 {
 861     int (*filter_frame)(AVFilterLink *, AVFrame *);
 862     AVFilterPad *dst = link->dstpad;
 863     AVFrame *out;
 864     int ret;
 865     AVFilterCommand *cmd= link->dst->command_queue;
 866     int64_t pts;
 867
 868     if (link->closed) {
 869         av_frame_free(&frame);
 870         return AVERROR_EOF;
 871     }
 872
 873     if (!(filter_frame = dst->filter_frame))
 874         filter_frame = default_filter_frame;
 875
 876     /* copy the frame if needed */
 877     if (dst->needs_writable && !av_frame_is_writable(frame)) {
 878         av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
 879
 880         /* Maybe use ff_copy_buffer_ref instead? */
 881         switch (link->type) {
 882         case AVMEDIA_TYPE_VIDEO:
 883             out = ff_get_video_buffer(link, link->w, link->h);
 884             break;
 885         case AVMEDIA_TYPE_AUDIO:
 886             out = ff_get_audio_buffer(link, frame->nb_samples);
 887             break;
 888         default: return AVERROR(EINVAL);
 889         }
 890         if (!out) {
 891             av_frame_free(&frame);
 892             return AVERROR(ENOMEM);
 893         }
 894         av_frame_copy_props(out, frame);
 895
 896         switch (link->type) {
 897         case AVMEDIA_TYPE_VIDEO:
 898             av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
 899                           frame->format, frame->width, frame->height);
 900             break;
 901         case AVMEDIA_TYPE_AUDIO:
 902             av_samples_copy(out->extended_data, frame->extended_data,
 903                             0, 0, frame->nb_samples,
 904                             av_get_channel_layout_nb_channels(frame->channel_layout),
 905                             frame->format);
 906             break;
 907         default: return AVERROR(EINVAL);
 908         }
 909
 910         av_frame_free(&frame);
 911     } else
 912         out = frame;
 913
 914     while(cmd && cmd->time <= out->pts * av_q2d(link->time_base)){
 915         av_log(link->dst, AV_LOG_DEBUG,
 916                "Processing command time:%f command:%s arg:%s\n",
 917                cmd->time, cmd->command, cmd->arg);
 918         avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
 919         ff_command_queue_pop(link->dst);
 920         cmd= link->dst->command_queue;
 921     }
 922
 923     pts = out->pts;
 924     ret = filter_frame(link, out);
 925     link->frame_requested = 0;
 926     ff_update_link_current_pts(link, pts);
 927     return ret;
 928 }
 929
 930 static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFrame *frame)
 931 {
 932     int insamples = frame->nb_samples, inpos = 0, nb_samples;
 933     AVFrame *pbuf = link->partial_buf;
 934     int nb_channels = av_frame_get_channels(frame);
 935     int ret = 0;
 936
 937     link->flags |= FF_LINK_FLAG_REQUEST_LOOP;
 938     /* Handle framing (min_samples, max_samples) */
 939     while (insamples) {
 940         if (!pbuf) {
 941             AVRational samples_tb = { 1, link->sample_rate };
 942             pbuf = ff_get_audio_buffer(link, link->partial_buf_size);
 943             if (!pbuf) {
 944                 av_log(link->dst, AV_LOG_WARNING,
 945                        "Samples dropped due to memory allocation failure.\n");
 946                 return 0;
 947             }
 948             av_frame_copy_props(pbuf, frame);
 949             pbuf->pts = frame->pts +
 950                         av_rescale_q(inpos, samples_tb, link->time_base);
 951             pbuf->nb_samples = 0;
 952         }
 953         nb_samples = FFMIN(insamples,
 954                            link->partial_buf_size - pbuf->nb_samples);
 955         av_samples_copy(pbuf->extended_data, frame->extended_data,
 956                         pbuf->nb_samples, inpos,
 957                         nb_samples, nb_channels, link->format);
 958         inpos                   += nb_samples;
 959         insamples               -= nb_samples;
 960         pbuf->nb_samples += nb_samples;
 961         if (pbuf->nb_samples >= link->min_samples) {
 962             ret = ff_filter_frame_framed(link, pbuf);
 963             pbuf = NULL;
 964         }
 965     }
 966     av_frame_free(&frame);
 967     link->partial_buf = pbuf;
 968     return ret;
 969 }
 970
 971 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
 972 {
 973     FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
 974
 975     /* Consistency checks */
 976     if (link->type == AVMEDIA_TYPE_VIDEO) {
 977         if (strcmp(link->dst->filter->name, "scale")) {
 978             av_assert1(frame->format                 == link->format);
 979             av_assert1(frame->width               == link->w);
 980             av_assert1(frame->height               == link->h);
 981         }
 982     } else {
 983         av_assert1(frame->format                == link->format);
 984         av_assert1(av_frame_get_channels(frame) == link->channels);
 985         av_assert1(frame->channel_layout        == link->channel_layout);
 986         av_assert1(frame->sample_rate           == link->sample_rate);
 987     }
 988
 989     /* Go directly to actual filtering if possible */
 990     if (link->type == AVMEDIA_TYPE_AUDIO &&
 991         link->min_samples &&
 992         (link->partial_buf ||
 993          frame->nb_samples < link->min_samples ||
 994          frame->nb_samples > link->max_samples)) {
 995         return ff_filter_frame_needs_framing(link, frame);
 996     } else {
 997         return ff_filter_frame_framed(link, frame);
 998     }
 999 }
1000
1001 const AVClass *avfilter_get_class(void)
1002 {
1003     return &avfilter_class;
1004 }