git.sesse.net Git - ffmpeg/blob - libavfilter/avfilter.c

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