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