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         ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
1239     }
1240
1241     *rframe = buf;
1242     return 0;
1243 }
1244
1245 static int ff_filter_frame_to_filter(AVFilterLink *link)
1246 {
1247     AVFrame *frame = NULL;
1248     AVFilterContext *dst = link->dst;
1249     int ret;
1250
1251     av_assert1(ff_framequeue_queued_frames(&link->fifo));
1252     ret = link->min_samples ?
1253           ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1254           ff_inlink_consume_frame(link, &frame);
1255     av_assert1(ret);
1256     if (ret < 0) {
1257         av_assert1(!frame);
1258         return ret;
1259     }
1260     /* The filter will soon have received a new frame, that may allow it to
1261        produce one or more: unblock its outputs. */
1262     filter_unblock(dst);
1263     /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1264        before the frame; ff_filter_frame_framed() will re-increment it. */
1265     link->frame_count_out--;
1266     ret = ff_filter_frame_framed(link, frame);
1267     if (ret < 0 && ret != link->status_out) {
1268         ff_avfilter_link_set_out_status(link, ret, AV_NOPTS_VALUE);
1269     } else {
1270         /* Run once again, to see if several frames were available, or if
1271            the input status has also changed, or any other reason. */
1272         ff_filter_set_ready(dst, 300);
1273     }
1274     return ret;
1275 }
1276
1277 static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
1278 {
1279     unsigned out = 0, progress = 0;
1280     int ret;
1281
1282     av_assert0(!in->status_out);
1283     if (!filter->nb_outputs) {
1284         /* not necessary with the current API and sinks */
1285         return 0;
1286     }
1287     while (!in->status_out) {
1288         if (!filter->outputs[out]->status_in) {
1289             progress++;
1290             ret = ff_request_frame_to_filter(filter->outputs[out]);
1291             if (ret < 0)
1292                 return ret;
1293         }
1294         if (++out == filter->nb_outputs) {
1295             if (!progress) {
1296                 /* Every output already closed: input no longer interesting
1297                    (example: overlay in shortest mode, other input closed). */
1298                 ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
1299                 return 0;
1300             }
1301             progress = 0;
1302             out = 0;
1303         }
1304     }
1305     ff_filter_set_ready(filter, 200);
1306     return 0;
1307 }
1308
1309 #define FFERROR_NOT_READY FFERRTAG('N','R','D','Y')
1310
1311 static int ff_filter_activate_default(AVFilterContext *filter)
1312 {
1313     unsigned i;
1314
1315     for (i = 0; i < filter->nb_inputs; i++) {
1316         if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1317             return ff_filter_frame_to_filter(filter->inputs[i]);
1318         }
1319     }
1320     for (i = 0; i < filter->nb_inputs; i++) {
1321         if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1322             av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1323             return forward_status_change(filter, filter->inputs[i]);
1324         }
1325     }
1326     for (i = 0; i < filter->nb_outputs; i++) {
1327         if (filter->outputs[i]->frame_wanted_out &&
1328             !filter->outputs[i]->frame_blocked_in) {
1329             return ff_request_frame_to_filter(filter->outputs[i]);
1330         }
1331     }
1332     return FFERROR_NOT_READY;
1333 }
1334
1335 /*
1336    Filter scheduling and activation
1337
1338    When a filter is activated, it must:
1339    - if possible, output a frame;
1340    - else, if relevant, forward the input status change;
1341    - else, check outputs for wanted frames and forward the requests.
1342
1343    The following AVFilterLink fields are used for activation:
1344
1345    - frame_wanted_out:
1346
1347      This field indicates if a frame is needed on this input of the
1348      destination filter. A positive value indicates that a frame is needed
1349      to process queued frames or internal data or to satisfy the
1350      application; a zero value indicates that a frame is not especially
1351      needed but could be processed anyway; a negative value indicates that a
1352      frame would just be queued.
1353
1354      It is set by filters using ff_request_frame() or ff_request_no_frame(),
1355      when requested by the application through a specific API or when it is
1356      set on one of the outputs.
1357
1358      It is cleared when a frame is sent from the source using
1359      ff_filter_frame().
1360
1361      It is also cleared when a status change is sent from the source using
1362      ff_avfilter_link_set_in_status().
1363
1364    - frame_blocked_in:
1365
1366      This field means that the source filter can not generate a frame as is.
1367      Its goal is to avoid repeatedly calling the request_frame() method on
1368      the same link.
1369
1370      It is set by the framework on all outputs of a filter before activating it.
1371
1372      It is automatically cleared by ff_filter_frame().
1373
1374      It is also automatically cleared by ff_avfilter_link_set_in_status().
1375
1376      It is also cleared on all outputs (using filter_unblock()) when
1377      something happens on an input: processing a frame or changing the
1378      status.
1379
1380    - fifo:
1381
1382      Contains the frames queued on a filter input. If it contains frames and
1383      frame_wanted_out is not set, then the filter can be activated. If that
1384      result in the filter not able to use these frames, the filter must set
1385      frame_wanted_out to ask for more frames.
1386
1387    - status_in and status_in_pts:
1388
1389      Status (EOF or error code) of the link and timestamp of the status
1390      change (in link time base, same as frames) as seen from the input of
1391      the link. The status change is considered happening after the frames
1392      queued in fifo.
1393
1394      It is set by the source filter using ff_avfilter_link_set_in_status().
1395
1396    - status_out:
1397
1398      Status of the link as seen from the output of the link. The status
1399      change is considered having already happened.
1400
1401      It is set by the destination filter using
1402      ff_avfilter_link_set_out_status().
1403
1404    Filters are activated according to the ready field, set using the
1405    ff_filter_set_ready(). Eventually, a priority queue will be used.
1406    ff_filter_set_ready() is called whenever anything could cause progress to
1407    be possible. Marking a filter ready when it is not is not a problem,
1408    except for the small overhead it causes.
1409
1410    Conditions that cause a filter to be marked ready are:
1411
1412    - frames added on an input link;
1413
1414    - changes in the input or output status of an input link;
1415
1416    - requests for a frame on an output link;
1417
1418    - after any actual processing using the legacy methods (filter_frame(),
1419      and request_frame() to acknowledge status changes), to run once more
1420      and check if enough input was present for several frames.
1421
1422    Exemples of scenarios to consider:
1423
1424    - buffersrc: activate if frame_wanted_out to notify the application;
1425      activate when the application adds a frame to push it immediately.
1426
1427    - testsrc: activate only if frame_wanted_out to produce and push a frame.
1428
1429    - concat (not at stitch points): can process a frame on any output.
1430      Activate if frame_wanted_out on output to forward on the corresponding
1431      input. Activate when a frame is present on input to process it
1432      immediately.
1433
1434    - framesync: needs at least one frame on each input; extra frames on the
1435      wrong input will accumulate. When a frame is first added on one input,
1436      set frame_wanted_out<0 on it to avoid getting more (would trigger
1437      testsrc) and frame_wanted_out>0 on the other to allow processing it.
1438
1439    Activation of old filters:
1440
1441    In order to activate a filter implementing the legacy filter_frame() and
1442    request_frame() methods, perform the first possible of the following
1443    actions:
1444
1445    - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1446      frame and call filter_frame().
1447
1448      Ratinale: filter frames as soon as possible instead of leaving them
1449      queued; frame_wanted_out < 0 is not possible since the old API does not
1450      set it nor provides any similar feedback; frame_wanted_out > 0 happens
1451      when min_samples > 0 and there are not enough samples queued.
1452
1453    - If an input has status_in set but not status_out, try to call
1454      request_frame() on one of the outputs in the hope that it will trigger
1455      request_frame() on the input with status_in and acknowledge it. This is
1456      awkward and fragile, filters with several inputs or outputs should be
1457      updated to direct activation as soon as possible.
1458
1459    - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1460      request_frame().
1461
1462      Rationale: checking frame_blocked_in is necessary to avoid requesting
1463      repeatedly on a blocked input if another is not blocked (example:
1464      [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1465
1466      TODO: respect needs_fifo and remove auto-inserted fifos.
1467
1468  */
1469
1470 int ff_filter_activate(AVFilterContext *filter)
1471 {
1472     int ret;
1473
1474     /* Generic timeline support is not yet implemented but should be easy */
1475     av_assert1(!(filter->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
1476                  filter->filter->activate));
1477     filter->ready = 0;
1478     ret = filter->filter->activate ? filter->filter->activate(filter) :
1479           ff_filter_activate_default(filter);
1480     if (ret == FFERROR_NOT_READY)
1481         ret = 0;
1482     return ret;
1483 }
1484
1485 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1486 {
1487     *rpts = link->current_pts;
1488     if (ff_framequeue_queued_frames(&link->fifo))
1489         return *rstatus = 0;
1490     if (link->status_out)
1491         return *rstatus = link->status_out;
1492     if (!link->status_in)
1493         return *rstatus = 0;
1494     *rstatus = link->status_out = link->status_in;
1495     ff_update_link_current_pts(link, link->status_in_pts);
1496     *rpts = link->current_pts;
1497     return 1;
1498 }
1499
1500 int ff_inlink_check_available_frame(AVFilterLink *link)
1501 {
1502     return ff_framequeue_queued_frames(&link->fifo) > 0;
1503 }
1504
1505 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1506 {
1507     uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1508     av_assert1(min);
1509     return samples >= min || (link->status_in && samples);
1510 }
1511
1512 static void consume_update(AVFilterLink *link, const AVFrame *frame)
1513 {
1514     ff_update_link_current_pts(link, frame->pts);
1515     ff_inlink_process_commands(link, frame);
1516     link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1517     link->frame_count_out++;
1518 }
1519
1520 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1521 {
1522     AVFrame *frame;
1523
1524     *rframe = NULL;
1525     if (!ff_inlink_check_available_frame(link))
1526         return 0;
1527     frame = ff_framequeue_take(&link->fifo);
1528     consume_update(link, frame);
1529     *rframe = frame;
1530     return 1;
1531 }
1532
1533 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1534                             AVFrame **rframe)
1535 {
1536     AVFrame *frame;
1537     int ret;
1538
1539     av_assert1(min);
1540     *rframe = NULL;
1541     if (!ff_inlink_check_available_samples(link, min))
1542         return 0;
1543     if (link->status_in)
1544         min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
1545     ret = take_samples(link, min, link->max_samples, &frame);
1546     if (ret < 0)
1547         return ret;
1548     consume_update(link, frame);
1549     *rframe = frame;
1550     return 1;
1551 }
1552
1553 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1554 {
1555     AVFrame *frame = *rframe;
1556     AVFrame *out;
1557     int ret;
1558
1559     if (av_frame_is_writable(frame))
1560         return 0;
1561     av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1562
1563     switch (link->type) {
1564     case AVMEDIA_TYPE_VIDEO:
1565         out = ff_get_video_buffer(link, link->w, link->h);
1566         break;
1567     case AVMEDIA_TYPE_AUDIO:
1568         out = ff_get_audio_buffer(link, frame->nb_samples);
1569         break;
1570     default:
1571         return AVERROR(EINVAL);
1572     }
1573     if (!out)
1574         return AVERROR(ENOMEM);
1575
1576     ret = av_frame_copy_props(out, frame);
1577     if (ret < 0) {
1578         av_frame_free(&out);
1579         return ret;
1580     }
1581
1582     switch (link->type) {
1583     case AVMEDIA_TYPE_VIDEO:
1584         av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1585                       frame->format, frame->width, frame->height);
1586         break;
1587     case AVMEDIA_TYPE_AUDIO:
1588         av_samples_copy(out->extended_data, frame->extended_data,
1589                         0, 0, frame->nb_samples,
1590                         av_frame_get_channels(frame),
1591                         frame->format);
1592         break;
1593     default:
1594         av_assert0(!"reached");
1595     }
1596
1597     av_frame_free(&frame);
1598     *rframe = out;
1599     return 0;
1600 }
1601
1602 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1603 {
1604     AVFilterCommand *cmd = link->dst->command_queue;
1605
1606     while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1607         av_log(link->dst, AV_LOG_DEBUG,
1608                "Processing command time:%f command:%s arg:%s\n",
1609                cmd->time, cmd->command, cmd->arg);
1610         avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1611         ff_command_queue_pop(link->dst);
1612         cmd= link->dst->command_queue;
1613     }
1614     return 0;
1615 }
1616
1617 int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1618 {
1619     AVFilterContext *dstctx = link->dst;
1620     int64_t pts = frame->pts;
1621     int64_t pos = av_frame_get_pkt_pos(frame);
1622
1623     if (!dstctx->enable_str)
1624         return 1;
1625
1626     dstctx->var_values[VAR_N] = link->frame_count_out;
1627     dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1628     dstctx->var_values[VAR_W] = link->w;
1629     dstctx->var_values[VAR_H] = link->h;
1630     dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1631
1632     return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1633 }
1634
1635 void ff_inlink_request_frame(AVFilterLink *link)
1636 {
1637     av_assert1(!link->status_in);
1638     av_assert1(!link->status_out);
1639     link->frame_wanted_out = 1;
1640     ff_filter_set_ready(link->src, 100);
1641 }
1642
1643 const AVClass *avfilter_get_class(void)
1644 {
1645     return &avfilter_class;
1646 }