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

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