* 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"
#include "avfilter.h"
#include "formats.h"
#include "internal.h"
-#include "audio.h"
+
+#include "libavutil/ffversion.h"
+const char av_filter_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame);
ff_tlog(ctx, "]%s", end ? "\n" : "");
}
-unsigned avfilter_version(void) {
+unsigned avfilter_version(void)
+{
av_assert0(LIBAVFILTER_VERSION_MICRO >= 100);
return LIBAVFILTER_VERSION_INT;
}
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,
if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
src->outputs[srcpad] || dst->inputs[dstpad])
- return -1;
+ return AVERROR(EINVAL);
if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
av_log(src, AV_LOG_ERROR,
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;
}
/* 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);
AVFilterLink *inlink;
if (!link) continue;
+ if (!link->src || !link->dst) {
+ av_log(filter, AV_LOG_ERROR,
+ "Not all input and output are properly linked (%d).\n", i);
+ return AVERROR(EINVAL);
+ }
inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
link->current_pts = AV_NOPTS_VALUE;
if ((config_link = link->dstpad->config_props))
if ((ret = config_link(link)) < 0) {
- av_log(link->src, AV_LOG_ERROR,
+ av_log(link->dst, AV_LOG_ERROR,
"Failed to configure input pad on %s\n",
link->dst->name);
return ret;
for (i = 0; i < link->src->nb_inputs; i++) {
int val;
if (!link->src->inputs[i])
- return -1;
+ return AVERROR(EINVAL);
val = ff_poll_frame(link->src->inputs[i]);
min = FFMIN(min, val);
}
return min;
}
+static const char *const var_names[] = {
+ "t",
+ "n",
+ "pos",
+ "w",
+ "h",
+ NULL
+};
+
+enum {
+ VAR_T,
+ VAR_N,
+ VAR_POS,
+ VAR_W,
+ VAR_H,
+ 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)
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);
}
}
static AVFilter *first_filter;
+static AVFilter **last_filter = &first_filter;
+#if !FF_API_NOCONST_GET_NAME
+const
+#endif
AVFilter *avfilter_get_by_name(const char *name)
{
- AVFilter *f = NULL;
+ const AVFilter *f = NULL;
+
+ if (!name)
+ return NULL;
while ((f = avfilter_next(f)))
if (!strcmp(f->name, name))
- return f;
+ return (AVFilter *)f;
return NULL;
}
int avfilter_register(AVFilter *filter)
{
- AVFilter **f = &first_filter;
- int i;
+ AVFilter **f = last_filter;
- for(i=0; filter->inputs && filter->inputs[i].name; i++) {
- const AVFilterPad *input = &filter->inputs[i];
- av_assert0( !input->filter_frame
- || (!input->start_frame && !input->end_frame));
- }
+ /* the filter must select generic or internal exclusively */
+ av_assert0((filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE) != AVFILTER_FLAG_SUPPORT_TIMELINE);
- while (*f)
- f = &(*f)->next;
- *f = filter;
filter->next = NULL;
+ while(*f || avpriv_atomic_ptr_cas((void * volatile *)f, NULL, filter))
+ f = &(*f)->next;
+ last_filter = &filter->next;
+
return 0;
}
if (!pads)
return 0;
- for(count = 0; pads->name; count ++) pads ++;
+ for (count = 0; pads->name; count++)
+ pads++;
return count;
}
static const AVClass *filter_child_class_next(const AVClass *prev)
{
- AVFilter *f = NULL;
+ const AVFilter *f = NULL;
/* find the filter that corresponds to prev */
while (prev && (f = avfilter_next(f)))
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,
.category = AV_CLASS_CATEGORY_FILTER,
.child_next = filter_child_next,
.child_class_next = filter_child_class_next,
+ .option = avfilter_options,
};
+static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg,
+ int *ret, int nb_jobs)
+{
+ int i;
+
+ for (i = 0; i < nb_jobs; i++) {
+ int r = func(ctx, arg, i, nb_jobs);
+ if (ret)
+ ret[i] = r;
+ }
+ return 0;
+}
+
AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
{
AVFilterContext *ret;
goto err;
}
+ 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);
+ ret->input_pads = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
if (!ret->input_pads)
goto err;
memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
- ret->inputs = av_mallocz(sizeof(AVFilterLink*) * ret->nb_inputs);
+ ret->inputs = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
if (!ret->inputs)
goto err;
}
ret->nb_outputs = avfilter_pad_count(filter->outputs);
if (ret->nb_outputs) {
- ret->output_pads = av_malloc(sizeof(AVFilterPad) * ret->nb_outputs);
+ ret->output_pads = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
if (!ret->output_pads)
goto err;
memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
- ret->outputs = av_mallocz(sizeof(AVFilterLink*) * ret->nb_outputs);
+ ret->outputs = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
if (!ret->outputs)
goto err;
}
-#if FF_API_FOO_COUNT
- ret->output_count = ret->nb_outputs;
- ret->input_count = ret->nb_inputs;
-#endif
return ret;
av_freep(&ret->output_pads);
ret->nb_outputs = 0;
av_freep(&ret->priv);
+ av_freep(&ret->internal);
av_free(ret);
return NULL;
}
}
#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;
filter->filter->uninit(filter);
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 || filter->filter->shorthand)
+ if (filter->filter->priv_class)
av_opt_free(filter->priv);
av_freep(&filter->name);
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);
}
}
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)) {
return ret;
}
}
+ }
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;
+ }
return count;
}
{
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) {
{
AVDictionary *options = NULL;
AVDictionaryEntry *e;
- int ret=0;
+ int ret = 0;
if (args && *args) {
if (!filter->filter->priv_class) {
return AVERROR(EINVAL);
}
-#if FF_API_OLD_FILTER_OPTS
+#if FF_API_OLD_FILTER_OPTS || FF_API_OLD_FILTER_OPTS_ERROR
if ( !strcmp(filter->filter->name, "format") ||
!strcmp(filter->filter->name, "noformat") ||
!strcmp(filter->filter->name, "frei0r") ||
while ((p = strchr(p, ':')))
*p++ = '|';
+#if FF_API_OLD_FILTER_OPTS
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);
+#else
+ if (deprecated) {
+ av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "
+ "'|' to separate the list items ('%s' instead of '%s')\n",
+ copy, args);
+ ret = AVERROR(EINVAL);
+ } else {
+ ret = process_options(filter, &options, copy);
+ }
+#endif
av_freep(©);
if (ret < 0)
goto fail;
+ } else
#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;
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;
+ AVFrame *out = NULL;
int ret;
AVFilterCommand *cmd= link->dst->command_queue;
int64_t pts;
if (dst->needs_writable && !av_frame_is_writable(frame)) {
av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
- /* Maybe use ff_copy_buffer_ref instead? */
switch (link->type) {
case AVMEDIA_TYPE_VIDEO:
out = ff_get_video_buffer(link, link->w, link->h);
case AVMEDIA_TYPE_AUDIO:
out = ff_get_audio_buffer(link, frame->nb_samples);
break;
- default: return AVERROR(EINVAL);
+ default:
+ ret = AVERROR(EINVAL);
+ goto fail;
}
if (!out) {
- av_frame_free(&frame);
- return AVERROR(ENOMEM);
+ ret = AVERROR(ENOMEM);
+ goto fail;
}
- av_frame_copy_props(out, frame);
+
+ ret = av_frame_copy_props(out, frame);
+ if (ret < 0)
+ goto fail;
switch (link->type) {
case AVMEDIA_TYPE_VIDEO:
av_get_channel_layout_nb_channels(frame->channel_layout),
frame->format);
break;
- default: return AVERROR(EINVAL);
+ default:
+ ret = AVERROR(EINVAL);
+ goto fail;
}
av_frame_free(&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_W] = link->w;
+ dstctx->var_values[VAR_H] = link->h;
+ 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;
+
+fail:
+ av_frame_free(&out);
+ av_frame_free(&frame);
+ return ret;
}
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,
/* Consistency checks */
if (link->type == AVMEDIA_TYPE_VIDEO) {
- if (strcmp(link->dst->filter->name, "scale")) {
+ if (strcmp(link->dst->filter->name, "buffersink") &&
+ strcmp(link->dst->filter->name, "format") &&
+ strcmp(link->dst->filter->name, "idet") &&
+ strcmp(link->dst->filter->name, "null") &&
+ strcmp(link->dst->filter->name, "scale")) {
av_assert1(frame->format == link->format);
av_assert1(frame->width == link->w);
av_assert1(frame->height == link->h);