h264dsp: merge some more asm blocks

[ffmpeg] / libavfilter / avfiltergraph.c

diff --git a/libavfilter/avfiltergraph.c b/libavfilter/avfiltergraph.c
index 4b24508f5fc5f70e9cc4e6964bd0a58315ca51ee..baffc5168ba7cc4a226a24feb4079ae49fb74d7a 100644 (file)
--- a/libavfilter/avfiltergraph.c
+++ b/libavfilter/avfiltergraph.c
@@ -36,13 +36,13 @@ void avfilter_graph_destroy(AVFilterGraph *graph)
 
 int avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter)
 {
-    graph->filters = av_realloc(graph->filters,
-                                sizeof(AVFilterContext*) * ++graph->filter_count);
+    AVFilterContext **filters = av_realloc(graph->filters,
+                                           sizeof(AVFilterContext*) * (graph->filter_count+1));
+    if (!filters)
+        return AVERROR(ENOMEM);
 
-    if (!graph->filters)
-        return -1;
-
-    graph->filters[graph->filter_count - 1] = filter;
+    graph->filters = filters;
+    graph->filters[graph->filter_count++] = filter;
 
     return 0;
 }
@@ -77,6 +77,23 @@ int avfilter_graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)
     return 0;
 }
 
+int avfilter_graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)
+{
+    AVFilterContext *filt;
+    int i, ret;
+
+    for (i=0; i < graph->filter_count; i++) {
+        filt = graph->filters[i];
+
+        if (!filt->output_count) {
+            if ((ret = avfilter_config_links(filt)))
+                return ret;
+        }
+    }
+
+    return 0;
+}
+
 AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name)
 {
     int i;
@@ -88,13 +105,13 @@ AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name)
     return NULL;
 }
 
-static int query_formats(AVFilterGraph *graph)
+static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
 {
     int i, j;
     int scaler_count = 0;
     char inst_name[30];
 
-    /* ask all the sub-filters for their supported colorspaces */
+    /* ask all the sub-filters for their supported media formats */
     for(i = 0; i < graph->filter_count; i ++) {
         if(graph->filters[i]->filter->query_formats)
             graph->filters[i]->filter->query_formats(graph->filters[i]);
@@ -115,9 +132,8 @@ static int query_formats(AVFilterGraph *graph)
                     char scale_args[256];
                     /* couldn't merge format lists. auto-insert scale filter */
                     snprintf(inst_name, sizeof(inst_name), "auto-inserted scaler %d",
-                             scaler_count);
-                    scale =
-                        avfilter_open(avfilter_get_by_name("scale"),inst_name);
+                             scaler_count++);
+                    avfilter_open(&scale, avfilter_get_by_name("scale"), inst_name);
 
                     snprintf(scale_args, sizeof(scale_args), "0:0:%s", graph->scale_sws_opts);
                     if(!scale || scale->filter->init(scale, scale_args, NULL) ||
@@ -130,11 +146,15 @@ static int query_formats(AVFilterGraph *graph)
                         return -1;
 
                     scale->filter->query_formats(scale);
-                    if(!avfilter_merge_formats(scale-> inputs[0]->in_formats,
-                                               scale-> inputs[0]->out_formats)||
-                       !avfilter_merge_formats(scale->outputs[0]->in_formats,
-                                               scale->outputs[0]->out_formats))
+                    if (((link = scale-> inputs[0]) &&
+                         !avfilter_merge_formats(link->in_formats, link->out_formats)) ||
+                        ((link = scale->outputs[0]) &&
+                         !avfilter_merge_formats(link->in_formats, link->out_formats))) {
+                        av_log(log_ctx, AV_LOG_ERROR,
+                               "Impossible to convert between the formats supported by the filter "
+                               "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
                         return -1;
+                    }
                 }
             }
         }
@@ -169,16 +189,29 @@ static void pick_formats(AVFilterGraph *graph)
     }
 }
 
-int avfilter_graph_config_formats(AVFilterGraph *graph)
+int avfilter_graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
 {
     /* find supported formats from sub-filters, and merge along links */
-    if(query_formats(graph))
+    if(query_formats(graph, log_ctx))
         return -1;
 
     /* Once everything is merged, it's possible that we'll still have
-     * multiple valid colorspace choices. We pick the first one. */
+     * multiple valid media format choices. We pick the first one. */
     pick_formats(graph);
 
     return 0;
 }
 
+int avfilter_graph_config(AVFilterGraph *graphctx, AVClass *log_ctx)
+{
+    int ret;
+
+    if ((ret = avfilter_graph_check_validity(graphctx, log_ctx)))
+        return ret;
+    if ((ret = avfilter_graph_config_formats(graphctx, log_ctx)))
+        return ret;
+    if ((ret = avfilter_graph_config_links(graphctx, log_ctx)))
+        return ret;
+
+    return 0;
+}