Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2008-2010 Stefano Sabatini
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. #include "config.h"
  22. #if HAVE_UNISTD_H
  23. #include <unistd.h>             /* getopt */
  24. #endif
  25. #include <stdio.h>
  26. #include <string.h>
  27.  
  28. #include "libavutil/channel_layout.h"
  29. #include "libavutil/mem.h"
  30. #include "libavutil/pixdesc.h"
  31. #include "libavfilter/avfilter.h"
  32.  
  33. #if !HAVE_GETOPT
  34. #include "compat/getopt.c"
  35. #endif
  36.  
  37. static void usage(void)
  38. {
  39.     printf("Convert a libavfilter graph to a dot file.\n");
  40.     printf("Usage: graph2dot [OPTIONS]\n");
  41.     printf("\n"
  42.            "Options:\n"
  43.            "-i INFILE         set INFILE as input file, stdin if omitted\n"
  44.            "-o OUTFILE        set OUTFILE as output file, stdout if omitted\n"
  45.            "-h                print this help\n");
  46. }
  47.  
  48. struct line {
  49.     char data[256];
  50.     struct line *next;
  51. };
  52.  
  53. static void print_digraph(FILE *outfile, AVFilterGraph *graph)
  54. {
  55.     int i, j;
  56.  
  57.     fprintf(outfile, "digraph G {\n");
  58.     fprintf(outfile, "node [shape=box]\n");
  59.     fprintf(outfile, "rankdir=LR\n");
  60.  
  61.     for (i = 0; i < graph->nb_filters; i++) {
  62.         char filter_ctx_label[128];
  63.         const AVFilterContext *filter_ctx = graph->filters[i];
  64.  
  65.         snprintf(filter_ctx_label, sizeof(filter_ctx_label), "%s\\n(%s)",
  66.                  filter_ctx->name,
  67.                  filter_ctx->filter->name);
  68.  
  69.         for (j = 0; j < filter_ctx->nb_outputs; j++) {
  70.             AVFilterLink *link = filter_ctx->outputs[j];
  71.             if (link) {
  72.                 char dst_filter_ctx_label[128];
  73.                 const AVFilterContext *dst_filter_ctx = link->dst;
  74.  
  75.                 snprintf(dst_filter_ctx_label, sizeof(dst_filter_ctx_label),
  76.                          "%s\\n(%s)",
  77.                          dst_filter_ctx->name,
  78.                          dst_filter_ctx->filter->name);
  79.  
  80.                 fprintf(outfile, "\"%s\" -> \"%s\" [ label= \"inpad:%s -> outpad:%s\\n",
  81.                         filter_ctx_label, dst_filter_ctx_label,
  82.                         avfilter_pad_get_name(link->srcpad, 0),
  83.                         avfilter_pad_get_name(link->dstpad, 0));
  84.  
  85.                 if (link->type == AVMEDIA_TYPE_VIDEO) {
  86.                     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);
  87.                     fprintf(outfile,
  88.                             "fmt:%s w:%d h:%d tb:%d/%d",
  89.                             desc->name,
  90.                             link->w, link->h,
  91.                             link->time_base.num, link->time_base.den);
  92.                 } else if (link->type == AVMEDIA_TYPE_AUDIO) {
  93.                     char buf[255];
  94.                     av_get_channel_layout_string(buf, sizeof(buf), -1,
  95.                                                  link->channel_layout);
  96.                     fprintf(outfile,
  97.                             "fmt:%s sr:%d cl:%s tb:%d/%d",
  98.                             av_get_sample_fmt_name(link->format),
  99.                             link->sample_rate, buf,
  100.                             link->time_base.num, link->time_base.den);
  101.                 }
  102.                 fprintf(outfile, "\" ];\n");
  103.             }
  104.         }
  105.     }
  106.     fprintf(outfile, "}\n");
  107. }
  108.  
  109. int main(int argc, char **argv)
  110. {
  111.     const char *outfilename = NULL;
  112.     const char *infilename  = NULL;
  113.     FILE *outfile           = NULL;
  114.     FILE *infile            = NULL;
  115.     char *graph_string      = NULL;
  116.     AVFilterGraph *graph = av_mallocz(sizeof(AVFilterGraph));
  117.     char c;
  118.  
  119.     av_log_set_level(AV_LOG_DEBUG);
  120.  
  121.     while ((c = getopt(argc, argv, "hi:o:")) != -1) {
  122.         switch (c) {
  123.         case 'h':
  124.             usage();
  125.             return 0;
  126.         case 'i':
  127.             infilename = optarg;
  128.             break;
  129.         case 'o':
  130.             outfilename = optarg;
  131.             break;
  132.         case '?':
  133.             return 1;
  134.         }
  135.     }
  136.  
  137.     if (!infilename || !strcmp(infilename, "-"))
  138.         infilename = "/dev/stdin";
  139.     infile = fopen(infilename, "r");
  140.     if (!infile) {
  141.         fprintf(stderr, "Failed to open input file '%s': %s\n",
  142.                 infilename, strerror(errno));
  143.         return 1;
  144.     }
  145.  
  146.     if (!outfilename || !strcmp(outfilename, "-"))
  147.         outfilename = "/dev/stdout";
  148.     outfile = fopen(outfilename, "w");
  149.     if (!outfile) {
  150.         fprintf(stderr, "Failed to open output file '%s': %s\n",
  151.                 outfilename, strerror(errno));
  152.         return 1;
  153.     }
  154.  
  155.     /* read from infile and put it in a buffer */
  156.     {
  157.         int64_t count = 0;
  158.         struct line *line, *last_line, *first_line;
  159.         char *p;
  160.         last_line = first_line = av_malloc(sizeof(struct line));
  161.         if (!last_line) {
  162.             fprintf(stderr, "Memory allocation failure\n");
  163.             return 1;
  164.         }
  165.  
  166.         while (fgets(last_line->data, sizeof(last_line->data), infile)) {
  167.             struct line *new_line = av_malloc(sizeof(struct line));
  168.             if (!new_line) {
  169.                 fprintf(stderr, "Memory allocation failure\n");
  170.                 return 1;
  171.             }
  172.             count += strlen(last_line->data);
  173.             last_line->next = new_line;
  174.             last_line       = new_line;
  175.         }
  176.         last_line->next = NULL;
  177.  
  178.         graph_string = av_malloc(count + 1);
  179.         if (!graph_string) {
  180.             fprintf(stderr, "Memory allocation failure\n");
  181.             return 1;
  182.         }
  183.         p = graph_string;
  184.         for (line = first_line; line->next; line = line->next) {
  185.             size_t l = strlen(line->data);
  186.             memcpy(p, line->data, l);
  187.             p += l;
  188.         }
  189.         *p = '\0';
  190.     }
  191.  
  192.     avfilter_register_all();
  193.  
  194.     if (avfilter_graph_parse(graph, graph_string, NULL, NULL, NULL) < 0) {
  195.         fprintf(stderr, "Failed to parse the graph description\n");
  196.         return 1;
  197.     }
  198.  
  199.     if (avfilter_graph_config(graph, NULL) < 0)
  200.         return 1;
  201.  
  202.     print_digraph(outfile, graph);
  203.     fflush(outfile);
  204.  
  205.     return 0;
  206. }
  207.