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

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