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 }, .flags = FLAGS, .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 ff_filter_process_command(AVFilterContext *ctx, const char *cmd,
 888                               const char *arg, char *res, int res_len, int flags)
 889 {
 890     const AVOption *o;
 891
 892     if (!ctx->filter->priv_class)
 893         return 0;
 894     o = av_opt_find2(ctx->priv, cmd, NULL, AV_OPT_FLAG_RUNTIME_PARAM | AV_OPT_FLAG_FILTERING_PARAM, AV_OPT_SEARCH_CHILDREN, NULL);
 895     if (!o)
 896         return AVERROR(ENOSYS);
 897     return av_opt_set(ctx->priv, cmd, arg, 0);
 898 }
 899
 900 int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
 901 {
 902     int ret = 0;
 903
 904     ret = av_opt_set_dict(ctx, options);
 905     if (ret < 0) {
 906         av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
 907         return ret;
 908     }
 909
 910     if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
 911         ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
 912         ctx->graph->internal->thread_execute) {
 913         ctx->thread_type       = AVFILTER_THREAD_SLICE;
 914         ctx->internal->execute = ctx->graph->internal->thread_execute;
 915     } else {
 916         ctx->thread_type = 0;
 917     }
 918
 919     if (ctx->filter->priv_class) {
 920         ret = av_opt_set_dict2(ctx->priv, options, AV_OPT_SEARCH_CHILDREN);
 921         if (ret < 0) {
 922             av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
 923             return ret;
 924         }
 925     }
 926
 927     if (ctx->filter->init_opaque)
 928         ret = ctx->filter->init_opaque(ctx, NULL);
 929     else if (ctx->filter->init)
 930         ret = ctx->filter->init(ctx);
 931     else if (ctx->filter->init_dict)
 932         ret = ctx->filter->init_dict(ctx, options);
 933
 934     return ret;
 935 }
 936
 937 int avfilter_init_str(AVFilterContext *filter, const char *args)
 938 {
 939     AVDictionary *options = NULL;
 940     AVDictionaryEntry *e;
 941     int ret = 0;
 942
 943     if (args && *args) {
 944         if (!filter->filter->priv_class) {
 945             av_log(filter, AV_LOG_ERROR, "This filter does not take any "
 946                    "options, but options were provided: %s.\n", args);
 947             return AVERROR(EINVAL);
 948         }
 949
 950 #if FF_API_OLD_FILTER_OPTS_ERROR
 951             if (   !strcmp(filter->filter->name, "format")     ||
 952                    !strcmp(filter->filter->name, "noformat")   ||
 953                    !strcmp(filter->filter->name, "frei0r")     ||
 954                    !strcmp(filter->filter->name, "frei0r_src") ||
 955                    !strcmp(filter->filter->name, "ocv")        ||
 956                    !strcmp(filter->filter->name, "pan")        ||
 957                    !strcmp(filter->filter->name, "pp")         ||
 958                    !strcmp(filter->filter->name, "aevalsrc")) {
 959             /* a hack for compatibility with the old syntax
 960              * replace colons with |s */
 961             char *copy = av_strdup(args);
 962             char *p    = copy;
 963             int nb_leading = 0; // number of leading colons to skip
 964             int deprecated = 0;
 965
 966             if (!copy) {
 967                 ret = AVERROR(ENOMEM);
 968                 goto fail;
 969             }
 970
 971             if (!strcmp(filter->filter->name, "frei0r") ||
 972                 !strcmp(filter->filter->name, "ocv"))
 973                 nb_leading = 1;
 974             else if (!strcmp(filter->filter->name, "frei0r_src"))
 975                 nb_leading = 3;
 976
 977             while (nb_leading--) {
 978                 p = strchr(p, ':');
 979                 if (!p) {
 980                     p = copy + strlen(copy);
 981                     break;
 982                 }
 983                 p++;
 984             }
 985
 986             deprecated = strchr(p, ':') != NULL;
 987
 988             if (!strcmp(filter->filter->name, "aevalsrc")) {
 989                 deprecated = 0;
 990                 while ((p = strchr(p, ':')) && p[1] != ':') {
 991                     const char *epos = strchr(p + 1, '=');
 992                     const char *spos = strchr(p + 1, ':');
 993                     const int next_token_is_opt = epos && (!spos || epos < spos);
 994                     if (next_token_is_opt) {
 995                         p++;
 996                         break;
 997                     }
 998                     /* next token does not contain a '=', assume a channel expression */
 999                     deprecated = 1;
1000                     *p++ = '|';
1001                 }
1002                 if (p && *p == ':') { // double sep '::' found
1003                     deprecated = 1;
1004                     memmove(p, p + 1, strlen(p));
1005                 }
1006             } else
1007             while ((p = strchr(p, ':')))
1008                 *p++ = '|';
1009
1010             if (deprecated) {
1011                 av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "
1012                        "'|' to separate the list items ('%s' instead of '%s')\n",
1013                        copy, args);
1014                 ret = AVERROR(EINVAL);
1015             } else {
1016                 ret = process_options(filter, &options, copy);
1017             }
1018             av_freep(&copy);
1019
1020             if (ret < 0)
1021                 goto fail;
1022         } else
1023 #endif
1024         {
1025             ret = process_options(filter, &options, args);
1026             if (ret < 0)
1027                 goto fail;
1028         }
1029     }
1030
1031     ret = avfilter_init_dict(filter, &options);
1032     if (ret < 0)
1033         goto fail;
1034
1035     if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1036         av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
1037         ret = AVERROR_OPTION_NOT_FOUND;
1038         goto fail;
1039     }
1040
1041 fail:
1042     av_dict_free(&options);
1043
1044     return ret;
1045 }
1046
1047 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
1048 {
1049     return pads[pad_idx].name;
1050 }
1051
1052 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
1053 {
1054     return pads[pad_idx].type;
1055 }
1056
1057 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
1058 {
1059     return ff_filter_frame(link->dst->outputs[0], frame);
1060 }
1061
1062 static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
1063 {
1064     int (*filter_frame)(AVFilterLink *, AVFrame *);
1065     AVFilterContext *dstctx = link->dst;
1066     AVFilterPad *dst = link->dstpad;
1067     int ret;
1068
1069     if (!(filter_frame = dst->filter_frame))
1070         filter_frame = default_filter_frame;
1071
1072     if (dst->needs_writable) {
1073         ret = ff_inlink_make_frame_writable(link, &frame);
1074         if (ret < 0)
1075             goto fail;
1076     }
1077
1078     ff_inlink_process_commands(link, frame);
1079     dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1080
1081     if (dstctx->is_disabled &&
1082         (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
1083         filter_frame = default_filter_frame;
1084     ret = filter_frame(link, frame);
1085     link->frame_count_out++;
1086     return ret;
1087
1088 fail:
1089     av_frame_free(&frame);
1090     return ret;
1091 }
1092
1093 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1094 {
1095     int ret;
1096     FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
1097
1098     /* Consistency checks */
1099     if (link->type == AVMEDIA_TYPE_VIDEO) {
1100         if (strcmp(link->dst->filter->name, "buffersink") &&
1101             strcmp(link->dst->filter->name, "format") &&
1102             strcmp(link->dst->filter->name, "idet") &&
1103             strcmp(link->dst->filter->name, "null") &&
1104             strcmp(link->dst->filter->name, "scale")) {
1105             av_assert1(frame->format                 == link->format);
1106             av_assert1(frame->width               == link->w);
1107             av_assert1(frame->height               == link->h);
1108         }
1109     } else {
1110         if (frame->format != link->format) {
1111             av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1112             goto error;
1113         }
1114         if (frame->channels != link->channels) {
1115             av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");
1116             goto error;
1117         }
1118         if (frame->channel_layout != link->channel_layout) {
1119             av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1120             goto error;
1121         }
1122         if (frame->sample_rate != link->sample_rate) {
1123             av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1124             goto error;
1125         }
1126     }
1127
1128     link->frame_blocked_in = link->frame_wanted_out = 0;
1129     link->frame_count_in++;
1130     filter_unblock(link->dst);
1131     ret = ff_framequeue_add(&link->fifo, frame);
1132     if (ret < 0) {
1133         av_frame_free(&frame);
1134         return ret;
1135     }
1136     ff_filter_set_ready(link->dst, 300);
1137     return 0;
1138
1139 error:
1140     av_frame_free(&frame);
1141     return AVERROR_PATCHWELCOME;
1142 }
1143
1144 static int samples_ready(AVFilterLink *link, unsigned min)
1145 {
1146     return ff_framequeue_queued_frames(&link->fifo) &&
1147            (ff_framequeue_queued_samples(&link->fifo) >= min ||
1148             link->status_in);
1149 }
1150
1151 static int take_samples(AVFilterLink *link, unsigned min, unsigned max,
1152                         AVFrame **rframe)
1153 {
1154     AVFrame *frame0, *frame, *buf;
1155     unsigned nb_samples, nb_frames, i, p;
1156     int ret;
1157
1158     /* Note: this function relies on no format changes and must only be
1159        called with enough samples. */
1160     av_assert1(samples_ready(link, link->min_samples));
1161     frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
1162     if (!link->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1163         *rframe = ff_framequeue_take(&link->fifo);
1164         return 0;
1165     }
1166     nb_frames = 0;
1167     nb_samples = 0;
1168     while (1) {
1169         if (nb_samples + frame->nb_samples > max) {
1170             if (nb_samples < min)
1171                 nb_samples = max;
1172             break;
1173         }
1174         nb_samples += frame->nb_samples;
1175         nb_frames++;
1176         if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
1177             break;
1178         frame = ff_framequeue_peek(&link->fifo, nb_frames);
1179     }
1180
1181     buf = ff_get_audio_buffer(link, nb_samples);
1182     if (!buf)
1183         return AVERROR(ENOMEM);
1184     ret = av_frame_copy_props(buf, frame0);
1185     if (ret < 0) {
1186         av_frame_free(&buf);
1187         return ret;
1188     }
1189     buf->pts = frame0->pts;
1190
1191     p = 0;
1192     for (i = 0; i < nb_frames; i++) {
1193         frame = ff_framequeue_take(&link->fifo);
1194         av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1195                         frame->nb_samples, link->channels, link->format);
1196         p += frame->nb_samples;
1197         av_frame_free(&frame);
1198     }
1199     if (p < nb_samples) {
1200         unsigned n = nb_samples - p;
1201         frame = ff_framequeue_peek(&link->fifo, 0);
1202         av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1203                         link->channels, link->format);
1204         ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
1205     }
1206
1207     *rframe = buf;
1208     return 0;
1209 }
1210
1211 static int ff_filter_frame_to_filter(AVFilterLink *link)
1212 {
1213     AVFrame *frame = NULL;
1214     AVFilterContext *dst = link->dst;
1215     int ret;
1216
1217     av_assert1(ff_framequeue_queued_frames(&link->fifo));
1218     ret = link->min_samples ?
1219           ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1220           ff_inlink_consume_frame(link, &frame);
1221     av_assert1(ret);
1222     if (ret < 0) {
1223         av_assert1(!frame);
1224         return ret;
1225     }
1226     /* The filter will soon have received a new frame, that may allow it to
1227        produce one or more: unblock its outputs. */
1228     filter_unblock(dst);
1229     /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1230        before the frame; ff_filter_frame_framed() will re-increment it. */
1231     link->frame_count_out--;
1232     ret = ff_filter_frame_framed(link, frame);
1233     if (ret < 0 && ret != link->status_out) {
1234         ff_avfilter_link_set_out_status(link, ret, AV_NOPTS_VALUE);
1235     } else {
1236         /* Run once again, to see if several frames were available, or if
1237            the input status has also changed, or any other reason. */
1238         ff_filter_set_ready(dst, 300);
1239     }
1240     return ret;
1241 }
1242
1243 static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
1244 {
1245     unsigned out = 0, progress = 0;
1246     int ret;
1247
1248     av_assert0(!in->status_out);
1249     if (!filter->nb_outputs) {
1250         /* not necessary with the current API and sinks */
1251         return 0;
1252     }
1253     while (!in->status_out) {
1254         if (!filter->outputs[out]->status_in) {
1255             progress++;
1256             ret = ff_request_frame_to_filter(filter->outputs[out]);
1257             if (ret < 0)
1258                 return ret;
1259         }
1260         if (++out == filter->nb_outputs) {
1261             if (!progress) {
1262                 /* Every output already closed: input no longer interesting
1263                    (example: overlay in shortest mode, other input closed). */
1264                 ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
1265                 return 0;
1266             }
1267             progress = 0;
1268             out = 0;
1269         }
1270     }
1271     ff_filter_set_ready(filter, 200);
1272     return 0;
1273 }
1274
1275 static int ff_filter_activate_default(AVFilterContext *filter)
1276 {
1277     unsigned i;
1278
1279     for (i = 0; i < filter->nb_inputs; i++) {
1280         if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1281             return ff_filter_frame_to_filter(filter->inputs[i]);
1282         }
1283     }
1284     for (i = 0; i < filter->nb_inputs; i++) {
1285         if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1286             av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1287             return forward_status_change(filter, filter->inputs[i]);
1288         }
1289     }
1290     for (i = 0; i < filter->nb_outputs; i++) {
1291         if (filter->outputs[i]->frame_wanted_out &&
1292             !filter->outputs[i]->frame_blocked_in) {
1293             return ff_request_frame_to_filter(filter->outputs[i]);
1294         }
1295     }
1296     return FFERROR_NOT_READY;
1297 }
1298
1299 /*
1300    Filter scheduling and activation
1301
1302    When a filter is activated, it must:
1303    - if possible, output a frame;
1304    - else, if relevant, forward the input status change;
1305    - else, check outputs for wanted frames and forward the requests.
1306
1307    The following AVFilterLink fields are used for activation:
1308
1309    - frame_wanted_out:
1310
1311      This field indicates if a frame is needed on this input of the
1312      destination filter. A positive value indicates that a frame is needed
1313      to process queued frames or internal data or to satisfy the
1314      application; a zero value indicates that a frame is not especially
1315      needed but could be processed anyway; a negative value indicates that a
1316      frame would just be queued.
1317
1318      It is set by filters using ff_request_frame() or ff_request_no_frame(),
1319      when requested by the application through a specific API or when it is
1320      set on one of the outputs.
1321
1322      It is cleared when a frame is sent from the source using
1323      ff_filter_frame().
1324
1325      It is also cleared when a status change is sent from the source using
1326      ff_avfilter_link_set_in_status().
1327
1328    - frame_blocked_in:
1329
1330      This field means that the source filter can not generate a frame as is.
1331      Its goal is to avoid repeatedly calling the request_frame() method on
1332      the same link.
1333
1334      It is set by the framework on all outputs of a filter before activating it.
1335
1336      It is automatically cleared by ff_filter_frame().
1337
1338      It is also automatically cleared by ff_avfilter_link_set_in_status().
1339
1340      It is also cleared on all outputs (using filter_unblock()) when
1341      something happens on an input: processing a frame or changing the
1342      status.
1343
1344    - fifo:
1345
1346      Contains the frames queued on a filter input. If it contains frames and
1347      frame_wanted_out is not set, then the filter can be activated. If that
1348      result in the filter not able to use these frames, the filter must set
1349      frame_wanted_out to ask for more frames.
1350
1351    - status_in and status_in_pts:
1352
1353      Status (EOF or error code) of the link and timestamp of the status
1354      change (in link time base, same as frames) as seen from the input of
1355      the link. The status change is considered happening after the frames
1356      queued in fifo.
1357
1358      It is set by the source filter using ff_avfilter_link_set_in_status().
1359
1360    - status_out:
1361
1362      Status of the link as seen from the output of the link. The status
1363      change is considered having already happened.
1364
1365      It is set by the destination filter using
1366      ff_avfilter_link_set_out_status().
1367
1368    Filters are activated according to the ready field, set using the
1369    ff_filter_set_ready(). Eventually, a priority queue will be used.
1370    ff_filter_set_ready() is called whenever anything could cause progress to
1371    be possible. Marking a filter ready when it is not is not a problem,
1372    except for the small overhead it causes.
1373
1374    Conditions that cause a filter to be marked ready are:
1375
1376    - frames added on an input link;
1377
1378    - changes in the input or output status of an input link;
1379
1380    - requests for a frame on an output link;
1381
1382    - after any actual processing using the legacy methods (filter_frame(),
1383      and request_frame() to acknowledge status changes), to run once more
1384      and check if enough input was present for several frames.
1385
1386    Examples of scenarios to consider:
1387
1388    - buffersrc: activate if frame_wanted_out to notify the application;
1389      activate when the application adds a frame to push it immediately.
1390
1391    - testsrc: activate only if frame_wanted_out to produce and push a frame.
1392
1393    - concat (not at stitch points): can process a frame on any output.
1394      Activate if frame_wanted_out on output to forward on the corresponding
1395      input. Activate when a frame is present on input to process it
1396      immediately.
1397
1398    - framesync: needs at least one frame on each input; extra frames on the
1399      wrong input will accumulate. When a frame is first added on one input,
1400      set frame_wanted_out<0 on it to avoid getting more (would trigger
1401      testsrc) and frame_wanted_out>0 on the other to allow processing it.
1402
1403    Activation of old filters:
1404
1405    In order to activate a filter implementing the legacy filter_frame() and
1406    request_frame() methods, perform the first possible of the following
1407    actions:
1408
1409    - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1410      frame and call filter_frame().
1411
1412      Rationale: filter frames as soon as possible instead of leaving them
1413      queued; frame_wanted_out < 0 is not possible since the old API does not
1414      set it nor provides any similar feedback; frame_wanted_out > 0 happens
1415      when min_samples > 0 and there are not enough samples queued.
1416
1417    - If an input has status_in set but not status_out, try to call
1418      request_frame() on one of the outputs in the hope that it will trigger
1419      request_frame() on the input with status_in and acknowledge it. This is
1420      awkward and fragile, filters with several inputs or outputs should be
1421      updated to direct activation as soon as possible.
1422
1423    - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1424      request_frame().
1425
1426      Rationale: checking frame_blocked_in is necessary to avoid requesting
1427      repeatedly on a blocked input if another is not blocked (example:
1428      [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1429
1430      TODO: respect needs_fifo and remove auto-inserted fifos.
1431
1432  */
1433
1434 int ff_filter_activate(AVFilterContext *filter)
1435 {
1436     int ret;
1437
1438     /* Generic timeline support is not yet implemented but should be easy */
1439     av_assert1(!(filter->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
1440                  filter->filter->activate));
1441     filter->ready = 0;
1442     ret = filter->filter->activate ? filter->filter->activate(filter) :
1443           ff_filter_activate_default(filter);
1444     if (ret == FFERROR_NOT_READY)
1445         ret = 0;
1446     return ret;
1447 }
1448
1449 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1450 {
1451     *rpts = link->current_pts;
1452     if (ff_framequeue_queued_frames(&link->fifo))
1453         return *rstatus = 0;
1454     if (link->status_out)
1455         return *rstatus = link->status_out;
1456     if (!link->status_in)
1457         return *rstatus = 0;
1458     *rstatus = link->status_out = link->status_in;
1459     ff_update_link_current_pts(link, link->status_in_pts);
1460     *rpts = link->current_pts;
1461     return 1;
1462 }
1463
1464 size_t ff_inlink_queued_frames(AVFilterLink *link)
1465 {
1466     return ff_framequeue_queued_frames(&link->fifo);
1467 }
1468
1469 int ff_inlink_check_available_frame(AVFilterLink *link)
1470 {
1471     return ff_framequeue_queued_frames(&link->fifo) > 0;
1472 }
1473
1474 int ff_inlink_queued_samples(AVFilterLink *link)
1475 {
1476     return ff_framequeue_queued_samples(&link->fifo);
1477 }
1478
1479 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1480 {
1481     uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1482     av_assert1(min);
1483     return samples >= min || (link->status_in && samples);
1484 }
1485
1486 static void consume_update(AVFilterLink *link, const AVFrame *frame)
1487 {
1488     ff_update_link_current_pts(link, frame->pts);
1489     ff_inlink_process_commands(link, frame);
1490     link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1491     link->frame_count_out++;
1492 }
1493
1494 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1495 {
1496     AVFrame *frame;
1497
1498     *rframe = NULL;
1499     if (!ff_inlink_check_available_frame(link))
1500         return 0;
1501
1502     if (link->fifo.samples_skipped) {
1503         frame = ff_framequeue_peek(&link->fifo, 0);
1504         return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1505     }
1506
1507     frame = ff_framequeue_take(&link->fifo);
1508     consume_update(link, frame);
1509     *rframe = frame;
1510     return 1;
1511 }
1512
1513 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1514                             AVFrame **rframe)
1515 {
1516     AVFrame *frame;
1517     int ret;
1518
1519     av_assert1(min);
1520     *rframe = NULL;
1521     if (!ff_inlink_check_available_samples(link, min))
1522         return 0;
1523     if (link->status_in)
1524         min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
1525     ret = take_samples(link, min, max, &frame);
1526     if (ret < 0)
1527         return ret;
1528     consume_update(link, frame);
1529     *rframe = frame;
1530     return 1;
1531 }
1532
1533 AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
1534 {
1535     return ff_framequeue_peek(&link->fifo, idx);
1536 }
1537
1538 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1539 {
1540     AVFrame *frame = *rframe;
1541     AVFrame *out;
1542     int ret;
1543
1544     if (av_frame_is_writable(frame))
1545         return 0;
1546     av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1547
1548     switch (link->type) {
1549     case AVMEDIA_TYPE_VIDEO:
1550         out = ff_get_video_buffer(link, link->w, link->h);
1551         break;
1552     case AVMEDIA_TYPE_AUDIO:
1553         out = ff_get_audio_buffer(link, frame->nb_samples);
1554         break;
1555     default:
1556         return AVERROR(EINVAL);
1557     }
1558     if (!out)
1559         return AVERROR(ENOMEM);
1560
1561     ret = av_frame_copy_props(out, frame);
1562     if (ret < 0) {
1563         av_frame_free(&out);
1564         return ret;
1565     }
1566
1567     switch (link->type) {
1568     case AVMEDIA_TYPE_VIDEO:
1569         av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1570                       frame->format, frame->width, frame->height);
1571         break;
1572     case AVMEDIA_TYPE_AUDIO:
1573         av_samples_copy(out->extended_data, frame->extended_data,
1574                         0, 0, frame->nb_samples,
1575                         frame->channels,
1576                         frame->format);
1577         break;
1578     default:
1579         av_assert0(!"reached");
1580     }
1581
1582     av_frame_free(&frame);
1583     *rframe = out;
1584     return 0;
1585 }
1586
1587 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1588 {
1589     AVFilterCommand *cmd = link->dst->command_queue;
1590
1591     while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1592         av_log(link->dst, AV_LOG_DEBUG,
1593                "Processing command time:%f command:%s arg:%s\n",
1594                cmd->time, cmd->command, cmd->arg);
1595         avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1596         ff_command_queue_pop(link->dst);
1597         cmd= link->dst->command_queue;
1598     }
1599     return 0;
1600 }
1601
1602 int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1603 {
1604     AVFilterContext *dstctx = link->dst;
1605     int64_t pts = frame->pts;
1606     int64_t pos = frame->pkt_pos;
1607
1608     if (!dstctx->enable_str)
1609         return 1;
1610
1611     dstctx->var_values[VAR_N] = link->frame_count_out;
1612     dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1613     dstctx->var_values[VAR_W] = link->w;
1614     dstctx->var_values[VAR_H] = link->h;
1615     dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1616
1617     return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1618 }
1619
1620 void ff_inlink_request_frame(AVFilterLink *link)
1621 {
1622     av_assert1(!link->status_in);
1623     av_assert1(!link->status_out);
1624     link->frame_wanted_out = 1;
1625     ff_filter_set_ready(link->src, 100);
1626 }
1627
1628 void ff_inlink_set_status(AVFilterLink *link, int status)
1629 {
1630     if (link->status_out)
1631         return;
1632     link->frame_wanted_out = 0;
1633     link->frame_blocked_in = 0;
1634     ff_avfilter_link_set_out_status(link, status, AV_NOPTS_VALUE);
1635     while (ff_framequeue_queued_frames(&link->fifo)) {
1636            AVFrame *frame = ff_framequeue_take(&link->fifo);
1637            av_frame_free(&frame);
1638     }
1639     if (!link->status_in)
1640         link->status_in = status;
1641 }
1642
1643 int ff_outlink_get_status(AVFilterLink *link)
1644 {
1645     return link->status_in;
1646 }
1647
1648 const AVClass *avfilter_get_class(void)
1649 {
1650     return &avfilter_class;
1651 }
1652
1653 int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link,
1654                              int default_pool_size)
1655 {
1656     AVHWFramesContext *frames;
1657
1658     // Must already be set by caller.
1659     av_assert0(link->hw_frames_ctx);
1660
1661     frames = (AVHWFramesContext*)link->hw_frames_ctx->data;
1662
1663     if (frames->initial_pool_size == 0) {
1664         // Dynamic allocation is necessarily supported.
1665     } else if (avctx->extra_hw_frames >= 0) {
1666         frames->initial_pool_size += avctx->extra_hw_frames;
1667     } else {
1668         frames->initial_pool_size = default_pool_size;
1669     }
1670
1671     return 0;
1672 }