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 static AVFilter *first_filter;
 579 static AVFilter **last_filter = &first_filter;
 580
 581 const AVFilter *avfilter_get_by_name(const char *name)
 582 {
 583     const AVFilter *f = NULL;
 584
 585     if (!name)
 586         return NULL;
 587
 588     while ((f = avfilter_next(f)))
 589         if (!strcmp(f->name, name))
 590             return (AVFilter *)f;
 591
 592     return NULL;
 593 }
 594
 595 static AVMutex filter_register_mutex = AV_MUTEX_INITIALIZER;
 596
 597 int avfilter_register(AVFilter *filter)
 598 {
 599     AVFilter **f;
 600
 601     /* the filter must select generic or internal exclusively */
 602     av_assert0((filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE) != AVFILTER_FLAG_SUPPORT_TIMELINE);
 603
 604     ff_mutex_lock(&filter_register_mutex);
 605     f = last_filter;
 606
 607     while (*f)
 608         f = &(*f)->next;
 609     *f = filter;
 610     filter->next = NULL;
 611     last_filter = &filter->next;
 612
 613     ff_mutex_unlock(&filter_register_mutex);
 614
 615     return 0;
 616 }
 617
 618 const AVFilter *avfilter_next(const AVFilter *prev)
 619 {
 620     return prev ? prev->next : first_filter;
 621 }
 622
 623 int avfilter_pad_count(const AVFilterPad *pads)
 624 {
 625     int count;
 626
 627     if (!pads)
 628         return 0;
 629
 630     for (count = 0; pads->name; count++)
 631         pads++;
 632     return count;
 633 }
 634
 635 static const char *default_filter_name(void *filter_ctx)
 636 {
 637     AVFilterContext *ctx = filter_ctx;
 638     return ctx->name ? ctx->name : ctx->filter->name;
 639 }
 640
 641 static void *filter_child_next(void *obj, void *prev)
 642 {
 643     AVFilterContext *ctx = obj;
 644     if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
 645         return ctx->priv;
 646     return NULL;
 647 }
 648
 649 static const AVClass *filter_child_class_next(const AVClass *prev)
 650 {
 651     const AVFilter *f = NULL;
 652
 653     /* find the filter that corresponds to prev */
 654     while (prev && (f = avfilter_next(f)))
 655         if (f->priv_class == prev)
 656             break;
 657
 658     /* could not find filter corresponding to prev */
 659     if (prev && !f)
 660         return NULL;
 661
 662     /* find next filter with specific options */
 663     while ((f = avfilter_next(f)))
 664         if (f->priv_class)
 665             return f->priv_class;
 666
 667     return NULL;
 668 }
 669
 670 #define OFFSET(x) offsetof(AVFilterContext, x)
 671 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
 672 static const AVOption avfilter_options[] = {
 673     { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
 674         { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
 675         { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" },
 676     { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
 677     { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
 678         { .i64 = 0 }, 0, INT_MAX, FLAGS },
 679     { NULL },
 680 };
 681
 682 static const AVClass avfilter_class = {
 683     .class_name = "AVFilter",
 684     .item_name  = default_filter_name,
 685     .version    = LIBAVUTIL_VERSION_INT,
 686     .category   = AV_CLASS_CATEGORY_FILTER,
 687     .child_next = filter_child_next,
 688     .child_class_next = filter_child_class_next,
 689     .option           = avfilter_options,
 690 };
 691
 692 static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg,
 693                            int *ret, int nb_jobs)
 694 {
 695     int i;
 696
 697     for (i = 0; i < nb_jobs; i++) {
 698         int r = func(ctx, arg, i, nb_jobs);
 699         if (ret)
 700             ret[i] = r;
 701     }
 702     return 0;
 703 }
 704
 705 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
 706 {
 707     AVFilterContext *ret;
 708     int preinited = 0;
 709
 710     if (!filter)
 711         return NULL;
 712
 713     ret = av_mallocz(sizeof(AVFilterContext));
 714     if (!ret)
 715         return NULL;
 716
 717     ret->av_class = &avfilter_class;
 718     ret->filter   = filter;
 719     ret->name     = inst_name ? av_strdup(inst_name) : NULL;
 720     if (filter->priv_size) {
 721         ret->priv     = av_mallocz(filter->priv_size);
 722         if (!ret->priv)
 723             goto err;
 724     }
 725     if (filter->preinit) {
 726         if (filter->preinit(ret) < 0)
 727             goto err;
 728         preinited = 1;
 729     }
 730
 731     av_opt_set_defaults(ret);
 732     if (filter->priv_class) {
 733         *(const AVClass**)ret->priv = filter->priv_class;
 734         av_opt_set_defaults(ret->priv);
 735     }
 736
 737     ret->internal = av_mallocz(sizeof(*ret->internal));
 738     if (!ret->internal)
 739         goto err;
 740     ret->internal->execute = default_execute;
 741
 742     ret->nb_inputs = avfilter_pad_count(filter->inputs);
 743     if (ret->nb_inputs ) {
 744         ret->input_pads   = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
 745         if (!ret->input_pads)
 746             goto err;
 747         memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
 748         ret->inputs       = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
 749         if (!ret->inputs)
 750             goto err;
 751     }
 752
 753     ret->nb_outputs = avfilter_pad_count(filter->outputs);
 754     if (ret->nb_outputs) {
 755         ret->output_pads  = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
 756         if (!ret->output_pads)
 757             goto err;
 758         memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
 759         ret->outputs      = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
 760         if (!ret->outputs)
 761             goto err;
 762     }
 763
 764     return ret;
 765
 766 err:
 767     if (preinited)
 768         filter->uninit(ret);
 769     av_freep(&ret->inputs);
 770     av_freep(&ret->input_pads);
 771     ret->nb_inputs = 0;
 772     av_freep(&ret->outputs);
 773     av_freep(&ret->output_pads);
 774     ret->nb_outputs = 0;
 775     av_freep(&ret->priv);
 776     av_freep(&ret->internal);
 777     av_free(ret);
 778     return NULL;
 779 }
 780
 781 static void free_link(AVFilterLink *link)
 782 {
 783     if (!link)
 784         return;
 785
 786     if (link->src)
 787         link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
 788     if (link->dst)
 789         link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
 790
 791     av_buffer_unref(&link->hw_frames_ctx);
 792
 793     ff_formats_unref(&link->in_formats);
 794     ff_formats_unref(&link->out_formats);
 795     ff_formats_unref(&link->in_samplerates);
 796     ff_formats_unref(&link->out_samplerates);
 797     ff_channel_layouts_unref(&link->in_channel_layouts);
 798     ff_channel_layouts_unref(&link->out_channel_layouts);
 799     avfilter_link_free(&link);
 800 }
 801
 802 void avfilter_free(AVFilterContext *filter)
 803 {
 804     int i;
 805
 806     if (!filter)
 807         return;
 808
 809     if (filter->graph)
 810         ff_filter_graph_remove_filter(filter->graph, filter);
 811
 812     if (filter->filter->uninit)
 813         filter->filter->uninit(filter);
 814
 815     for (i = 0; i < filter->nb_inputs; i++) {
 816         free_link(filter->inputs[i]);
 817     }
 818     for (i = 0; i < filter->nb_outputs; i++) {
 819         free_link(filter->outputs[i]);
 820     }
 821
 822     if (filter->filter->priv_class)
 823         av_opt_free(filter->priv);
 824
 825     av_buffer_unref(&filter->hw_device_ctx);
 826
 827     av_freep(&filter->name);
 828     av_freep(&filter->input_pads);
 829     av_freep(&filter->output_pads);
 830     av_freep(&filter->inputs);
 831     av_freep(&filter->outputs);
 832     av_freep(&filter->priv);
 833     while(filter->command_queue){
 834         ff_command_queue_pop(filter);
 835     }
 836     av_opt_free(filter);
 837     av_expr_free(filter->enable);
 838     filter->enable = NULL;
 839     av_freep(&filter->var_values);
 840     av_freep(&filter->internal);
 841     av_free(filter);
 842 }
 843
 844 int ff_filter_get_nb_threads(AVFilterContext *ctx)
 845 {
 846      if (ctx->nb_threads > 0)
 847          return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
 848      return ctx->graph->nb_threads;
 849 }
 850
 851 static int process_options(AVFilterContext *ctx, AVDictionary **options,
 852                            const char *args)
 853 {
 854     const AVOption *o = NULL;
 855     int ret, count = 0;
 856     char *av_uninit(parsed_key), *av_uninit(value);
 857     const char *key;
 858     int offset= -1;
 859
 860     if (!args)
 861         return 0;
 862
 863     while (*args) {
 864         const char *shorthand = NULL;
 865
 866         o = av_opt_next(ctx->priv, o);
 867         if (o) {
 868             if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
 869                 continue;
 870             offset = o->offset;
 871             shorthand = o->name;
 872         }
 873
 874         ret = av_opt_get_key_value(&args, "=", ":",
 875                                    shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
 876                                    &parsed_key, &value);
 877         if (ret < 0) {
 878             if (ret == AVERROR(EINVAL))
 879                 av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
 880             else
 881                 av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
 882                        av_err2str(ret));
 883             return ret;
 884         }
 885         if (*args)
 886             args++;
 887         if (parsed_key) {
 888             key = parsed_key;
 889             while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
 890         } else {
 891             key = shorthand;
 892         }
 893
 894         av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
 895
 896         if (av_opt_find(ctx, key, NULL, 0, 0)) {
 897             ret = av_opt_set(ctx, key, value, 0);
 898             if (ret < 0) {
 899                 av_free(value);
 900                 av_free(parsed_key);
 901                 return ret;
 902             }
 903         } else {
 904         av_dict_set(options, key, value, 0);
 905         if ((ret = av_opt_set(ctx->priv, key, value, AV_OPT_SEARCH_CHILDREN)) < 0) {
 906             if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {
 907             if (ret == AVERROR_OPTION_NOT_FOUND)
 908                 av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
 909             av_free(value);
 910             av_free(parsed_key);
 911             return ret;
 912             }
 913         }
 914         }
 915
 916         av_free(value);
 917         av_free(parsed_key);
 918         count++;
 919     }
 920
 921     if (ctx->enable_str) {
 922         ret = set_enable_expr(ctx, ctx->enable_str);
 923         if (ret < 0)
 924             return ret;
 925     }
 926     return count;
 927 }
 928
 929 int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
 930 {
 931     int ret = 0;
 932
 933     ret = av_opt_set_dict(ctx, options);
 934     if (ret < 0) {
 935         av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
 936         return ret;
 937     }
 938
 939     if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
 940         ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
 941         ctx->graph->internal->thread_execute) {
 942         ctx->thread_type       = AVFILTER_THREAD_SLICE;
 943         ctx->internal->execute = ctx->graph->internal->thread_execute;
 944     } else {
 945         ctx->thread_type = 0;
 946     }
 947
 948     if (ctx->filter->priv_class) {
 949         ret = av_opt_set_dict2(ctx->priv, options, AV_OPT_SEARCH_CHILDREN);
 950         if (ret < 0) {
 951             av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
 952             return ret;
 953         }
 954     }
 955
 956     if (ctx->filter->init_opaque)
 957         ret = ctx->filter->init_opaque(ctx, NULL);
 958     else if (ctx->filter->init)
 959         ret = ctx->filter->init(ctx);
 960     else if (ctx->filter->init_dict)
 961         ret = ctx->filter->init_dict(ctx, options);
 962
 963     return ret;
 964 }
 965
 966 int avfilter_init_str(AVFilterContext *filter, const char *args)
 967 {
 968     AVDictionary *options = NULL;
 969     AVDictionaryEntry *e;
 970     int ret = 0;
 971
 972     if (args && *args) {
 973         if (!filter->filter->priv_class) {
 974             av_log(filter, AV_LOG_ERROR, "This filter does not take any "
 975                    "options, but options were provided: %s.\n", args);
 976             return AVERROR(EINVAL);
 977         }
 978
 979 #if FF_API_OLD_FILTER_OPTS_ERROR
 980             if (   !strcmp(filter->filter->name, "format")     ||
 981                    !strcmp(filter->filter->name, "noformat")   ||
 982                    !strcmp(filter->filter->name, "frei0r")     ||
 983                    !strcmp(filter->filter->name, "frei0r_src") ||
 984                    !strcmp(filter->filter->name, "ocv")        ||
 985                    !strcmp(filter->filter->name, "pan")        ||
 986                    !strcmp(filter->filter->name, "pp")         ||
 987                    !strcmp(filter->filter->name, "aevalsrc")) {
 988             /* a hack for compatibility with the old syntax
 989              * replace colons with |s */
 990             char *copy = av_strdup(args);
 991             char *p    = copy;
 992             int nb_leading = 0; // number of leading colons to skip
 993             int deprecated = 0;
 994
 995             if (!copy) {
 996                 ret = AVERROR(ENOMEM);
 997                 goto fail;
 998             }
 999
1000             if (!strcmp(filter->filter->name, "frei0r") ||
1001                 !strcmp(filter->filter->name, "ocv"))
1002                 nb_leading = 1;
1003             else if (!strcmp(filter->filter->name, "frei0r_src"))
1004                 nb_leading = 3;
1005
1006             while (nb_leading--) {
1007                 p = strchr(p, ':');
1008                 if (!p) {
1009                     p = copy + strlen(copy);
1010                     break;
1011                 }
1012                 p++;
1013             }
1014
1015             deprecated = strchr(p, ':') != NULL;
1016
1017             if (!strcmp(filter->filter->name, "aevalsrc")) {
1018                 deprecated = 0;
1019                 while ((p = strchr(p, ':')) && p[1] != ':') {
1020                     const char *epos = strchr(p + 1, '=');
1021                     const char *spos = strchr(p + 1, ':');
1022                     const int next_token_is_opt = epos && (!spos || epos < spos);
1023                     if (next_token_is_opt) {
1024                         p++;
1025                         break;
1026                     }
1027                     /* next token does not contain a '=', assume a channel expression */
1028                     deprecated = 1;
1029                     *p++ = '|';
1030                 }
1031                 if (p && *p == ':') { // double sep '::' found
1032                     deprecated = 1;
1033                     memmove(p, p + 1, strlen(p));
1034                 }
1035             } else
1036             while ((p = strchr(p, ':')))
1037                 *p++ = '|';
1038
1039             if (deprecated) {
1040                 av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "
1041                        "'|' to separate the list items ('%s' instead of '%s')\n",
1042                        copy, args);
1043                 ret = AVERROR(EINVAL);
1044             } else {
1045                 ret = process_options(filter, &options, copy);
1046             }
1047             av_freep(&copy);
1048
1049             if (ret < 0)
1050                 goto fail;
1051         } else
1052 #endif
1053         {
1054             ret = process_options(filter, &options, args);
1055             if (ret < 0)
1056                 goto fail;
1057         }
1058     }
1059
1060     ret = avfilter_init_dict(filter, &options);
1061     if (ret < 0)
1062         goto fail;
1063
1064     if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1065         av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
1066         ret = AVERROR_OPTION_NOT_FOUND;
1067         goto fail;
1068     }
1069
1070 fail:
1071     av_dict_free(&options);
1072
1073     return ret;
1074 }
1075
1076 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
1077 {
1078     return pads[pad_idx].name;
1079 }
1080
1081 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
1082 {
1083     return pads[pad_idx].type;
1084 }
1085
1086 static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
1087 {
1088     return ff_filter_frame(link->dst->outputs[0], frame);
1089 }
1090
1091 static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
1092 {
1093     int (*filter_frame)(AVFilterLink *, AVFrame *);
1094     AVFilterContext *dstctx = link->dst;
1095     AVFilterPad *dst = link->dstpad;
1096     int ret;
1097
1098     if (!(filter_frame = dst->filter_frame))
1099         filter_frame = default_filter_frame;
1100
1101     if (dst->needs_writable) {
1102         ret = ff_inlink_make_frame_writable(link, &frame);
1103         if (ret < 0)
1104             goto fail;
1105     }
1106
1107     ff_inlink_process_commands(link, frame);
1108     dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1109
1110     if (dstctx->is_disabled &&
1111         (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
1112         filter_frame = default_filter_frame;
1113     ret = filter_frame(link, frame);
1114     link->frame_count_out++;
1115     return ret;
1116
1117 fail:
1118     av_frame_free(&frame);
1119     return ret;
1120 }
1121
1122 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1123 {
1124     int ret;
1125     FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
1126
1127     /* Consistency checks */
1128     if (link->type == AVMEDIA_TYPE_VIDEO) {
1129         if (strcmp(link->dst->filter->name, "buffersink") &&
1130             strcmp(link->dst->filter->name, "format") &&
1131             strcmp(link->dst->filter->name, "idet") &&
1132             strcmp(link->dst->filter->name, "null") &&
1133             strcmp(link->dst->filter->name, "scale")) {
1134             av_assert1(frame->format                 == link->format);
1135             av_assert1(frame->width               == link->w);
1136             av_assert1(frame->height               == link->h);
1137         }
1138     } else {
1139         if (frame->format != link->format) {
1140             av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1141             goto error;
1142         }
1143         if (frame->channels != link->channels) {
1144             av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");
1145             goto error;
1146         }
1147         if (frame->channel_layout != link->channel_layout) {
1148             av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1149             goto error;
1150         }
1151         if (frame->sample_rate != link->sample_rate) {
1152             av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1153             goto error;
1154         }
1155     }
1156
1157     link->frame_blocked_in = link->frame_wanted_out = 0;
1158     link->frame_count_in++;
1159     filter_unblock(link->dst);
1160     ret = ff_framequeue_add(&link->fifo, frame);
1161     if (ret < 0) {
1162         av_frame_free(&frame);
1163         return ret;
1164     }
1165     ff_filter_set_ready(link->dst, 300);
1166     return 0;
1167
1168 error:
1169     av_frame_free(&frame);
1170     return AVERROR_PATCHWELCOME;
1171 }
1172
1173 static int samples_ready(AVFilterLink *link, unsigned min)
1174 {
1175     return ff_framequeue_queued_frames(&link->fifo) &&
1176            (ff_framequeue_queued_samples(&link->fifo) >= min ||
1177             link->status_in);
1178 }
1179
1180 static int take_samples(AVFilterLink *link, unsigned min, unsigned max,
1181                         AVFrame **rframe)
1182 {
1183     AVFrame *frame0, *frame, *buf;
1184     unsigned nb_samples, nb_frames, i, p;
1185     int ret;
1186
1187     /* Note: this function relies on no format changes and must only be
1188        called with enough samples. */
1189     av_assert1(samples_ready(link, link->min_samples));
1190     frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
1191     if (!link->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1192         *rframe = ff_framequeue_take(&link->fifo);
1193         return 0;
1194     }
1195     nb_frames = 0;
1196     nb_samples = 0;
1197     while (1) {
1198         if (nb_samples + frame->nb_samples > max) {
1199             if (nb_samples < min)
1200                 nb_samples = max;
1201             break;
1202         }
1203         nb_samples += frame->nb_samples;
1204         nb_frames++;
1205         if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
1206             break;
1207         frame = ff_framequeue_peek(&link->fifo, nb_frames);
1208     }
1209
1210     buf = ff_get_audio_buffer(link, nb_samples);
1211     if (!buf)
1212         return AVERROR(ENOMEM);
1213     ret = av_frame_copy_props(buf, frame0);
1214     if (ret < 0) {
1215         av_frame_free(&buf);
1216         return ret;
1217     }
1218     buf->pts = frame0->pts;
1219
1220     p = 0;
1221     for (i = 0; i < nb_frames; i++) {
1222         frame = ff_framequeue_take(&link->fifo);
1223         av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1224                         frame->nb_samples, link->channels, link->format);
1225         p += frame->nb_samples;
1226         av_frame_free(&frame);
1227     }
1228     if (p < nb_samples) {
1229         unsigned n = nb_samples - p;
1230         frame = ff_framequeue_peek(&link->fifo, 0);
1231         av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1232                         link->channels, link->format);
1233         ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
1234     }
1235
1236     *rframe = buf;
1237     return 0;
1238 }
1239
1240 static int ff_filter_frame_to_filter(AVFilterLink *link)
1241 {
1242     AVFrame *frame = NULL;
1243     AVFilterContext *dst = link->dst;
1244     int ret;
1245
1246     av_assert1(ff_framequeue_queued_frames(&link->fifo));
1247     ret = link->min_samples ?
1248           ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1249           ff_inlink_consume_frame(link, &frame);
1250     av_assert1(ret);
1251     if (ret < 0) {
1252         av_assert1(!frame);
1253         return ret;
1254     }
1255     /* The filter will soon have received a new frame, that may allow it to
1256        produce one or more: unblock its outputs. */
1257     filter_unblock(dst);
1258     /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1259        before the frame; ff_filter_frame_framed() will re-increment it. */
1260     link->frame_count_out--;
1261     ret = ff_filter_frame_framed(link, frame);
1262     if (ret < 0 && ret != link->status_out) {
1263         ff_avfilter_link_set_out_status(link, ret, AV_NOPTS_VALUE);
1264     } else {
1265         /* Run once again, to see if several frames were available, or if
1266            the input status has also changed, or any other reason. */
1267         ff_filter_set_ready(dst, 300);
1268     }
1269     return ret;
1270 }
1271
1272 static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
1273 {
1274     unsigned out = 0, progress = 0;
1275     int ret;
1276
1277     av_assert0(!in->status_out);
1278     if (!filter->nb_outputs) {
1279         /* not necessary with the current API and sinks */
1280         return 0;
1281     }
1282     while (!in->status_out) {
1283         if (!filter->outputs[out]->status_in) {
1284             progress++;
1285             ret = ff_request_frame_to_filter(filter->outputs[out]);
1286             if (ret < 0)
1287                 return ret;
1288         }
1289         if (++out == filter->nb_outputs) {
1290             if (!progress) {
1291                 /* Every output already closed: input no longer interesting
1292                    (example: overlay in shortest mode, other input closed). */
1293                 ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
1294                 return 0;
1295             }
1296             progress = 0;
1297             out = 0;
1298         }
1299     }
1300     ff_filter_set_ready(filter, 200);
1301     return 0;
1302 }
1303
1304 static int ff_filter_activate_default(AVFilterContext *filter)
1305 {
1306     unsigned i;
1307
1308     for (i = 0; i < filter->nb_inputs; i++) {
1309         if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1310             return ff_filter_frame_to_filter(filter->inputs[i]);
1311         }
1312     }
1313     for (i = 0; i < filter->nb_inputs; i++) {
1314         if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1315             av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1316             return forward_status_change(filter, filter->inputs[i]);
1317         }
1318     }
1319     for (i = 0; i < filter->nb_outputs; i++) {
1320         if (filter->outputs[i]->frame_wanted_out &&
1321             !filter->outputs[i]->frame_blocked_in) {
1322             return ff_request_frame_to_filter(filter->outputs[i]);
1323         }
1324     }
1325     return FFERROR_NOT_READY;
1326 }
1327
1328 /*
1329    Filter scheduling and activation
1330
1331    When a filter is activated, it must:
1332    - if possible, output a frame;
1333    - else, if relevant, forward the input status change;
1334    - else, check outputs for wanted frames and forward the requests.
1335
1336    The following AVFilterLink fields are used for activation:
1337
1338    - frame_wanted_out:
1339
1340      This field indicates if a frame is needed on this input of the
1341      destination filter. A positive value indicates that a frame is needed
1342      to process queued frames or internal data or to satisfy the
1343      application; a zero value indicates that a frame is not especially
1344      needed but could be processed anyway; a negative value indicates that a
1345      frame would just be queued.
1346
1347      It is set by filters using ff_request_frame() or ff_request_no_frame(),
1348      when requested by the application through a specific API or when it is
1349      set on one of the outputs.
1350
1351      It is cleared when a frame is sent from the source using
1352      ff_filter_frame().
1353
1354      It is also cleared when a status change is sent from the source using
1355      ff_avfilter_link_set_in_status().
1356
1357    - frame_blocked_in:
1358
1359      This field means that the source filter can not generate a frame as is.
1360      Its goal is to avoid repeatedly calling the request_frame() method on
1361      the same link.
1362
1363      It is set by the framework on all outputs of a filter before activating it.
1364
1365      It is automatically cleared by ff_filter_frame().
1366
1367      It is also automatically cleared by ff_avfilter_link_set_in_status().
1368
1369      It is also cleared on all outputs (using filter_unblock()) when
1370      something happens on an input: processing a frame or changing the
1371      status.
1372
1373    - fifo:
1374
1375      Contains the frames queued on a filter input. If it contains frames and
1376      frame_wanted_out is not set, then the filter can be activated. If that
1377      result in the filter not able to use these frames, the filter must set
1378      frame_wanted_out to ask for more frames.
1379
1380    - status_in and status_in_pts:
1381
1382      Status (EOF or error code) of the link and timestamp of the status
1383      change (in link time base, same as frames) as seen from the input of
1384      the link. The status change is considered happening after the frames
1385      queued in fifo.
1386
1387      It is set by the source filter using ff_avfilter_link_set_in_status().
1388
1389    - status_out:
1390
1391      Status of the link as seen from the output of the link. The status
1392      change is considered having already happened.
1393
1394      It is set by the destination filter using
1395      ff_avfilter_link_set_out_status().
1396
1397    Filters are activated according to the ready field, set using the
1398    ff_filter_set_ready(). Eventually, a priority queue will be used.
1399    ff_filter_set_ready() is called whenever anything could cause progress to
1400    be possible. Marking a filter ready when it is not is not a problem,
1401    except for the small overhead it causes.
1402
1403    Conditions that cause a filter to be marked ready are:
1404
1405    - frames added on an input link;
1406
1407    - changes in the input or output status of an input link;
1408
1409    - requests for a frame on an output link;
1410
1411    - after any actual processing using the legacy methods (filter_frame(),
1412      and request_frame() to acknowledge status changes), to run once more
1413      and check if enough input was present for several frames.
1414
1415    Exemples of scenarios to consider:
1416
1417    - buffersrc: activate if frame_wanted_out to notify the application;
1418      activate when the application adds a frame to push it immediately.
1419
1420    - testsrc: activate only if frame_wanted_out to produce and push a frame.
1421
1422    - concat (not at stitch points): can process a frame on any output.
1423      Activate if frame_wanted_out on output to forward on the corresponding
1424      input. Activate when a frame is present on input to process it
1425      immediately.
1426
1427    - framesync: needs at least one frame on each input; extra frames on the
1428      wrong input will accumulate. When a frame is first added on one input,
1429      set frame_wanted_out<0 on it to avoid getting more (would trigger
1430      testsrc) and frame_wanted_out>0 on the other to allow processing it.
1431
1432    Activation of old filters:
1433
1434    In order to activate a filter implementing the legacy filter_frame() and
1435    request_frame() methods, perform the first possible of the following
1436    actions:
1437
1438    - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1439      frame and call filter_frame().
1440
1441      Ratinale: filter frames as soon as possible instead of leaving them
1442      queued; frame_wanted_out < 0 is not possible since the old API does not
1443      set it nor provides any similar feedback; frame_wanted_out > 0 happens
1444      when min_samples > 0 and there are not enough samples queued.
1445
1446    - If an input has status_in set but not status_out, try to call
1447      request_frame() on one of the outputs in the hope that it will trigger
1448      request_frame() on the input with status_in and acknowledge it. This is
1449      awkward and fragile, filters with several inputs or outputs should be
1450      updated to direct activation as soon as possible.
1451
1452    - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1453      request_frame().
1454
1455      Rationale: checking frame_blocked_in is necessary to avoid requesting
1456      repeatedly on a blocked input if another is not blocked (example:
1457      [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1458
1459      TODO: respect needs_fifo and remove auto-inserted fifos.
1460
1461  */
1462
1463 int ff_filter_activate(AVFilterContext *filter)
1464 {
1465     int ret;
1466
1467     /* Generic timeline support is not yet implemented but should be easy */
1468     av_assert1(!(filter->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
1469                  filter->filter->activate));
1470     filter->ready = 0;
1471     ret = filter->filter->activate ? filter->filter->activate(filter) :
1472           ff_filter_activate_default(filter);
1473     if (ret == FFERROR_NOT_READY)
1474         ret = 0;
1475     return ret;
1476 }
1477
1478 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1479 {
1480     *rpts = link->current_pts;
1481     if (ff_framequeue_queued_frames(&link->fifo))
1482         return *rstatus = 0;
1483     if (link->status_out)
1484         return *rstatus = link->status_out;
1485     if (!link->status_in)
1486         return *rstatus = 0;
1487     *rstatus = link->status_out = link->status_in;
1488     ff_update_link_current_pts(link, link->status_in_pts);
1489     *rpts = link->current_pts;
1490     return 1;
1491 }
1492
1493 int ff_inlink_check_available_frame(AVFilterLink *link)
1494 {
1495     return ff_framequeue_queued_frames(&link->fifo) > 0;
1496 }
1497
1498 int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1499 {
1500     uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1501     av_assert1(min);
1502     return samples >= min || (link->status_in && samples);
1503 }
1504
1505 static void consume_update(AVFilterLink *link, const AVFrame *frame)
1506 {
1507     ff_update_link_current_pts(link, frame->pts);
1508     ff_inlink_process_commands(link, frame);
1509     link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1510     link->frame_count_out++;
1511 }
1512
1513 int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1514 {
1515     AVFrame *frame;
1516
1517     *rframe = NULL;
1518     if (!ff_inlink_check_available_frame(link))
1519         return 0;
1520
1521     if (link->fifo.samples_skipped) {
1522         frame = ff_framequeue_peek(&link->fifo, 0);
1523         return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1524     }
1525
1526     frame = ff_framequeue_take(&link->fifo);
1527     consume_update(link, frame);
1528     *rframe = frame;
1529     return 1;
1530 }
1531
1532 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1533                             AVFrame **rframe)
1534 {
1535     AVFrame *frame;
1536     int ret;
1537
1538     av_assert1(min);
1539     *rframe = NULL;
1540     if (!ff_inlink_check_available_samples(link, min))
1541         return 0;
1542     if (link->status_in)
1543         min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
1544     ret = take_samples(link, min, max, &frame);
1545     if (ret < 0)
1546         return ret;
1547     consume_update(link, frame);
1548     *rframe = frame;
1549     return 1;
1550 }
1551
1552 int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1553 {
1554     AVFrame *frame = *rframe;
1555     AVFrame *out;
1556     int ret;
1557
1558     if (av_frame_is_writable(frame))
1559         return 0;
1560     av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1561
1562     switch (link->type) {
1563     case AVMEDIA_TYPE_VIDEO:
1564         out = ff_get_video_buffer(link, link->w, link->h);
1565         break;
1566     case AVMEDIA_TYPE_AUDIO:
1567         out = ff_get_audio_buffer(link, frame->nb_samples);
1568         break;
1569     default:
1570         return AVERROR(EINVAL);
1571     }
1572     if (!out)
1573         return AVERROR(ENOMEM);
1574
1575     ret = av_frame_copy_props(out, frame);
1576     if (ret < 0) {
1577         av_frame_free(&out);
1578         return ret;
1579     }
1580
1581     switch (link->type) {
1582     case AVMEDIA_TYPE_VIDEO:
1583         av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1584                       frame->format, frame->width, frame->height);
1585         break;
1586     case AVMEDIA_TYPE_AUDIO:
1587         av_samples_copy(out->extended_data, frame->extended_data,
1588                         0, 0, frame->nb_samples,
1589                         frame->channels,
1590                         frame->format);
1591         break;
1592     default:
1593         av_assert0(!"reached");
1594     }
1595
1596     av_frame_free(&frame);
1597     *rframe = out;
1598     return 0;
1599 }
1600
1601 int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1602 {
1603     AVFilterCommand *cmd = link->dst->command_queue;
1604
1605     while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1606         av_log(link->dst, AV_LOG_DEBUG,
1607                "Processing command time:%f command:%s arg:%s\n",
1608                cmd->time, cmd->command, cmd->arg);
1609         avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1610         ff_command_queue_pop(link->dst);
1611         cmd= link->dst->command_queue;
1612     }
1613     return 0;
1614 }
1615
1616 int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1617 {
1618     AVFilterContext *dstctx = link->dst;
1619     int64_t pts = frame->pts;
1620     int64_t pos = frame->pkt_pos;
1621
1622     if (!dstctx->enable_str)
1623         return 1;
1624
1625     dstctx->var_values[VAR_N] = link->frame_count_out;
1626     dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1627     dstctx->var_values[VAR_W] = link->w;
1628     dstctx->var_values[VAR_H] = link->h;
1629     dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1630
1631     return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1632 }
1633
1634 void ff_inlink_request_frame(AVFilterLink *link)
1635 {
1636     av_assert1(!link->status_in);
1637     av_assert1(!link->status_out);
1638     link->frame_wanted_out = 1;
1639     ff_filter_set_ready(link->src, 100);
1640 }
1641
1642 void ff_inlink_set_status(AVFilterLink *link, int status)
1643 {
1644     if (link->status_out)
1645         return;
1646     link->frame_wanted_out = 0;
1647     link->frame_blocked_in = 0;
1648     ff_avfilter_link_set_out_status(link, status, AV_NOPTS_VALUE);
1649     while (ff_framequeue_queued_frames(&link->fifo)) {
1650            AVFrame *frame = ff_framequeue_take(&link->fifo);
1651            av_frame_free(&frame);
1652     }
1653     if (!link->status_in)
1654         link->status_in = status;
1655 }
1656
1657 int ff_outlink_get_status(AVFilterLink *link)
1658 {
1659     return link->status_in;
1660 }
1661
1662 const AVClass *avfilter_get_class(void)
1663 {
1664     return &avfilter_class;
1665 }