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 static AVFilterContext *create_filter(AVFilterGraph *ctx, int index,
  30                                       const char *name, const char *args,
  31                                       AVClass *log_ctx)
  32 {
  33     AVFilterContext *filt;
  34
  35     AVFilter *filterdef;
  36     char inst_name[30];
  37
  38     snprintf(inst_name, sizeof(inst_name), "Parsed filter %d", index);
  39
  40     if(!(filterdef = avfilter_get_by_name(name))) {
  41         av_log(&log_ctx, AV_LOG_ERROR,
  42                "no such filter: '%s'\n", name);
  43         return NULL;
  44     }
  45
  46     if(!(filt = avfilter_open(filterdef, inst_name))) {
  47         av_log(log_ctx, AV_LOG_ERROR,
  48                "error creating filter '%s'\n", name);
  49         return NULL;
  50     }
  51
  52     if(avfilter_graph_add_filter(ctx, filt) < 0)
  53         return NULL;
  54
  55     if(avfilter_init_filter(filt, args, NULL)) {
  56         av_log(log_ctx, AV_LOG_ERROR,
  57                "error initializing filter '%s' with args '%s'\n", name, args);
  58         return NULL;
  59     }
  60
  61     return filt;
  62 }
  63
  64 static int link_filter(AVFilterContext *src, int srcpad,
  65                        AVFilterContext *dst, int dstpad,
  66                        AVClass *log_ctx)
  67 {
  68     if(avfilter_link(src, srcpad, dst, dstpad)) {
  69         av_log(log_ctx, AV_LOG_ERROR,
  70                "cannot create the link %s:%d -> %s:%d\n",
  71                src->filter->name, srcpad, dst->filter->name, dstpad);
  72         return -1;
  73     }
  74
  75     return 0;
  76 }
  77
  78 static void consume_whitespace(const char **buf)
  79 {
  80     *buf += strspn(*buf, " \n\t");
  81 }
  82
  83 /**
  84  * Consumes a string from *buf.
  85  * @return a copy of the consumed string, which should be free'd after use
  86  */
  87 static char *consume_string(const char **buf)
  88 {
  89     char *out = av_malloc(strlen(*buf) + 1);
  90     char *ret = out;
  91
  92     consume_whitespace(buf);
  93
  94     do{
  95         char c = *(*buf)++;
  96         switch (c) {
  97         case '\\':
  98             *out++= *(*buf)++;
  99             break;
 100         case '\'':
 101             while(**buf && **buf != '\'')
 102                 *out++= *(*buf)++;
 103             if(**buf) (*buf)++;
 104             break;
 105         case 0:
 106         case ']':
 107         case '[':
 108         case '=':
 109         case ',':
 110         case ' ':
 111         case '\n':
 112             *out++= 0;
 113             break;
 114         default:
 115             *out++= c;
 116         }
 117     } while(out[-1]);
 118
 119     (*buf)--;
 120     consume_whitespace(buf);
 121
 122     return ret;
 123 }
 124
 125 /**
 126  * Parse "[linkname]"
 127  * @arg name a pointer (that need to be free'd after use) to the name between
 128  *           parenthesis
 129  */
 130 static void parse_link_name(const char **buf, char **name, AVClass *log_ctx)
 131 {
 132     const char *start = *buf;
 133     (*buf)++;
 134
 135     *name = consume_string(buf);
 136
 137     if(!*name[0]) {
 138         av_log(log_ctx, AV_LOG_ERROR,
 139                "Bad (empty?) label found in the following: \"%s\".\n", start);
 140         goto fail;
 141     }
 142
 143     if(*(*buf)++ != ']') {
 144         av_log(log_ctx, AV_LOG_ERROR,
 145                "Mismatched '[' found in the following: \"%s\".\n", start);
 146     fail:
 147         av_freep(name);
 148     }
 149 }
 150
 151 /**
 152  * Parse "filter=params"
 153  * @arg name a pointer (that need to be free'd after use) to the name of the
 154  *           filter
 155  * @arg ars  a pointer (that need to be free'd after use) to the args of the
 156  *           filter
 157  */
 158 static AVFilterContext *parse_filter(const char **buf,
 159                                      AVFilterGraph *graph, int index,
 160                                      AVClass *log_ctx)
 161 {
 162     char *name, *opts;
 163     name = consume_string(buf);
 164
 165     if(**buf == '=') {
 166         (*buf)++;
 167         opts = consume_string(buf);
 168     } else {
 169         opts = NULL;
 170     }
 171
 172     return create_filter(graph, index, name, opts, log_ctx);
 173 }
 174
 175 enum LinkType {
 176     LinkTypeIn,
 177     LinkTypeOut,
 178 };
 179
 180 /**
 181  * A linked-list of the inputs/outputs of the filter chain.
 182  */
 183 typedef struct AVFilterInOut {
 184     enum LinkType type;
 185     char *name;
 186     AVFilterContext *filter;
 187     int pad_idx;
 188
 189     struct AVFilterInOut *next;
 190 } AVFilterInOut;
 191
 192 static void free_inout(AVFilterInOut *head)
 193 {
 194     while (head) {
 195         AVFilterInOut *next = head->next;
 196         av_free(head);
 197         head = next;
 198     }
 199 }
 200
 201 /**
 202  * Process a link. This funcion looks for a matching label in the *inout
 203  * linked list. If none is found, it adds this link to the list.
 204  */
 205 static int handle_link(char *name, AVFilterInOut **inout, int pad,
 206                        enum LinkType type, AVFilterContext *filter,
 207                        AVClass *log_ctx)
 208 {
 209     AVFilterInOut *p = *inout;
 210
 211     for (; p && strcmp(p->name, name); p = p->next);
 212
 213     if(!p) {
 214         // First label apearence, add it to the linked list
 215         AVFilterInOut *inoutn = av_malloc(sizeof(AVFilterInOut));
 216
 217         inoutn->name    = name;
 218         inoutn->type    = type;
 219         inoutn->filter  = filter;
 220         inoutn->pad_idx = pad;
 221         inoutn->next    = *inout;
 222         *inout = inoutn;
 223          return 0;
 224     }
 225
 226     if(p->type == LinkTypeIn && type == LinkTypeOut) {
 227         if(link_filter(filter, pad, p->filter, p->pad_idx, log_ctx) < 0)
 228             goto fail;
 229     } else if(p->type == LinkTypeOut && type == LinkTypeIn) {
 230         if(link_filter(p->filter, p->pad_idx, filter, pad, log_ctx) < 0)
 231             goto fail;
 232     } else {
 233         av_log(log_ctx, AV_LOG_ERROR,
 234                "Two links named '%s' are either both input or both output\n",
 235                name);
 236         goto fail;
 237     }
 238
 239     p->filter = NULL;
 240
 241     return 0;
 242  fail:
 243     return -1;
 244 }
 245
 246
 247 /**
 248  * Parse "[a1][link2] ... [etc]"
 249  */
 250 static int parse_inouts(const char **buf, AVFilterInOut **inout, int pad,
 251                         enum LinkType type, AVFilterContext *filter,
 252                         AVClass *log_ctx)
 253 {
 254     while (**buf == '[') {
 255         char *name;
 256
 257         parse_link_name(buf, &name, log_ctx);
 258
 259         if(!name)
 260             return -1;
 261
 262         if(handle_link(name, inout, pad++, type, filter, log_ctx) < 0)
 263             return -1;
 264
 265         consume_whitespace(buf);
 266     }
 267     return pad;
 268 }
 269
 270 static const char *skip_inouts(const char *buf)
 271 {
 272     while (*buf == '[') {
 273         buf += strcspn(buf, "]") + 1;
 274         consume_whitespace(&buf);
 275     }
 276     return buf;
 277 }
 278
 279
 280 /**
 281  * Parse a string describing a filter graph.
 282  */
 283 int avfilter_parse_graph(AVFilterGraph *graph, const char *filters,
 284                          AVFilterContext *in, int inpad,
 285                          AVFilterContext *out, int outpad,
 286                          AVClass *log_ctx)
 287 {
 288     AVFilterInOut *inout=NULL;
 289     AVFilterInOut  *head=NULL;
 290
 291     int index = 0;
 292     char chr = 0;
 293     int pad = 0;
 294     int has_out = 0;
 295
 296     AVFilterContext *last_filt = NULL;
 297
 298     do {
 299         AVFilterContext *filter;
 300         int oldpad = pad;
 301         const char *inouts;
 302
 303         consume_whitespace(&filters);
 304         inouts = filters;
 305
 306         // We need to parse the inputs of the filter after we create it, so
 307         // skip it by now
 308         filters = skip_inouts(filters);
 309
 310         if(!(filter = parse_filter(&filters, graph, index, log_ctx)))
 311             goto fail;
 312
 313         pad = parse_inouts(&inouts, &inout, chr == ',', LinkTypeIn, filter,
 314                            log_ctx);
 315
 316         if(pad < 0)
 317             goto fail;
 318
 319         // If the first filter has an input and none was given, it is
 320         // implicitly the input of the whole graph.
 321         if(pad == 0 && filter->input_count == 1) {
 322             if(link_filter(in, inpad, filter, 0, log_ctx))
 323                 goto fail;
 324         }
 325
 326         if(chr == ',') {
 327             if(link_filter(last_filt, oldpad, filter, 0, log_ctx) < 0)
 328                 goto fail;
 329         }
 330
 331         pad = parse_inouts(&filters, &inout, 0, LinkTypeOut, filter, log_ctx);
 332
 333         if (pad < 0)
 334             goto fail;
 335
 336         consume_whitespace(&filters);
 337
 338         chr = *filters++;
 339         index++;
 340         last_filt = filter;
 341     } while (chr == ',' || chr == ';');
 342
 343     head = inout;
 344     // Process remaining labels. Only inputs and outputs should be left.
 345     for (; inout; inout = inout->next) {
 346         if(!inout->filter)
 347             continue; // Already processed
 348
 349         if(!strcmp(inout->name, "in")) {
 350             if(link_filter(in, inpad, inout->filter, inout->pad_idx, log_ctx))
 351                 goto fail;
 352
 353         } else if(!strcmp(inout->name, "out")) {
 354             has_out = 1;
 355
 356             if(link_filter(inout->filter, inout->pad_idx, out, outpad, log_ctx))
 357                 goto fail;
 358
 359         } else {
 360             av_log(log_ctx, AV_LOG_ERROR, "Unmatched link: %s.\n",
 361                    inout->name);
 362                 goto fail;
 363         }
 364     }
 365
 366     free_inout(head);
 367
 368     if(!has_out) {
 369         if(link_filter(last_filt, pad, out, outpad, log_ctx))
 370             goto fail;
 371     }
 372
 373     return 0;
 374
 375  fail:
 376     free_inout(head);
 377     avfilter_destroy_graph(graph);
 378     return -1;
 379 }