diff options
Diffstat (limited to 'ffmpeg/libavfilter/avfiltergraph.c')
| -rw-r--r-- | ffmpeg/libavfilter/avfiltergraph.c | 405 |
1 files changed, 329 insertions, 76 deletions
diff --git a/ffmpeg/libavfilter/avfiltergraph.c b/ffmpeg/libavfilter/avfiltergraph.c index 89cdda3..1fb83c4 100644 --- a/ffmpeg/libavfilter/avfiltergraph.c +++ b/ffmpeg/libavfilter/avfiltergraph.c @@ -20,58 +20,112 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include "config.h" + #include <string.h> #include "libavutil/avassert.h" +#include "libavutil/avstring.h" +#include "libavutil/bprint.h" #include "libavutil/channel_layout.h" +#include "libavutil/internal.h" #include "libavutil/opt.h" #include "libavutil/pixdesc.h" #include "libavcodec/avcodec.h" // avcodec_find_best_pix_fmt_of_2() + #include "avfilter.h" -#include "avfiltergraph.h" #include "formats.h" #include "internal.h" - -#define OFFSET(x) offsetof(AVFilterGraph,x) - -static const AVOption options[]={ -{"scale_sws_opts" , "default scale filter options" , OFFSET(scale_sws_opts) , AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, 0 }, -{"aresample_swr_opts" , "default aresample filter options" , OFFSET(aresample_swr_opts) , AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, 0 }, -{0} +#include "thread.h" + +#define OFFSET(x) offsetof(AVFilterGraph, x) +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM +static const AVOption filtergraph_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 }, .flags = FLAGS, .unit = "thread_type" }, + { "threads", "Maximum number of threads", OFFSET(nb_threads), + AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS }, + {"scale_sws_opts" , "default scale filter options" , OFFSET(scale_sws_opts) , + AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, + {"aresample_swr_opts" , "default aresample filter options" , OFFSET(aresample_swr_opts) , + AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, + { NULL }, }; - static const AVClass filtergraph_class = { .class_name = "AVFilterGraph", .item_name = av_default_item_name, - .option = options, .version = LIBAVUTIL_VERSION_INT, + .option = filtergraph_options, .category = AV_CLASS_CATEGORY_FILTER, }; +#if !HAVE_THREADS +void ff_graph_thread_free(AVFilterGraph *graph) +{ +} + +int ff_graph_thread_init(AVFilterGraph *graph) +{ + graph->thread_type = 0; + graph->nb_threads = 1; + return 0; +} +#endif + AVFilterGraph *avfilter_graph_alloc(void) { AVFilterGraph *ret = av_mallocz(sizeof(*ret)); if (!ret) return NULL; + + ret->internal = av_mallocz(sizeof(*ret->internal)); + if (!ret->internal) { + av_freep(&ret); + return NULL; + } + ret->av_class = &filtergraph_class; + av_opt_set_defaults(ret); + return ret; } +void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter) +{ + int i; + for (i = 0; i < graph->nb_filters; i++) { + if (graph->filters[i] == filter) { + FFSWAP(AVFilterContext*, graph->filters[i], + graph->filters[graph->nb_filters - 1]); + graph->nb_filters--; + return; + } + } +} + void avfilter_graph_free(AVFilterGraph **graph) { if (!*graph) return; - for (; (*graph)->nb_filters > 0; (*graph)->nb_filters--) - avfilter_free((*graph)->filters[(*graph)->nb_filters - 1]); + + while ((*graph)->nb_filters) + avfilter_free((*graph)->filters[0]); + + ff_graph_thread_free(*graph); + av_freep(&(*graph)->sink_links); + av_freep(&(*graph)->scale_sws_opts); av_freep(&(*graph)->aresample_swr_opts); av_freep(&(*graph)->resample_lavr_opts); av_freep(&(*graph)->filters); + av_freep(&(*graph)->internal); av_freep(graph); } +#if FF_API_AVFILTER_OPEN int avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter) { AVFilterContext **filters = av_realloc(graph->filters, @@ -82,21 +136,32 @@ int avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter) graph->filters = filters; graph->filters[graph->nb_filters++] = filter; +#if FF_API_FOO_COUNT +FF_DISABLE_DEPRECATION_WARNINGS + graph->filter_count_unused = graph->nb_filters; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + + filter->graph = graph; + return 0; } +#endif -int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt, +int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx) { int ret; - if ((ret = avfilter_open(filt_ctx, filt, name)) < 0) - goto fail; - if ((ret = avfilter_init_filter(*filt_ctx, args, opaque)) < 0) - goto fail; - if ((ret = avfilter_graph_add_filter(graph_ctx, *filt_ctx)) < 0) + *filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name); + if (!*filt_ctx) + return AVERROR(ENOMEM); + + ret = avfilter_init_str(*filt_ctx, args); + if (ret < 0) goto fail; + return 0; fail: @@ -111,13 +176,55 @@ void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags) graph->disable_auto_convert = flags; } +AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph, + const AVFilter *filter, + const char *name) +{ + AVFilterContext **filters, *s; + + if (graph->thread_type && !graph->internal->thread_execute) { + if (graph->execute) { + graph->internal->thread_execute = graph->execute; + } else { + int ret = ff_graph_thread_init(graph); + if (ret < 0) { + av_log(graph, AV_LOG_ERROR, "Error initializing threading.\n"); + return NULL; + } + } + } + + s = ff_filter_alloc(filter, name); + if (!s) + return NULL; + + filters = av_realloc(graph->filters, sizeof(*filters) * (graph->nb_filters + 1)); + if (!filters) { + avfilter_free(s); + return NULL; + } + + graph->filters = filters; + graph->filters[graph->nb_filters++] = s; + +#if FF_API_FOO_COUNT +FF_DISABLE_DEPRECATION_WARNINGS + graph->filter_count_unused = graph->nb_filters; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + + s->graph = graph; + + return s; +} + /** * Check for the validity of graph. * * A graph is considered valid if all its input and output pads are * connected. * - * @return 0 in case of success, a negative value otherwise + * @return >= 0 in case of success, a negative value otherwise */ static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx) { @@ -155,7 +262,7 @@ static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx) /** * Configure all the links of graphctx. * - * @return 0 in case of success, a negative value otherwise + * @return >= 0 in case of success, a negative value otherwise */ static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx) { @@ -211,8 +318,9 @@ static int filter_query_formats(AVFilterContext *ctx) AVMEDIA_TYPE_VIDEO; if ((ret = ctx->filter->query_formats(ctx)) < 0) { - av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n", - ctx->name, av_err2str(ret)); + if (ret != AVERROR(EAGAIN)) + av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n", + ctx->name, av_err2str(ret)); return ret; } @@ -238,26 +346,115 @@ static int filter_query_formats(AVFilterContext *ctx) return 0; } +static int formats_declared(AVFilterContext *f) +{ + int i; + + for (i = 0; i < f->nb_inputs; i++) { + if (!f->inputs[i]->out_formats) + return 0; + if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO && + !(f->inputs[i]->out_samplerates && + f->inputs[i]->out_channel_layouts)) + return 0; + } + for (i = 0; i < f->nb_outputs; i++) { + if (!f->outputs[i]->in_formats) + return 0; + if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO && + !(f->outputs[i]->in_samplerates && + f->outputs[i]->in_channel_layouts)) + return 0; + } + return 1; +} + +static AVFilterFormats *clone_filter_formats(AVFilterFormats *arg) +{ + AVFilterFormats *a = av_memdup(arg, sizeof(*arg)); + if (a) { + a->refcount = 0; + a->refs = NULL; + a->formats = av_memdup(a->formats, sizeof(*a->formats) * a->nb_formats); + if (!a->formats && arg->formats) + av_freep(&a); + } + return a; +} + +static int can_merge_formats(AVFilterFormats *a_arg, + AVFilterFormats *b_arg, + enum AVMediaType type, + int is_sample_rate) +{ + AVFilterFormats *a, *b, *ret; + if (a_arg == b_arg) + return 1; + a = clone_filter_formats(a_arg); + b = clone_filter_formats(b_arg); + + if (!a || !b) { + if (a) + av_freep(&a->formats); + if (b) + av_freep(&b->formats); + + av_freep(&a); + av_freep(&b); + + return 0; + } + + if (is_sample_rate) { + ret = ff_merge_samplerates(a, b); + } else { + ret = ff_merge_formats(a, b, type); + } + if (ret) { + av_freep(&ret->formats); + av_freep(&ret->refs); + av_freep(&ret); + return 1; + } else { + av_freep(&a->formats); + av_freep(&b->formats); + av_freep(&a); + av_freep(&b); + return 0; + } +} + +/** + * Perform one round of query_formats() and merging formats lists on the + * filter graph. + * @return >=0 if all links formats lists could be queried and merged; + * AVERROR(EAGAIN) some progress was made in the queries or merging + * and a later call may succeed; + * AVERROR(EIO) (may be changed) plus a log message if no progress + * was made and the negotiation is stuck; + * a negative error code if some other error happened + */ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx) { int i, j, ret; int scaler_count = 0, resampler_count = 0; + int count_queried = 0; /* successful calls to query_formats() */ + int count_merged = 0; /* successful merge of formats lists */ + int count_already_merged = 0; /* lists already merged */ + int count_delayed = 0; /* lists that need to be merged later */ - for (j = 0; j < 2; j++) { - /* ask all the sub-filters for their supported media formats */ for (i = 0; i < graph->nb_filters; i++) { - /* Call query_formats on sources first. - This is a temporary workaround for amerge, - until format renegociation is implemented. */ - if (!graph->filters[i]->nb_inputs == j) + AVFilterContext *f = graph->filters[i]; + if (formats_declared(f)) continue; - if (graph->filters[i]->filter->query_formats) - ret = filter_query_formats(graph->filters[i]); + if (f->filter->query_formats) + ret = filter_query_formats(f); else - ret = ff_default_query_formats(graph->filters[i]); - if (ret < 0) + ret = ff_default_query_formats(f); + if (ret < 0 && ret != AVERROR(EAGAIN)) return ret; - } + /* note: EAGAIN could indicate a partial success, not counted yet */ + count_queried += ret >= 0; } /* go through and merge as many format lists as possible */ @@ -271,21 +468,49 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx) if (!link) continue; - if (link->in_formats != link->out_formats && - !ff_merge_formats(link->in_formats, link->out_formats, - link->type)) - convert_needed = 1; - if (link->type == AVMEDIA_TYPE_AUDIO) { - if (link->in_channel_layouts != link->out_channel_layouts && - !ff_merge_channel_layouts(link->in_channel_layouts, - link->out_channel_layouts)) - convert_needed = 1; - if (link->in_samplerates != link->out_samplerates && - !ff_merge_samplerates(link->in_samplerates, - link->out_samplerates)) + if (link->in_formats != link->out_formats + && link->in_formats && link->out_formats) + if (!can_merge_formats(link->in_formats, link->out_formats, + link->type, 0)) convert_needed = 1; + if (link->type == AVMEDIA_TYPE_AUDIO) { + if (link->in_samplerates != link->out_samplerates + && link->in_samplerates && link->out_samplerates) + if (!can_merge_formats(link->in_samplerates, + link->out_samplerates, + 0, 1)) + convert_needed = 1; + } + +#define MERGE_DISPATCH(field, statement) \ + if (!(link->in_ ## field && link->out_ ## field)) { \ + count_delayed++; \ + } else if (link->in_ ## field == link->out_ ## field) { \ + count_already_merged++; \ + } else if (!convert_needed) { \ + count_merged++; \ + statement \ } + if (link->type == AVMEDIA_TYPE_AUDIO) { + MERGE_DISPATCH(channel_layouts, + if (!ff_merge_channel_layouts(link->in_channel_layouts, + link->out_channel_layouts)) + convert_needed = 1; + ) + MERGE_DISPATCH(samplerates, + if (!ff_merge_samplerates(link->in_samplerates, + link->out_samplerates)) + convert_needed = 1; + ) + } + MERGE_DISPATCH(formats, + if (!ff_merge_formats(link->in_formats, link->out_formats, + link->type)) + convert_needed = 1; + ) +#undef MERGE_DISPATCH + if (convert_needed) { AVFilterContext *convert; AVFilter *filter; @@ -304,13 +529,9 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx) snprintf(inst_name, sizeof(inst_name), "auto-inserted scaler %d", scaler_count++); - if (graph->scale_sws_opts) - snprintf(scale_args, sizeof(scale_args), "0:0:%s", graph->scale_sws_opts); - else - snprintf(scale_args, sizeof(scale_args), "0:0"); if ((ret = avfilter_graph_create_filter(&convert, filter, - inst_name, scale_args, NULL, + inst_name, graph->scale_sws_opts, NULL, graph)) < 0) return ret; break; @@ -368,6 +589,30 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx) } } + av_log(graph, AV_LOG_DEBUG, "query_formats: " + "%d queried, %d merged, %d already done, %d delayed\n", + count_queried, count_merged, count_already_merged, count_delayed); + if (count_delayed) { + AVBPrint bp; + + /* if count_queried > 0, one filter at least did set its formats, + that will give additional information to its neighbour; + if count_merged > 0, one pair of formats lists at least was merged, + that will give additional information to all connected filters; + in both cases, progress was made and a new round must be done */ + if (count_queried || count_merged) + return AVERROR(EAGAIN); + av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC); + for (i = 0; i < graph->nb_filters; i++) + if (!formats_declared(graph->filters[i])) + av_bprintf(&bp, "%s%s", bp.len ? ", " : "", + graph->filters[i]->name); + av_log(graph, AV_LOG_ERROR, + "The following filters could not choose their formats: %s\n" + "Consider inserting the (a)format filter near their input or " + "output.\n", bp.str); + return AVERROR(EIO); + } return 0; } @@ -381,34 +626,38 @@ static int pick_format(AVFilterLink *link, AVFilterLink *ref) int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0; enum AVPixelFormat best= AV_PIX_FMT_NONE; int i; - for (i=0; i<link->in_formats->format_count; i++) { + for (i=0; i<link->in_formats->nb_formats; i++) { enum AVPixelFormat p = link->in_formats->formats[i]; best= avcodec_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL); } av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n", - av_get_pix_fmt_name(best), link->in_formats->format_count, + av_get_pix_fmt_name(best), link->in_formats->nb_formats, av_get_pix_fmt_name(ref->format), has_alpha); link->in_formats->formats[0] = best; } } - link->in_formats->format_count = 1; + link->in_formats->nb_formats = 1; link->format = link->in_formats->formats[0]; if (link->type == AVMEDIA_TYPE_AUDIO) { - if (!link->in_samplerates->format_count) { + if (!link->in_samplerates->nb_formats) { av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for" " the link between filters %s and %s.\n", link->src->name, link->dst->name); return AVERROR(EINVAL); } - link->in_samplerates->format_count = 1; + link->in_samplerates->nb_formats = 1; link->sample_rate = link->in_samplerates->formats[0]; if (link->in_channel_layouts->all_layouts) { av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for" " the link between filters %s and %s.\n", link->src->name, link->dst->name); + if (!link->in_channel_layouts->all_counts) + av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not " + "supported, try specifying a channel layout using " + "'aformat=channel_layouts=something'.\n"); return AVERROR(EINVAL); } link->in_channel_layouts->nb_channel_layouts = 1; @@ -450,6 +699,7 @@ do { \ \ if (!out_link->in_ ## list->nb) { \ add_format(&out_link->in_ ##list, fmt); \ + ret = 1; \ break; \ } \ \ @@ -469,9 +719,9 @@ static int reduce_formats_on_filter(AVFilterContext *filter) int i, j, k, ret = 0; REDUCE_FORMATS(int, AVFilterFormats, formats, formats, - format_count, ff_add_format); + nb_formats, ff_add_format); REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats, - format_count, ff_add_format); + nb_formats, ff_add_format); /* reduce channel layouts */ for (i = 0; i < filter->nb_inputs; i++) { @@ -491,7 +741,8 @@ static int reduce_formats_on_filter(AVFilterContext *filter) if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1) continue; - if (fmts->all_layouts) { + if (fmts->all_layouts && + (!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) { /* Turn the infinite list into a singleton */ fmts->all_layouts = fmts->all_counts = 0; ff_add_channel_layout(&outlink->in_channel_layouts, fmt); @@ -534,7 +785,7 @@ static void swap_samplerates_on_filter(AVFilterContext *filter) link = filter->inputs[i]; if (link->type == AVMEDIA_TYPE_AUDIO && - link->out_samplerates->format_count == 1) + link->out_samplerates->nb_formats== 1) break; } if (i == filter->nb_inputs) @@ -547,10 +798,10 @@ static void swap_samplerates_on_filter(AVFilterContext *filter) int best_idx, best_diff = INT_MAX; if (outlink->type != AVMEDIA_TYPE_AUDIO || - outlink->in_samplerates->format_count < 2) + outlink->in_samplerates->nb_formats < 2) continue; - for (j = 0; j < outlink->in_samplerates->format_count; j++) { + for (j = 0; j < outlink->in_samplerates->nb_formats; j++) { int diff = abs(sample_rate - outlink->in_samplerates->formats[j]); if (diff < best_diff) { @@ -712,7 +963,7 @@ static void swap_sample_fmts_on_filter(AVFilterContext *filter) link = filter->inputs[i]; if (link->type == AVMEDIA_TYPE_AUDIO && - link->out_formats->format_count == 1) + link->out_formats->nb_formats == 1) break; } if (i == filter->nb_inputs) @@ -726,10 +977,10 @@ static void swap_sample_fmts_on_filter(AVFilterContext *filter) int best_idx = -1, best_score = INT_MIN; if (outlink->type != AVMEDIA_TYPE_AUDIO || - outlink->in_formats->format_count < 2) + outlink->in_formats->nb_formats < 2) continue; - for (j = 0; j < outlink->in_formats->format_count; j++) { + for (j = 0; j < outlink->in_formats->nb_formats; j++) { int out_format = outlink->in_formats->formats[j]; int out_bps = av_get_bytes_per_sample(out_format); int score; @@ -782,7 +1033,7 @@ static int pick_formats(AVFilterGraph *graph) AVFilterContext *filter = graph->filters[i]; if (filter->nb_inputs){ for (j = 0; j < filter->nb_inputs; j++){ - if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->format_count == 1) { + if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->nb_formats == 1) { if ((ret = pick_format(filter->inputs[j], NULL)) < 0) return ret; change = 1; @@ -791,7 +1042,7 @@ static int pick_formats(AVFilterGraph *graph) } if (filter->nb_outputs){ for (j = 0; j < filter->nb_outputs; j++){ - if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->format_count == 1) { + if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->nb_formats == 1) { if ((ret = pick_format(filter->outputs[j], NULL)) < 0) return ret; change = 1; @@ -831,7 +1082,9 @@ static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx) int ret; /* find supported formats from sub-filters, and merge along links */ - if ((ret = query_formats(graph, log_ctx)) < 0) + while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN)) + av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n"); + if (ret < 0) return ret; /* Once everything is merged, it's possible that we'll still have @@ -953,24 +1206,24 @@ int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const { int i, r = AVERROR(ENOSYS); - if(!graph) + if (!graph) return r; - if((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) { - r=avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST); - if(r != AVERROR(ENOSYS)) + if ((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) { + r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST); + if (r != AVERROR(ENOSYS)) return r; } - if(res_len && res) - res[0]= 0; + if (res_len && res) + res[0] = 0; for (i = 0; i < graph->nb_filters; i++) { AVFilterContext *filter = graph->filters[i]; - if(!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)){ + if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) { r = avfilter_process_command(filter, cmd, arg, res, res_len, flags); - if(r != AVERROR(ENOSYS)) { - if((flags & AVFILTER_CMD_FLAG_ONE) || r<0) + if (r != AVERROR(ENOSYS)) { + if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0) return r; } } |