Plug some memory leaks

[ffmpeg] / libavfilter / graphparser.c

diff --git a/libavfilter/graphparser.c b/libavfilter/graphparser.c
index 926ab690523528489750628002c90a7334a78ccb..2a8a0179905c886e19ae4d358f2fcf244cabf9a6 100644 (file)
--- a/libavfilter/graphparser.c
+++ b/libavfilter/graphparser.c
@@ -144,8 +144,10 @@ static AVFilterContext *create_filter(AVFilterGraph *ctx, int index,
         return NULL;
     }
 
-    if(avfilter_graph_add_filter(ctx, filt) < 0)
+    if(avfilter_graph_add_filter(ctx, filt) < 0) {
+        avfilter_destroy(filt);
         return NULL;
+    }
 
     if(avfilter_init_filter(filt, args, NULL)) {
         av_log(log_ctx, AV_LOG_ERROR,
@@ -164,18 +166,24 @@ static AVFilterContext *parse_filter(const char **buf, AVFilterGraph *graph,
 {
     char *opts = NULL;
     char *name = consume_string(buf);
+    AVFilterContext *ret;
 
-    if(**buf == '=')
+    if(**buf == '=') {
         (*buf)++;
         opts = consume_string(buf);
+    }
 
-    return create_filter(graph, index, name, opts, log_ctx);
+    ret = create_filter(graph, index, name, opts, log_ctx);
+    av_free(name);
+    av_free(opts);
+    return ret;
 }
 
 static void free_inout(AVFilterInOut *head)
 {
     while(head) {
         AVFilterInOut *next = head->next;
+        av_free(head->name);
         av_free(head);
         head = next;
     }
@@ -196,53 +204,54 @@ static AVFilterInOut *extract_inout(const char *label, AVFilterInOut **links)
     return ret;
 }
 
+static void insert_inout(AVFilterInOut **inouts, AVFilterInOut *element)
+{
+    element->next = *inouts;
+    *inouts = element;
+}
 
 static int link_filter_inouts(AVFilterContext *filter,
                               AVFilterInOut **currInputs,
                               AVFilterInOut **openLinks, AVClass *log_ctx)
 {
-    int pad = 0;
+    int pad = filter->input_count;
 
-    pad = filter->input_count;
     while(pad--) {
         AVFilterInOut *p = *currInputs;
         *currInputs = (*currInputs)->next;
         if(!p) {
             av_log(log_ctx, AV_LOG_ERROR,
                    "Not enough inputs specified for the \"%s\" filter.\n",
-                   filter->name);
+                   filter->filter->name);
             return -1;
         }
 
         if(p->filter) {
             if(link_filter(p->filter, p->pad_idx, filter, pad, log_ctx))
                 return -1;
+            av_free(p->name);
             av_free(p);
         } else {
             p->filter = filter;
             p->pad_idx = pad;
-            p->next = *openLinks;
-            *openLinks = p;
+            insert_inout(openInputs, p);
         }
     }
 
-
     if(*currInputs) {
         av_log(log_ctx, AV_LOG_ERROR,
                "Too many inputs specified for the \"%s\" filter.\n",
-               filter->name);
+               filter->filter->name);
         return -1;
     }
 
     pad = filter->output_count;
     while(pad--) {
-        AVFilterInOut *currlinkn = av_malloc(sizeof(AVFilterInOut));
-        currlinkn->name    = NULL;
+        AVFilterInOut *currlinkn = av_mallocz(sizeof(AVFilterInOut));
         currlinkn->type    = LinkTypeOut;
         currlinkn->filter  = filter;
         currlinkn->pad_idx = pad;
-        currlinkn->next    = *currInputs;
-        *currInputs = currlinkn;
+        insert_inout(currInputs, currlinkn);
     }
 
     return 0;
@@ -255,7 +264,6 @@ static int parse_inputs(const char **buf, AVFilterInOut **currInputs,
 
     while(**buf == '[') {
         char *name = parse_link_name(buf, log_ctx);
-        AVFilterInOut *link_to_add;
         AVFilterInOut *match;
 
         if(!name)
@@ -272,19 +280,16 @@ static int parse_inputs(const char **buf, AVFilterInOut **currInputs,
                        "Label \"%s\" appears twice as input!\n", match->name);
                 return -1;
             }
-
-            link_to_add = match;
         } else {
             /* Not in the list, so add it as an input */
-            link_to_add = av_malloc(sizeof(AVFilterInOut));
-
-            link_to_add->name    = name;
-            link_to_add->type    = LinkTypeIn;
-            link_to_add->filter  = NULL;
-            link_to_add->pad_idx = pad;
+            match = av_mallocz(sizeof(AVFilterInOut));
+            match->name    = name;
+            match->type    = LinkTypeIn;
+            match->pad_idx = pad;
         }
-        link_to_add->next = *currInputs;
-        *currInputs = link_to_add;
+
+        insert_inout(currInputs, match);
+
         *buf += consume_whitespace(*buf);
         pad++;
     }
@@ -321,6 +326,8 @@ static int parse_outputs(const char **buf, AVFilterInOut **currInputs,
             if(link_filter(input->filter, input->pad_idx,
                            match->filter, match->pad_idx, log_ctx) < 0)
                 return -1;
+            av_free(match->name);
+            av_free(name);
             av_free(match);
             av_free(input);
         } else {
@@ -328,7 +335,7 @@ static int parse_outputs(const char **buf, AVFilterInOut **currInputs,
             input->next = *openLinks;
             input->type = LinkTypeOut;
             input->name = name;
-            *openLinks = input;
+            insert_inout(openOutputs, input);
         }
         *buf += consume_whitespace(*buf);
         pad++;
@@ -337,15 +344,11 @@ static int parse_outputs(const char **buf, AVFilterInOut **currInputs,
     return pad;
 }
 
-/**
- * Parse a string describing a filter graph.
- */
 int avfilter_parse_graph(AVFilterGraph *graph, const char *filters,
                          AVFilterInOut *openLinks, AVClass *log_ctx)
 {
     int index = 0;
     char chr = 0;
-    int pad = 0;
 
     AVFilterInOut *currInputs = NULL;
 
@@ -353,9 +356,7 @@ int avfilter_parse_graph(AVFilterGraph *graph, const char *filters,
         AVFilterContext *filter;
         filters += consume_whitespace(filters);
 
-        pad = parse_inputs(&filters, &currInputs, &openLinks, log_ctx);
-
-        if(pad < 0)
+        if(parse_inputs(&filters, &currInputs, &openLinks, log_ctx) < 0)
             goto fail;
 
         filter = parse_filter(&filters, graph, index, log_ctx);
@@ -364,19 +365,16 @@ int avfilter_parse_graph(AVFilterGraph *graph, const char *filters,
             goto fail;
 
         if(filter->input_count == 1 && !currInputs && !index) {
-            // First input can be ommitted if it is "[in]"
+            /* First input can be ommitted if it is "[in]" */
             const char *tmp = "[in]";
-            pad = parse_inputs(&tmp, &currInputs, &openLinks, log_ctx);
-            if(pad < 0)
+            if(parse_inputs(&tmp, &currInputs, &openLinks, log_ctx))
                 goto fail;
         }
 
         if(link_filter_inouts(filter, &currInputs, &openLinks, log_ctx) < 0)
             goto fail;
 
-        pad = parse_outputs(&filters, &currInputs, &openLinks, log_ctx);
-
-        if(pad < 0)
+        if(parse_outputs(&filters, &currInputs, &openLinks, log_ctx))
             goto fail;
 
         filters += consume_whitespace(filters);
@@ -392,7 +390,7 @@ int avfilter_parse_graph(AVFilterGraph *graph, const char *filters,
     } while(chr == ',' || chr == ';');
 
     if(openLinks && !strcmp(openLinks->name, "out") && currInputs) {
-        // Last output can be ommitted if it is "[out]"
+        /* Last output can be ommitted if it is "[out]" */
         const char *tmp = "[out]";
         if(parse_outputs(&tmp, &currInputs, &openLinks, log_ctx) < 0)
             goto fail;