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