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

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