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