libavfilter/avfiltergraph.c

   1 /*
   2  * filter graphs
   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 void uninit(AVFilterGraph *graph)
  45 {
  46     for(; graph->filter_count > 0; graph->filter_count --)
  47         avfilter_destroy(graph->filters[graph->filter_count - 1]);
  48     av_freep(&graph->filters);
  49 }
  50
  51 /* TODO: insert in sorted order */
  52 void avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter)
  53 {
  54     graph->filters = av_realloc(graph->filters,
  55                                 sizeof(AVFilterContext*) * ++graph->filter_count);
  56     graph->filters[graph->filter_count - 1] = filter;
  57 }
  58
  59 /* search intelligently, once we insert in order */
  60 AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name)
  61 {
  62     int i;
  63
  64     if(!name)
  65         return NULL;
  66
  67     for(i = 0; i < graph->filter_count; i ++)
  68         if(graph->filters[i]->name && !strcmp(name, graph->filters[i]->name))
  69             return graph->filters[i];
  70
  71     return NULL;
  72 }
  73
  74 static int query_formats(AVFilterGraph *graph)
  75 {
  76     int i, j;
  77
  78     /* ask all the sub-filters for their supported colorspaces */
  79     for(i = 0; i < graph->filter_count; i ++) {
  80         if(graph->filters[i]->filter->query_formats)
  81             graph->filters[i]->filter->query_formats(graph->filters[i]);
  82         else
  83             avfilter_default_query_formats(graph->filters[i]);
  84     }
  85
  86     /* go through and merge as many format lists as possible */
  87     for(i = 0; i < graph->filter_count; i ++) {
  88         AVFilterContext *filter = graph->filters[i];
  89
  90         for(j = 0; j < filter->input_count; j ++) {
  91             AVFilterLink *link;
  92             if(!(link = filter->inputs[j]))
  93                 continue;
  94             if(link->in_formats != link->out_formats) {
  95                 if(!avfilter_merge_formats(link->in_formats,
  96                                            link->out_formats)) {
  97                     /* couldn't merge format lists. auto-insert scale filter */
  98                     AVFilterContext *scale;
  99
 100                     if(!(scale =
 101                          avfilter_open(avfilter_get_by_name("scale"), NULL)))
 102                         return -1;
 103                     if(scale->filter->init(scale, NULL, NULL) ||
 104                        avfilter_insert_filter(link, scale, 0, 0)) {
 105                         avfilter_destroy(scale);
 106                         return -1;
 107                     }
 108
 109                     avfilter_graph_add_filter(graph, scale);
 110                     scale->filter->query_formats(scale);
 111                     if(!avfilter_merge_formats(scale-> inputs[0]->in_formats,
 112                                               scale-> inputs[0]->out_formats) ||
 113                        !avfilter_merge_formats(scale->outputs[0]->in_formats,
 114                                               scale->outputs[0]->out_formats))
 115                         return -1;
 116                 }
 117             }
 118         }
 119     }
 120
 121     return 0;
 122 }
 123
 124 static void pick_format(AVFilterLink *link)
 125 {
 126     if(!link || !link->in_formats)
 127         return;
 128
 129     link->in_formats->format_count = 1;
 130     link->format = link->in_formats->formats[0];
 131
 132     avfilter_formats_unref(&link->in_formats);
 133     avfilter_formats_unref(&link->out_formats);
 134 }
 135
 136 static void pick_formats(AVFilterGraph *graph)
 137 {
 138     int i, j;
 139
 140     for(i = 0; i < graph->filter_count; i ++) {
 141         AVFilterContext *filter = graph->filters[i];
 142
 143         for(j = 0; j < filter->input_count; j ++)
 144             pick_format(filter->inputs[j]);
 145         for(j = 0; j < filter->output_count; j ++)
 146             pick_format(filter->outputs[j]);
 147     }
 148 }
 149
 150 int avfilter_graph_config_formats(AVFilterGraph *graph)
 151 {
 152     /* find supported formats from sub-filters, and merge along links */
 153     if(query_formats(graph))
 154         return -1;
 155
 156     /* Once everything is merged, it's possible that we'll still have
 157      * multiple valid colorspace choices. We pick the first one. */
 158     pick_formats(graph);
 159
 160     return 0;
 161 }
 162
 163 static int graph_load_from_desc2(AVFilterGraph *ctx, AVFilterGraphDesc *desc)
 164 {
 165     AVFilterGraphDescFilter *curfilt;
 166     AVFilterGraphDescLink   *curlink;
 167     AVFilterContext *filt, *filtb;
 168
 169     AVFilter *filterdef;
 170     char tmp[20];
 171
 172     /* create all filters */
 173     for(curfilt = desc->filters; curfilt; curfilt = curfilt->next) {
 174         snprintf(tmp, 20, "%d", curfilt->index);
 175         if(!(filterdef = avfilter_get_by_name(curfilt->filter)) ||
 176            !(filt = avfilter_open(filterdef, tmp))) {
 177             av_log(&log_ctx, AV_LOG_ERROR,
 178                "error creating filter '%s'\n", curfilt->filter);
 179             goto fail;
 180         }
 181         avfilter_graph_add_filter(ctx, filt);
 182         if(avfilter_init_filter(filt, curfilt->args, NULL)) {
 183             av_log(&log_ctx, AV_LOG_ERROR,
 184                 "error initializing filter '%s'\n", curfilt->filter);
 185             goto fail;
 186         }
 187     }
 188
 189     /* create all links */
 190     for(curlink = desc->links; curlink; curlink = curlink->next) {
 191         snprintf(tmp, 20, "%d", curlink->src);
 192         if(!(filt = avfilter_graph_get_filter(ctx, tmp))) {
 193             av_log(&log_ctx, AV_LOG_ERROR, "link source does not exist in graph\n");
 194             goto fail;
 195         }
 196         snprintf(tmp, 20, "%d", curlink->dst);
 197         if(!(filtb = avfilter_graph_get_filter(ctx, tmp))) {
 198             av_log(&log_ctx, AV_LOG_ERROR, "link destination does not exist in graph\n");
 199             goto fail;
 200         }
 201         if(avfilter_link(filt, curlink->srcpad, filtb, curlink->dstpad)) {
 202             av_log(&log_ctx, AV_LOG_ERROR, "cannot create link between source and destination filters\n");
 203             goto fail;
 204         }
 205     }
 206
 207     return 0;
 208
 209 fail:
 210     uninit(ctx);
 211     return -1;
 212 }
 213
 214 int graph_load_from_desc3(AVFilterGraph *graph, AVFilterGraphDesc *desc, AVFilterContext *in, int inpad, AVFilterContext *out, int outpad)
 215 {
 216     AVFilterGraphDescExport *curpad;
 217     char tmp[20];
 218     AVFilterContext *filt;
 219
 220     if (graph_load_from_desc2(graph, desc) < 0)
 221         goto fail;
 222
 223     /* export all input pads */
 224     for(curpad = desc->inputs; curpad; curpad = curpad->next) {
 225         snprintf(tmp, 20, "%d", curpad->filter);
 226         if(!(filt = avfilter_graph_get_filter(graph, tmp))) {
 227             av_log(&log_ctx, AV_LOG_ERROR, "filter owning exported pad does not exist\n");
 228             goto fail;
 229         }
 230         if(avfilter_link(in, inpad, filt, curpad->pad)) {
 231             av_log(&log_ctx, AV_LOG_ERROR, "cannot create link between source and destination filters\n");
 232             goto fail;
 233         }
 234     }
 235
 236     /* export all output pads */
 237     for(curpad = desc->outputs; curpad; curpad = curpad->next) {
 238         snprintf(tmp, 20, "%d", curpad->filter);
 239         if(!(filt = avfilter_graph_get_filter(graph, tmp))) {
 240             av_log(&log_ctx, AV_LOG_ERROR, "filter owning exported pad does not exist\n");
 241             goto fail;
 242         }
 243
 244         if(avfilter_link(filt, curpad->pad, out, outpad)) {
 245             av_log(&log_ctx, AV_LOG_ERROR, "cannot create link between source and destination filters\n");
 246             goto fail;
 247         }
 248     }
 249
 250     return 0;
 251
 252 fail:
 253     uninit(graph);
 254     return -1;
 255 }
 256
 257
 258 static void consume_whitespace(const char **buf)
 259 {
 260     *buf += strspn(*buf, " \n\t");
 261 }
 262
 263 /**
 264  * get the next non-whitespace char
 265  */
 266 static char consume_char(const char **buf)
 267 {
 268     char out;
 269     consume_whitespace(buf);
 270
 271     out = **buf;
 272
 273     if (out)
 274         (*buf)++;
 275
 276     return out;
 277 }
 278
 279 /**
 280  * remove the quotation marks from a string. Ex: "aaa'bb'cc" -> "aaabbcc"
 281  */
 282 static void unquote(char *str)
 283 {
 284     char *p1, *p2;
 285     p1=p2=str;
 286     while (*p1 != 0) {
 287         if (*p1 != '\'')
 288             *p2++ = *p1;
 289         p1++;
 290     }
 291
 292     *p2 = 0;
 293 }
 294
 295 /**
 296  * Consumes a string from *buf.
 297  * @return a copy of the consumed string, which should be free'd after use
 298  */
 299 static char *consume_string(const char **buf)
 300 {
 301     const char *start;
 302     char *ret;
 303     int size;
 304
 305     consume_whitespace(buf);
 306
 307     if (!(**buf))
 308         return av_mallocz(1);
 309
 310     start = *buf;
 311
 312     *buf += strcspn(*buf, " ()=,'");
 313
 314     if (**buf == '\'') {
 315         char *p = strchr(*buf + 1, '\'');
 316         if (p)
 317             *buf = p + 1;
 318         else
 319             *buf += strlen(*buf); // Move the pointer to the null end byte
 320     }
 321
 322     size = *buf - start + 1;
 323     ret = av_malloc(size);
 324     memcpy(ret, start, size - 1);
 325     ret[size-1] = 0;
 326
 327     unquote(ret);
 328
 329     return ret;
 330 }
 331
 332 /**
 333  * Parse "(linkname)"
 334  * @arg name a pointer (that need to be free'd after use) to the name between
 335  *           parenthesis
 336  */
 337 static void parse_link_name(const char **buf, char **name)
 338 {
 339     consume_char(buf);
 340
 341     *name = consume_string(buf);
 342
 343     if (!*name[0])
 344         goto fail;
 345
 346     if (consume_char(buf) != ')')
 347         goto fail;
 348
 349     return;
 350  fail:
 351     av_freep(name);
 352     av_log(&log_ctx, AV_LOG_ERROR, "Could not parse link name!\n");
 353 }
 354
 355 /**
 356  * Parse "filter=params"
 357  * @arg name a pointer (that need to be free'd after use) to the name of the
 358  *           filter
 359  * @arg ars  a pointer (that need to be free'd after use) to the args of the
 360  *           filter
 361  */
 362 static void parse_filter(const char **buf, char **name, char **opts)
 363 {
 364     *name = consume_string(buf);
 365
 366     if (**buf == '=') {
 367         consume_char(buf);
 368         *opts = consume_string(buf);
 369     } else {
 370         *opts = NULL;
 371     }
 372
 373 }
 374
 375 enum LinkType {
 376     LinkTypeIn,
 377     LinkTypeOut,
 378 };
 379
 380 /**
 381  * A linked-list of the inputs/outputs of the filter chain.
 382  */
 383 typedef struct AVFilterInOut {
 384     enum LinkType type;
 385     char *name;
 386     int instance;
 387     int pad_idx;
 388
 389     struct AVFilterInOut *next;
 390 } AVFilterInOut;
 391
 392 static void free_inout(AVFilterInOut *head)
 393 {
 394     while (head) {
 395         AVFilterInOut *next;
 396         next = head->next;
 397         av_free(head);
 398         head = next;
 399     }
 400 }
 401
 402 /**
 403  * Parse "(a1)(link2) ... (etc)"
 404  */
 405 static int parse_inouts(const char **buf, AVFilterInOut **inout, int firstpad,
 406                         enum LinkType type, int instance)
 407 {
 408     int pad = firstpad;
 409     while (**buf == '(') {
 410         AVFilterInOut *inoutn = av_malloc(sizeof(AVFilterInOut));
 411         parse_link_name(buf, &inoutn->name);
 412         inoutn->type = type;
 413         inoutn->instance = instance;
 414         inoutn->pad_idx = pad++;
 415         inoutn->next = *inout;
 416         *inout = inoutn;
 417     }
 418     return pad;
 419 }
 420
 421 static AVFilterGraphDesc *parse_chain(const char *filters, int has_in)
 422 {
 423     AVFilterGraphDesc        *ret;
 424     AVFilterGraphDescFilter **filterp, *filtern;
 425     AVFilterGraphDescLink   **linkp,   *linkn;
 426     AVFilterInOut           *inout=NULL;
 427     AVFilterInOut           *head;
 428
 429     int index = 0;
 430     char chr = 0;
 431     int pad = 0;
 432     int has_out = 0;
 433
 434     consume_whitespace(&filters);
 435
 436     if(!(ret = av_mallocz(sizeof(AVFilterGraphDesc))))
 437         return NULL;
 438
 439     filterp = &ret->filters;
 440     linkp   = &ret->links;
 441
 442     do {
 443         if(chr == ',') {
 444             linkn = av_mallocz(sizeof(AVFilterGraphDescLink));
 445             linkn->src = index-1;
 446             linkn->srcpad = pad;
 447             linkn->dst = index;
 448             linkn->dstpad = 0;
 449
 450             *linkp = linkn;
 451             linkp = &linkn->next;
 452         }
 453         pad = parse_inouts(&filters, &inout, chr == ',' || (!has_in),
 454                            LinkTypeIn, index);
 455
 456         filtern = av_mallocz(sizeof(AVFilterGraphDescFilter));
 457         filtern->index = index;
 458         parse_filter(&filters, &filtern->filter, &filtern->args);
 459         *filterp = filtern;
 460         filterp = &filtern->next;
 461
 462         pad = parse_inouts(&filters, &inout, 0,
 463                            LinkTypeOut, index);
 464         chr = consume_char(&filters);
 465         index++;
 466     } while (chr == ',' || chr == ';');
 467
 468     head = inout;
 469     for (; inout != NULL; inout = inout->next) {
 470         if (inout->instance == -1)
 471             continue; // Already processed
 472
 473         if (!strcmp(inout->name, "in")) {
 474             if (!has_in)
 475                 goto fail;
 476             ret->inputs = av_mallocz(sizeof(AVFilterGraphDescExport));
 477             ret->inputs->filter = inout->instance;
 478             ret->inputs->pad = inout->pad_idx;
 479         } else if (!strcmp(inout->name, "out")) {
 480             has_out = 1;
 481             ret->outputs = av_mallocz(sizeof(AVFilterGraphDescExport));
 482             ret->outputs->filter = inout->instance;
 483             ret->outputs->pad = inout->pad_idx;
 484         } else {
 485             AVFilterInOut *p, *src, *dst;
 486             for (p = inout->next;
 487                  p && strcmp(p->name,inout->name); p = p->next);
 488
 489             if (!p) {
 490                 av_log(&log_ctx, AV_LOG_ERROR, "Unmatched link: %s.\n",
 491                        inout->name);
 492                 goto fail;
 493             }
 494
 495             if (p->type == LinkTypeIn && inout->type == LinkTypeOut) {
 496                 src = inout;
 497                 dst = p;
 498             } else if (p->type == LinkTypeOut && inout->type == LinkTypeIn) {
 499                 src = p;
 500                 dst = inout;
 501             } else {
 502                 av_log(&log_ctx, AV_LOG_ERROR, "Two links named '%s' are either both input or both output\n",
 503                        inout->name);
 504                 goto fail;
 505             }
 506             linkn = av_mallocz(sizeof(AVFilterGraphDescLink));
 507
 508             linkn->src = src->instance;
 509             linkn->srcpad = src->pad_idx;
 510             linkn->dst = dst->instance;
 511             linkn->dstpad = dst->pad_idx;
 512
 513             *linkp = linkn;
 514             linkp = &linkn->next;
 515
 516             src->instance = -1;
 517             dst->instance = -1;
 518         }
 519     }
 520
 521     free_inout(head);
 522
 523     if (!has_in) {
 524         ret->inputs = av_mallocz(sizeof(AVFilterGraphDescExport));
 525         ret->inputs->filter = 0;
 526     }
 527     if (!has_out) {
 528         ret->outputs = av_mallocz(sizeof(AVFilterGraphDescExport));
 529         ret->outputs->filter = index-1;
 530     }
 531
 532     return ret;
 533
 534  fail:
 535     free_inout(head);
 536
 537     avfilter_graph_free_desc(ret);
 538     return NULL;
 539 }
 540
 541 /**
 542  * Parse a string describing a filter graph.
 543  */
 544 AVFilterGraphDesc *avfilter_graph_parse_chain(const char *filters)
 545 {
 546     AVFilterGraphDesc *ret;
 547
 548     /* Try first to parse supposing there is no (in) element */
 549     if ((ret = parse_chain(filters, 0)))
 550         return ret;
 551
 552     /* Parse supposing there is an (in) element */
 553     return parse_chain(filters, 1);
 554 }
 555
 556 /**
 557  * Free a graph description.
 558  */
 559 void avfilter_graph_free_desc(AVFilterGraphDesc *desc)
 560 {
 561     void *next;
 562
 563     while(desc->filters) {
 564         next = desc->filters->next;
 565         av_free(desc->filters->filter);
 566         av_free(desc->filters->args);
 567         av_free(desc->filters);
 568         desc->filters = next;
 569     }
 570
 571     while(desc->links) {
 572         next = desc->links->next;
 573         av_free(desc->links);
 574         desc->links = next;
 575     }
 576
 577     while(desc->inputs) {
 578         next = desc->inputs->next;
 579         av_free(desc->inputs);
 580         desc->inputs = next;
 581     }
 582
 583     while(desc->outputs) {
 584         next = desc->outputs->next;
 585         av_free(desc->outputs);
 586         desc->outputs = next;
 587     }
 588 }
 589