Handle av_realloc() failure
[ffmpeg.git] / libavfilter / graphparser.c
1 /*
2  * filter graph parser
3  * copyright (c) 2008 Vitor Sessak
4  * copyright (c) 2007 Bobby Bingham
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include <ctype.h>
24 #include <string.h>
25
26 #include "avfilter.h"
27 #include "avfiltergraph.h"
28
29 /**
30  * For use in av_log
31  */
32 static const char *log_name(void *p)
33 {
34     return "Filter parser";
35 }
36
37 static const AVClass filter_parser_class = {
38     "Filter parser",
39     log_name
40 };
41
42 static const AVClass *log_ctx = &filter_parser_class;
43
44 static int create_filter(AVFilterGraph *ctx, int index, char *name,
45                          char *args)
46 {
47     AVFilterContext *filt;
48
49     AVFilter *filterdef;
50     char tmp[20];
51
52     snprintf(tmp, 20, "%d", index);
53     if(!(filterdef = avfilter_get_by_name(name)) ||
54        !(filt = avfilter_open(filterdef, tmp))) {
55         av_log(&log_ctx, AV_LOG_ERROR,
56                "error creating filter '%s'\n", name);
57         return -1;
58     }
59
60     if (avfilter_graph_add_filter(ctx, filt) < 0)
61         return -1;
62
63     if(avfilter_init_filter(filt, args, NULL)) {
64         av_log(&log_ctx, AV_LOG_ERROR,
65                "error initializing filter '%s'\n", name);
66         return -1;
67     }
68
69     return 0;
70 }
71
72 static int link_filter(AVFilterGraph *ctx, int src, int srcpad,
73                        int dst, int dstpad)
74 {
75     AVFilterContext *filt, *filtb;
76
77     char tmp[20];
78
79     snprintf(tmp, 20, "%d", src);
80     if(!(filt = avfilter_graph_get_filter(ctx, tmp))) {
81         av_log(&log_ctx, AV_LOG_ERROR, "link source does not exist in graph\n");
82         return -1;
83     }
84     snprintf(tmp, 20, "%d", dst);
85     if(!(filtb = avfilter_graph_get_filter(ctx, tmp))) {
86         av_log(&log_ctx, AV_LOG_ERROR, "link destination does not exist in graph\n");
87         return -1;
88     }
89     if(avfilter_link(filt, srcpad, filtb, dstpad)) {
90         av_log(&log_ctx, AV_LOG_ERROR, "cannot create link between source and destination filters\n");
91         return -1;
92     }
93
94     return 0;
95 }
96
97 static void consume_whitespace(const char **buf)
98 {
99     *buf += strspn(*buf, " \n\t");
100 }
101
102 /**
103  * Copy the first size bytes of input string to a null-terminated string,
104  * removing any control character. Ex: "aaa'bb'c\'c\\" -> "aaabbc'c\"
105  */
106 static void copy_unquoted(char *out, const char *in, int size)
107 {
108     int i;
109     for (i=0; i < size; i++) {
110         if (in[i] == '\'')
111             continue;
112         else if (in[i] == '\\') {
113             if (i+1 == size) {
114                 *out = 0;
115                 return;
116             }
117             i++;
118         }
119         *out++ = in[i];
120     }
121     *out=0;
122 }
123
124 /**
125  * Consumes a string from *buf.
126  * @return a copy of the consumed string, which should be free'd after use
127  */
128 static char *consume_string(const char **buf)
129 {
130     const char *start;
131     char *ret;
132     int size;
133
134     consume_whitespace(buf);
135
136     if (!(**buf))
137         return av_mallocz(1);
138
139     start = *buf;
140
141     while(1) {
142         *buf += strcspn(*buf, " ()=,'\\");
143         if (**buf == '\\')
144             *buf+=2;
145         else
146             break;
147     }
148
149     if (**buf == '\'') {
150         const char *p = *buf;
151         do {
152             p++;
153             p = strchr(p, '\'');
154         } while (p && p[-1] == '\\');
155         if (p)
156             *buf = p + 1;
157         else
158             *buf += strlen(*buf); // Move the pointer to the null end byte
159     }
160
161     size = *buf - start + 1;
162     ret = av_malloc(size);
163     copy_unquoted(ret, start, size-1);
164
165     return ret;
166 }
167
168 /**
169  * Parse "(linkname)"
170  * @arg name a pointer (that need to be free'd after use) to the name between
171  *           parenthesis
172  */
173 static void parse_link_name(const char **buf, char **name)
174 {
175     (*buf)++;
176
177     *name = consume_string(buf);
178
179     if (!*name[0])
180         goto fail;
181
182     if (*(*buf)++ != ')')
183         goto fail;
184
185     return;
186  fail:
187     av_freep(name);
188     av_log(&log_ctx, AV_LOG_ERROR, "Could not parse link name!\n");
189 }
190
191 /**
192  * Parse "filter=params"
193  * @arg name a pointer (that need to be free'd after use) to the name of the
194  *           filter
195  * @arg ars  a pointer (that need to be free'd after use) to the args of the
196  *           filter
197  */
198 static int parse_filter(const char **buf, AVFilterGraph *graph, int index)
199 {
200     char *name, *opts;
201     name = consume_string(buf);
202
203     if (**buf == '=') {
204         (*buf)++;
205         opts = consume_string(buf);
206     } else {
207         opts = NULL;
208     }
209
210     return create_filter(graph, index, name, opts);
211 }
212
213 enum LinkType {
214     LinkTypeIn,
215     LinkTypeOut,
216 };
217
218 /**
219  * A linked-list of the inputs/outputs of the filter chain.
220  */
221 typedef struct AVFilterInOut {
222     enum LinkType type;
223     char *name;
224     int instance;
225     int pad_idx;
226
227     struct AVFilterInOut *next;
228 } AVFilterInOut;
229
230 static void free_inout(AVFilterInOut *head)
231 {
232     while (head) {
233         AVFilterInOut *next;
234         next = head->next;
235         av_free(head);
236         head = next;
237     }
238 }
239
240 /**
241  * Parse "(a1)(link2) ... (etc)"
242  */
243 static int parse_inouts(const char **buf, AVFilterInOut **inout, int firstpad,
244                         enum LinkType type, int instance)
245 {
246     int pad = firstpad;
247     while (**buf == '(') {
248         AVFilterInOut *inoutn = av_malloc(sizeof(AVFilterInOut));
249         parse_link_name(buf, &inoutn->name);
250         inoutn->type = type;
251         inoutn->instance = instance;
252         inoutn->pad_idx = pad++;
253         inoutn->next = *inout;
254         *inout = inoutn;
255     }
256     return pad;
257 }
258
259 /**
260  * Parse a string describing a filter graph.
261  */
262 int avfilter_graph_parse_chain(AVFilterGraph *graph, const char *filters, AVFilterContext *in, int inpad, AVFilterContext *out, int outpad)
263 {
264     AVFilterInOut *inout=NULL;
265     AVFilterInOut  *head=NULL;
266
267     int index = 0;
268     char chr = 0;
269     int pad = 0;
270     int has_out = 0;
271
272     char tmp[20];
273     AVFilterContext *filt;
274
275     consume_whitespace(&filters);
276
277     do {
278         int oldpad = pad;
279
280         pad = parse_inouts(&filters, &inout, chr == ',', LinkTypeIn, index);
281
282         if (parse_filter(&filters, graph, index) < 0)
283             goto fail;
284
285         // If the first filter has an input and none was given, it is
286         // implicitly the input of the whole graph.
287         if (pad == 0 && graph->filters[graph->filter_count-1]->input_count == 1) {
288             snprintf(tmp, 20, "%d", index);
289             if(!(filt = avfilter_graph_get_filter(graph, tmp))) {
290                 av_log(&log_ctx, AV_LOG_ERROR, "filter owning exported pad does not exist\n");
291                 goto fail;
292             }
293             if(avfilter_link(in, inpad, filt, 0)) {
294                 av_log(&log_ctx, AV_LOG_ERROR, "cannot create link between source and destination filters\n");
295                 goto fail;
296             }
297         }
298
299         if(chr == ',') {
300             if (link_filter(graph, index-1, oldpad, index, 0) < 0)
301                 goto fail;
302
303         }
304         pad = parse_inouts(&filters, &inout, 0, LinkTypeOut, index);
305         chr = *filters++;
306         index++;
307     } while (chr == ',' || chr == ';');
308
309     head = inout;
310     for (; inout != NULL; inout = inout->next) {
311         if (inout->instance == -1)
312             continue; // Already processed
313
314         if (!strcmp(inout->name, "in")) {
315             snprintf(tmp, 20, "%d", inout->instance);
316             if(!(filt = avfilter_graph_get_filter(graph, tmp))) {
317                 av_log(&log_ctx, AV_LOG_ERROR, "filter owning exported pad does not exist\n");
318                 goto fail;
319             }
320             if(avfilter_link(in, inpad, filt, inout->pad_idx)) {
321                 av_log(&log_ctx, AV_LOG_ERROR, "cannot create link between source and destination filters\n");
322                 goto fail;
323             }
324         } else if (!strcmp(inout->name, "out")) {
325             has_out = 1;
326             snprintf(tmp, 20, "%d", inout->instance);
327             if(!(filt = avfilter_graph_get_filter(graph, tmp))) {
328                 av_log(&log_ctx, AV_LOG_ERROR, "filter owning exported pad does not exist\n");
329                 goto fail;
330             }
331
332             if(avfilter_link(filt, inout->pad_idx, out, outpad)) {
333                 av_log(&log_ctx, AV_LOG_ERROR, "cannot create link between source and destination filters\n");
334                 goto fail;
335         }
336
337         } else {
338             AVFilterInOut *p, *src, *dst;
339             for (p = inout->next;
340                  p && strcmp(p->name,inout->name); p = p->next);
341
342             if (!p) {
343                 av_log(&log_ctx, AV_LOG_ERROR, "Unmatched link: %s.\n",
344                        inout->name);
345                 goto fail;
346             }
347
348             if (p->type == LinkTypeIn && inout->type == LinkTypeOut) {
349                 src = inout;
350                 dst = p;
351             } else if (p->type == LinkTypeOut && inout->type == LinkTypeIn) {
352                 src = p;
353                 dst = inout;
354             } else {
355                 av_log(&log_ctx, AV_LOG_ERROR, "Two links named '%s' are either both input or both output\n",
356                        inout->name);
357                 goto fail;
358             }
359
360             if (link_filter(graph, src->instance, src->pad_idx, dst->instance, dst->pad_idx) < 0)
361                 goto fail;
362
363             src->instance = -1;
364             dst->instance = -1;
365         }
366     }
367
368     free_inout(head);
369
370     if (!has_out) {
371         snprintf(tmp, 20, "%d", index-1);
372         if(!(filt = avfilter_graph_get_filter(graph, tmp))) {
373             av_log(&log_ctx, AV_LOG_ERROR, "filter owning exported pad does not exist\n");
374             goto fail;
375         }
376
377         if(avfilter_link(filt, pad, out, outpad)) {
378             av_log(&log_ctx, AV_LOG_ERROR, "cannot create link between source and destination filters\n");
379             goto fail;
380         }
381
382     }
383
384     return 0;
385
386  fail:
387     free_inout(head);
388     avfilter_destroy_graph(graph);
389     return -1;
390 }