diff options
Diffstat (limited to 'ffmpeg/libavfilter/avfilter.c')
| -rw-r--r-- | ffmpeg/libavfilter/avfilter.c | 603 |
1 files changed, 490 insertions, 113 deletions
diff --git a/ffmpeg/libavfilter/avfilter.c b/ffmpeg/libavfilter/avfilter.c index 8a907dc..2567ce9 100644 --- a/ffmpeg/libavfilter/avfilter.c +++ b/ffmpeg/libavfilter/avfilter.c @@ -19,11 +19,14 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include "libavutil/atomic.h" #include "libavutil/avassert.h" #include "libavutil/avstring.h" #include "libavutil/channel_layout.h" #include "libavutil/common.h" +#include "libavutil/eval.h" #include "libavutil/imgutils.h" +#include "libavutil/internal.h" #include "libavutil/opt.h" #include "libavutil/pixdesc.h" #include "libavutil/rational.h" @@ -33,7 +36,6 @@ #include "avfilter.h" #include "formats.h" #include "internal.h" -#include "audio.h" static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame); @@ -65,7 +67,8 @@ void ff_tlog_ref(void *ctx, AVFrame *ref, int end) ff_tlog(ctx, "]%s", end ? "\n" : ""); } -unsigned avfilter_version(void) { +unsigned avfilter_version(void) +{ av_assert0(LIBAVFILTER_VERSION_MICRO >= 100); return LIBAVFILTER_VERSION_INT; } @@ -90,25 +93,36 @@ void ff_command_queue_pop(AVFilterContext *filter) av_free(c); } -void ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, +int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, AVFilterPad **pads, AVFilterLink ***links, AVFilterPad *newpad) { + AVFilterLink **newlinks; + AVFilterPad *newpads; unsigned i; idx = FFMIN(idx, *count); - *pads = av_realloc(*pads, sizeof(AVFilterPad) * (*count + 1)); - *links = av_realloc(*links, sizeof(AVFilterLink*) * (*count + 1)); - memmove(*pads +idx+1, *pads +idx, sizeof(AVFilterPad) * (*count-idx)); - memmove(*links+idx+1, *links+idx, sizeof(AVFilterLink*) * (*count-idx)); - memcpy(*pads+idx, newpad, sizeof(AVFilterPad)); + newpads = av_realloc_array(*pads, *count + 1, sizeof(AVFilterPad)); + newlinks = av_realloc_array(*links, *count + 1, sizeof(AVFilterLink*)); + if (newpads) + *pads = newpads; + if (newlinks) + *links = newlinks; + if (!newpads || !newlinks) + return AVERROR(ENOMEM); + + memmove(*pads + idx + 1, *pads + idx, sizeof(AVFilterPad) * (*count - idx)); + memmove(*links + idx + 1, *links + idx, sizeof(AVFilterLink*) * (*count - idx)); + memcpy(*pads + idx, newpad, sizeof(AVFilterPad)); (*links)[idx] = NULL; (*count)++; - for (i = idx+1; i < *count; i++) - if (*links[i]) - (*(unsigned *)((uint8_t *) *links[i] + padidx_off))++; + for (i = idx + 1; i < *count; i++) + if ((*links)[i]) + (*(unsigned *)((uint8_t *) (*links)[i] + padidx_off))++; + + return 0; } int avfilter_link(AVFilterContext *src, unsigned srcpad, @@ -128,8 +142,11 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad, return AVERROR(EINVAL); } - src->outputs[srcpad] = - dst-> inputs[dstpad] = link = av_mallocz(sizeof(AVFilterLink)); + link = av_mallocz(sizeof(*link)); + if (!link) + return AVERROR(ENOMEM); + + src->outputs[srcpad] = dst->inputs[dstpad] = link; link->src = src; link->dst = dst; @@ -180,19 +197,18 @@ int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, } /* re-hookup the link to the new destination filter we inserted */ - link->dst = filt; - link->dstpad = &filt->input_pads[filt_srcpad_idx]; + link->dst = filt; + link->dstpad = &filt->input_pads[filt_srcpad_idx]; filt->inputs[filt_srcpad_idx] = link; /* if any information on supported media formats already exists on the * link, we need to preserve that */ if (link->out_formats) ff_formats_changeref(&link->out_formats, - &filt->outputs[filt_dstpad_idx]->out_formats); - + &filt->outputs[filt_dstpad_idx]->out_formats); if (link->out_samplerates) ff_formats_changeref(&link->out_samplerates, - &filt->outputs[filt_dstpad_idx]->out_samplerates); + &filt->outputs[filt_dstpad_idx]->out_samplerates); if (link->out_channel_layouts) ff_channel_layouts_changeref(&link->out_channel_layouts, &filt->outputs[filt_dstpad_idx]->out_channel_layouts); @@ -323,17 +339,27 @@ int ff_request_frame(AVFilterLink *link) if (link->closed) return AVERROR_EOF; - if (link->srcpad->request_frame) - ret = link->srcpad->request_frame(link); - else if (link->src->inputs[0]) - ret = ff_request_frame(link->src->inputs[0]); - if (ret == AVERROR_EOF && link->partial_buf) { - AVFrame *pbuf = link->partial_buf; - link->partial_buf = NULL; - ret = ff_filter_frame_framed(link, pbuf); - } - if (ret == AVERROR_EOF) - link->closed = 1; + av_assert0(!link->frame_requested); + link->frame_requested = 1; + while (link->frame_requested) { + if (link->srcpad->request_frame) + ret = link->srcpad->request_frame(link); + else if (link->src->inputs[0]) + ret = ff_request_frame(link->src->inputs[0]); + if (ret == AVERROR_EOF && link->partial_buf) { + AVFrame *pbuf = link->partial_buf; + link->partial_buf = NULL; + ret = ff_filter_frame_framed(link, pbuf); + } + if (ret < 0) { + link->frame_requested = 0; + if (ret == AVERROR_EOF) + link->closed = 1; + } else { + av_assert0(!link->frame_requested || + link->flags & FF_LINK_FLAG_REQUEST_LOOP); + } + } return ret; } @@ -355,6 +381,49 @@ int ff_poll_frame(AVFilterLink *link) return min; } +static const char *const var_names[] = { "t", "n", "pos", NULL }; +enum { VAR_T, VAR_N, VAR_POS, VAR_VARS_NB }; + +static int set_enable_expr(AVFilterContext *ctx, const char *expr) +{ + int ret; + char *expr_dup; + AVExpr *old = ctx->enable; + + if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) { + av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported " + "with filter '%s'\n", ctx->filter->name); + return AVERROR_PATCHWELCOME; + } + + expr_dup = av_strdup(expr); + if (!expr_dup) + return AVERROR(ENOMEM); + + if (!ctx->var_values) { + ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values)); + if (!ctx->var_values) { + av_free(expr_dup); + return AVERROR(ENOMEM); + } + } + + ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names, + NULL, NULL, NULL, NULL, 0, ctx->priv); + if (ret < 0) { + av_log(ctx->priv, AV_LOG_ERROR, + "Error when evaluating the expression '%s' for enable\n", + expr_dup); + av_free(expr_dup); + return ret; + } + + av_expr_free(old); + av_free(ctx->enable_str); + ctx->enable_str = expr_dup; + return 0; +} + void ff_update_link_current_pts(AVFilterLink *link, int64_t pts) { if (pts == AV_NOPTS_VALUE) @@ -368,42 +437,50 @@ void ff_update_link_current_pts(AVFilterLink *link, int64_t pts) int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags) { if(!strcmp(cmd, "ping")){ + char local_res[256] = {0}; + + if (!res) { + res = local_res; + res_len = sizeof(local_res); + } av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name); + if (res == local_res) + av_log(filter, AV_LOG_INFO, "%s", res); return 0; + }else if(!strcmp(cmd, "enable")) { + return set_enable_expr(filter, arg); }else if(filter->filter->process_command) { return filter->filter->process_command(filter, cmd, arg, res, res_len, flags); } return AVERROR(ENOSYS); } -#define MAX_REGISTERED_AVFILTERS_NB 256 - -static AVFilter *registered_avfilters[MAX_REGISTERED_AVFILTERS_NB + 1]; - -static int next_registered_avfilter_idx = 0; +static AVFilter *first_filter; +#if !FF_API_NOCONST_GET_NAME +const +#endif AVFilter *avfilter_get_by_name(const char *name) { - int i; + const AVFilter *f = NULL; - for (i = 0; registered_avfilters[i]; i++) - if (!strcmp(registered_avfilters[i]->name, name)) - return registered_avfilters[i]; + if (!name) + return NULL; + + while ((f = avfilter_next(f))) + if (!strcmp(f->name, name)) + return (AVFilter *)f; return NULL; } int avfilter_register(AVFilter *filter) { + AVFilter **f = &first_filter; int i; - if (next_registered_avfilter_idx == MAX_REGISTERED_AVFILTERS_NB) { - av_log(NULL, AV_LOG_ERROR, - "Maximum number of registered filters %d reached, " - "impossible to register filter with name '%s'\n", - MAX_REGISTERED_AVFILTERS_NB, filter->name); - return AVERROR(ENOMEM); - } + /* the filter must select generic or internal exclusively */ + av_assert0((filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE) != AVFILTER_FLAG_SUPPORT_TIMELINE); for(i=0; filter->inputs && filter->inputs[i].name; i++) { const AVFilterPad *input = &filter->inputs[i]; @@ -411,29 +488,39 @@ int avfilter_register(AVFilter *filter) || (!input->start_frame && !input->end_frame)); } - registered_avfilters[next_registered_avfilter_idx++] = filter; + filter->next = NULL; + + while(*f || avpriv_atomic_ptr_cas((void * volatile *)f, NULL, filter)) + f = &(*f)->next; + return 0; } +const AVFilter *avfilter_next(const AVFilter *prev) +{ + return prev ? prev->next : first_filter; +} + +#if FF_API_OLD_FILTER_REGISTER AVFilter **av_filter_next(AVFilter **filter) { - return filter ? ++filter : ®istered_avfilters[0]; + return filter ? &(*filter)->next : &first_filter; } void avfilter_uninit(void) { - memset(registered_avfilters, 0, sizeof(registered_avfilters)); - next_registered_avfilter_idx = 0; } +#endif -static int pad_count(const AVFilterPad *pads) +int avfilter_pad_count(const AVFilterPad *pads) { int count; if (!pads) return 0; - for(count = 0; pads->name; count ++) pads ++; + for (count = 0; pads->name; count++) + pads++; return count; } @@ -446,31 +533,42 @@ static const char *default_filter_name(void *filter_ctx) static void *filter_child_next(void *obj, void *prev) { AVFilterContext *ctx = obj; - if (!prev && ctx->filter && ctx->filter->priv_class) + if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv) return ctx->priv; return NULL; } static const AVClass *filter_child_class_next(const AVClass *prev) { - AVFilter **filter_ptr = NULL; + const AVFilter *f = NULL; /* find the filter that corresponds to prev */ - while (prev && *(filter_ptr = av_filter_next(filter_ptr))) - if ((*filter_ptr)->priv_class == prev) + while (prev && (f = avfilter_next(f))) + if (f->priv_class == prev) break; /* could not find filter corresponding to prev */ - if (prev && !(*filter_ptr)) + if (prev && !f) return NULL; /* find next filter with specific options */ - while (*(filter_ptr = av_filter_next(filter_ptr))) - if ((*filter_ptr)->priv_class) - return (*filter_ptr)->priv_class; + while ((f = avfilter_next(f))) + if (f->priv_class) + return f->priv_class; + return NULL; } +#define OFFSET(x) offsetof(AVFilterContext, x) +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM +static const AVOption avfilter_options[] = { + { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS, + { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" }, + { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" }, + { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS }, + { NULL }, +}; + static const AVClass avfilter_class = { .class_name = "AVFilter", .item_name = default_filter_name, @@ -478,24 +576,32 @@ static const AVClass avfilter_class = { .category = AV_CLASS_CATEGORY_FILTER, .child_next = filter_child_next, .child_class_next = filter_child_class_next, + .option = avfilter_options, }; -const AVClass *avfilter_get_class(void) +static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, + int *ret, int nb_jobs) { - return &avfilter_class; + int i; + + for (i = 0; i < nb_jobs; i++) { + int r = func(ctx, arg, i, nb_jobs); + if (ret) + ret[i] = r; + } + return 0; } -int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name) +AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name) { AVFilterContext *ret; - *filter_ctx = NULL; if (!filter) - return AVERROR(EINVAL); + return NULL; ret = av_mallocz(sizeof(AVFilterContext)); if (!ret) - return AVERROR(ENOMEM); + return NULL; ret->av_class = &avfilter_class; ret->filter = filter; @@ -506,7 +612,18 @@ int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *in goto err; } - ret->nb_inputs = pad_count(filter->inputs); + av_opt_set_defaults(ret); + if (filter->priv_class) { + *(const AVClass**)ret->priv = filter->priv_class; + av_opt_set_defaults(ret->priv); + } + + ret->internal = av_mallocz(sizeof(*ret->internal)); + if (!ret->internal) + goto err; + ret->internal->execute = default_execute; + + ret->nb_inputs = avfilter_pad_count(filter->inputs); if (ret->nb_inputs ) { ret->input_pads = av_malloc(sizeof(AVFilterPad) * ret->nb_inputs); if (!ret->input_pads) @@ -517,7 +634,7 @@ int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *in goto err; } - ret->nb_outputs = pad_count(filter->outputs); + ret->nb_outputs = avfilter_pad_count(filter->outputs); if (ret->nb_outputs) { ret->output_pads = av_malloc(sizeof(AVFilterPad) * ret->nb_outputs); if (!ret->output_pads) @@ -528,12 +645,13 @@ int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *in goto err; } #if FF_API_FOO_COUNT +FF_DISABLE_DEPRECATION_WARNINGS ret->output_count = ret->nb_outputs; ret->input_count = ret->nb_inputs; +FF_ENABLE_DEPRECATION_WARNINGS #endif - *filter_ctx = ret; - return 0; + return ret; err: av_freep(&ret->inputs); @@ -543,50 +661,61 @@ err: av_freep(&ret->output_pads); ret->nb_outputs = 0; av_freep(&ret->priv); + av_freep(&ret->internal); av_free(ret); - return AVERROR(ENOMEM); + return NULL; +} + +#if FF_API_AVFILTER_OPEN +int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name) +{ + *filter_ctx = ff_filter_alloc(filter, inst_name); + return *filter_ctx ? 0 : AVERROR(ENOMEM); +} +#endif + +static void free_link(AVFilterLink *link) +{ + if (!link) + return; + + if (link->src) + link->src->outputs[link->srcpad - link->src->output_pads] = NULL; + if (link->dst) + link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL; + + ff_formats_unref(&link->in_formats); + ff_formats_unref(&link->out_formats); + ff_formats_unref(&link->in_samplerates); + ff_formats_unref(&link->out_samplerates); + ff_channel_layouts_unref(&link->in_channel_layouts); + ff_channel_layouts_unref(&link->out_channel_layouts); + avfilter_link_free(&link); } void avfilter_free(AVFilterContext *filter) { int i; - AVFilterLink *link; if (!filter) return; + if (filter->graph) + ff_filter_graph_remove_filter(filter->graph, filter); + if (filter->filter->uninit) filter->filter->uninit(filter); - if (filter->filter->shorthand) - av_opt_free(filter->priv); for (i = 0; i < filter->nb_inputs; i++) { - if ((link = filter->inputs[i])) { - if (link->src) - link->src->outputs[link->srcpad - link->src->output_pads] = NULL; - ff_formats_unref(&link->in_formats); - ff_formats_unref(&link->out_formats); - ff_formats_unref(&link->in_samplerates); - ff_formats_unref(&link->out_samplerates); - ff_channel_layouts_unref(&link->in_channel_layouts); - ff_channel_layouts_unref(&link->out_channel_layouts); - } - avfilter_link_free(&link); + free_link(filter->inputs[i]); } for (i = 0; i < filter->nb_outputs; i++) { - if ((link = filter->outputs[i])) { - if (link->dst) - link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL; - ff_formats_unref(&link->in_formats); - ff_formats_unref(&link->out_formats); - ff_formats_unref(&link->in_samplerates); - ff_formats_unref(&link->out_samplerates); - ff_channel_layouts_unref(&link->in_channel_layouts); - ff_channel_layouts_unref(&link->out_channel_layouts); - } - avfilter_link_free(&link); + free_link(filter->outputs[i]); } + if (filter->filter->priv_class) + av_opt_free(filter->priv); + av_freep(&filter->name); av_freep(&filter->input_pads); av_freep(&filter->output_pads); @@ -596,37 +725,264 @@ void avfilter_free(AVFilterContext *filter) while(filter->command_queue){ ff_command_queue_pop(filter); } + av_opt_free(filter); + av_expr_free(filter->enable); + filter->enable = NULL; + av_freep(&filter->var_values); + av_freep(&filter->internal); av_free(filter); } -int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque) +static int process_options(AVFilterContext *ctx, AVDictionary **options, + const char *args) { - int ret=0; + const AVOption *o = NULL; + int ret, count = 0; + char *av_uninit(parsed_key), *av_uninit(value); + const char *key; + int offset= -1; + + if (!args) + return 0; + + while (*args) { + const char *shorthand = NULL; + + o = av_opt_next(ctx->priv, o); + if (o) { + if (o->type == AV_OPT_TYPE_CONST || o->offset == offset) + continue; + offset = o->offset; + shorthand = o->name; + } + + ret = av_opt_get_key_value(&args, "=", ":", + shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0, + &parsed_key, &value); + if (ret < 0) { + if (ret == AVERROR(EINVAL)) + av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args); + else + av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args, + av_err2str(ret)); + return ret; + } + if (*args) + args++; + if (parsed_key) { + key = parsed_key; + while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */ + } else { + key = shorthand; + } + + av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value); + + if (av_opt_find(ctx, key, NULL, 0, 0)) { + ret = av_opt_set(ctx, key, value, 0); + if (ret < 0) { + av_free(value); + av_free(parsed_key); + return ret; + } + } else { + av_dict_set(options, key, value, 0); + if ((ret = av_opt_set(ctx->priv, key, value, 0)) < 0) { + if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) { + if (ret == AVERROR_OPTION_NOT_FOUND) + av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key); + av_free(value); + av_free(parsed_key); + return ret; + } + } + } - if (filter->filter->shorthand) { - av_assert0(filter->priv); - av_assert0(filter->filter->priv_class); - *(const AVClass **)filter->priv = filter->filter->priv_class; - av_opt_set_defaults(filter->priv); - ret = av_opt_set_from_string(filter->priv, args, - filter->filter->shorthand, "=", ":"); + av_free(value); + av_free(parsed_key); + count++; + } + + if (ctx->enable_str) { + ret = set_enable_expr(ctx, ctx->enable_str); if (ret < 0) return ret; - args = NULL; } - if (filter->filter->init_opaque) - ret = filter->filter->init_opaque(filter, args, opaque); - else if (filter->filter->init) - ret = filter->filter->init(filter, args); + return count; +} + +#if FF_API_AVFILTER_INIT_FILTER +int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque) +{ + return avfilter_init_str(filter, args); +} +#endif + +int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options) +{ + int ret = 0; + + ret = av_opt_set_dict(ctx, options); + if (ret < 0) { + av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n"); + return ret; + } + + if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS && + ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE && + ctx->graph->internal->thread_execute) { + ctx->thread_type = AVFILTER_THREAD_SLICE; + ctx->internal->execute = ctx->graph->internal->thread_execute; + } else { + ctx->thread_type = 0; + } + + if (ctx->filter->priv_class) { + ret = av_opt_set_dict(ctx->priv, options); + if (ret < 0) { + av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n"); + return ret; + } + } + + if (ctx->filter->init_opaque) + ret = ctx->filter->init_opaque(ctx, NULL); + else if (ctx->filter->init) + ret = ctx->filter->init(ctx); + else if (ctx->filter->init_dict) + ret = ctx->filter->init_dict(ctx, options); + + return ret; +} + +int avfilter_init_str(AVFilterContext *filter, const char *args) +{ + AVDictionary *options = NULL; + AVDictionaryEntry *e; + int ret = 0; + + if (args && *args) { + if (!filter->filter->priv_class) { + av_log(filter, AV_LOG_ERROR, "This filter does not take any " + "options, but options were provided: %s.\n", args); + return AVERROR(EINVAL); + } + +#if FF_API_OLD_FILTER_OPTS + if ( !strcmp(filter->filter->name, "format") || + !strcmp(filter->filter->name, "noformat") || + !strcmp(filter->filter->name, "frei0r") || + !strcmp(filter->filter->name, "frei0r_src") || + !strcmp(filter->filter->name, "ocv") || + !strcmp(filter->filter->name, "pan") || + !strcmp(filter->filter->name, "pp") || + !strcmp(filter->filter->name, "aevalsrc")) { + /* a hack for compatibility with the old syntax + * replace colons with |s */ + char *copy = av_strdup(args); + char *p = copy; + int nb_leading = 0; // number of leading colons to skip + int deprecated = 0; + + if (!copy) { + ret = AVERROR(ENOMEM); + goto fail; + } + + if (!strcmp(filter->filter->name, "frei0r") || + !strcmp(filter->filter->name, "ocv")) + nb_leading = 1; + else if (!strcmp(filter->filter->name, "frei0r_src")) + nb_leading = 3; + + while (nb_leading--) { + p = strchr(p, ':'); + if (!p) { + p = copy + strlen(copy); + break; + } + p++; + } + + deprecated = strchr(p, ':') != NULL; + + if (!strcmp(filter->filter->name, "aevalsrc")) { + deprecated = 0; + while ((p = strchr(p, ':')) && p[1] != ':') { + const char *epos = strchr(p + 1, '='); + const char *spos = strchr(p + 1, ':'); + const int next_token_is_opt = epos && (!spos || epos < spos); + if (next_token_is_opt) { + p++; + break; + } + /* next token does not contain a '=', assume a channel expression */ + deprecated = 1; + *p++ = '|'; + } + if (p && *p == ':') { // double sep '::' found + deprecated = 1; + memmove(p, p + 1, strlen(p)); + } + } else + while ((p = strchr(p, ':'))) + *p++ = '|'; + + if (deprecated) + av_log(filter, AV_LOG_WARNING, "This syntax is deprecated. Use " + "'|' to separate the list items.\n"); + + av_log(filter, AV_LOG_DEBUG, "compat: called with args=[%s]\n", copy); + ret = process_options(filter, &options, copy); + av_freep(©); + + if (ret < 0) + goto fail; +#endif + } else { +#if CONFIG_MP_FILTER + if (!strcmp(filter->filter->name, "mp")) { + char *escaped; + + if (!strncmp(args, "filter=", 7)) + args += 7; + ret = av_escape(&escaped, args, ":=", AV_ESCAPE_MODE_BACKSLASH, 0); + if (ret < 0) { + av_log(filter, AV_LOG_ERROR, "Unable to escape MPlayer filters arg '%s'\n", args); + goto fail; + } + ret = process_options(filter, &options, escaped); + av_free(escaped); + } else +#endif + ret = process_options(filter, &options, args); + if (ret < 0) + goto fail; + } + } + + ret = avfilter_init_dict(filter, &options); + if (ret < 0) + goto fail; + + if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) { + av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key); + ret = AVERROR_OPTION_NOT_FOUND; + goto fail; + } + +fail: + av_dict_free(&options); + return ret; } -const char *avfilter_pad_get_name(AVFilterPad *pads, int pad_idx) +const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx) { return pads[pad_idx].name; } -enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx) +enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx) { return pads[pad_idx].type; } @@ -639,6 +995,7 @@ static int default_filter_frame(AVFilterLink *link, AVFrame *frame) static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame) { int (*filter_frame)(AVFilterLink *, AVFrame *); + AVFilterContext *dstctx = link->dst; AVFilterPad *dst = link->dstpad; AVFrame *out; int ret; @@ -701,7 +1058,20 @@ static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame) } pts = out->pts; + if (dstctx->enable_str) { + int64_t pos = av_frame_get_pkt_pos(out); + dstctx->var_values[VAR_N] = link->frame_count; + dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base); + dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos; + + dstctx->is_disabled = fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) < 0.5; + if (dstctx->is_disabled && + (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC)) + filter_frame = default_filter_frame; + } ret = filter_frame(link, out); + link->frame_count++; + link->frame_requested = 0; ff_update_link_current_pts(link, pts); return ret; } @@ -713,6 +1083,7 @@ static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFrame *frame) int nb_channels = av_frame_get_channels(frame); int ret = 0; + link->flags |= FF_LINK_FLAG_REQUEST_LOOP; /* Handle framing (min_samples, max_samples) */ while (insamples) { if (!pbuf) { @@ -724,8 +1095,9 @@ static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFrame *frame) return 0; } av_frame_copy_props(pbuf, frame); - pbuf->pts = frame->pts + - av_rescale_q(inpos, samples_tb, link->time_base); + pbuf->pts = frame->pts; + if (pbuf->pts != AV_NOPTS_VALUE) + pbuf->pts += av_rescale_q(inpos, samples_tb, link->time_base); pbuf->nb_samples = 0; } nb_samples = FFMIN(insamples, @@ -775,3 +1147,8 @@ int ff_filter_frame(AVFilterLink *link, AVFrame *frame) return ff_filter_frame_framed(link, frame); } } + +const AVClass *avfilter_get_class(void) +{ + return &avfilter_class; +} |