*   this creates strange graphs ("minlen=0" is better)

 * try puting src/sink ghostpads for each bin into invisible clusters

 *

 * for more compact nodes, try

 * - changing node-shape from box into record

 * - use labels like : element [ label="{element | <src> src | <sink> sink}"]

 * - point to record-connectors : element1:src -> element2:sink

 * - we use head/tail labels for pad-caps right now

 *   - this does not work well, as dot seems to not llok at their sizen when

 *     doing the layout

 *   - we could add the caps to the pad itself, then we should use one line per

 *     caps (simple caps = one line)

#include "gstvalue.h"

const gchar spaces[] = {

  "                                "    /* 32 */

      "                                "        /* 64 */

      "                                "        /* 96 */

      "                                "        /* 128 */

};

    state_name = g_strdup_printf ("\\n[%c] -> [%c]", state_icons[state],

static void

debug_dump_pad (GstPad * pad, gchar * color_name, gchar * element_name,

    FILE * out, const gint indent)

{

  GstPadTemplate *pad_templ;

  GstPadPresence presence;

  gchar *pad_name, *style_name;

  gchar pad_flags[6];

  const gchar *activation_mode = "-><";

  const gchar *spc = &spaces[MAX (sizeof (spaces) - (1 + indent * 2), 0)];

  pad_name = debug_dump_make_object_name (GST_OBJECT (pad));

  /* pad availability */

  style_name = "filled,solid";

  if ((pad_templ = gst_pad_get_pad_template (pad))) {

    presence = GST_PAD_TEMPLATE_PRESENCE (pad_templ);

    if (presence == GST_PAD_SOMETIMES) {

      style_name = "filled,dotted";

    } else if (presence == GST_PAD_REQUEST) {

      style_name = "filled,dashed";

    }

  }

  /* check if pad flags */

  pad_flags[0] = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_BLOCKED) ? 'B' : 'b';

  pad_flags[1] = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLUSHING) ? 'F' : 'f';

  pad_flags[2] = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_IN_GETCAPS) ? 'G' : 'g';

  pad_flags[3] = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_IN_SETCAPS) ? 's' : 's';

  pad_flags[4] = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_BLOCKING) ? 'B' : 'b';

  pad_flags[5] = '\0';

  fprintf (out, "%s  %s_%s [color=black, fillcolor=\"%s\", label=\"%s\\n[%c][%s]\", height=\"0.2\", style=\"%s\"];\n", spc, element_name, pad_name, color_name, GST_OBJECT_NAME (pad), activation_mode[pad->mode],      /* NONE/PUSH/PULL */

      pad_flags, style_name);

  g_free (pad_name);

}

static void

debug_dump_element_pad (GstPad * pad, GstElement * element,

    GstDebugGraphDetails details, FILE * out, const gint indent)

{

  GstElement *target_element;

  GstPad *target_pad, *tmp_pad;

  GstPadDirection dir;

  gchar *pad_name, *element_name;

  gchar *target_element_name;

  gchar *color_name;

  dir = gst_pad_get_direction (pad);

  pad_name = debug_dump_make_object_name (GST_OBJECT (pad));

  element_name = debug_dump_make_object_name (GST_OBJECT (element));

  if (GST_IS_GHOST_PAD (pad)) {

    color_name =

        (dir == GST_PAD_SRC) ? "#ffdddd" : ((dir ==

            GST_PAD_SINK) ? "#ddddff" : "#ffffff");

    /* output target-pad so that it belongs to this element */

    if ((tmp_pad = gst_ghost_pad_get_target (GST_GHOST_PAD (pad)))) {

      if ((target_pad = gst_pad_get_peer (tmp_pad))) {

        if ((target_element = gst_pad_get_parent_element (target_pad))) {

          target_element_name =

              debug_dump_make_object_name (GST_OBJECT (target_element));

        } else {

          target_element_name = "";

        }

        debug_dump_pad (target_pad, color_name, target_element_name, out,

            indent);

        if (target_element) {

          g_free (target_element_name);

          gst_object_unref (target_element);

        }

        gst_object_unref (target_pad);

      }

      gst_object_unref (tmp_pad);

    }

  } else {

    color_name =

        (dir == GST_PAD_SRC) ? "#ffaaaa" : ((dir ==

            GST_PAD_SINK) ? "#aaaaff" : "#cccccc");

  }

  /* pads */

  debug_dump_pad (pad, color_name, element_name, out, indent);

  g_free (element_name);

}

static gboolean

string_append_field (GQuark field, const GValue * value, gpointer ptr)

{

  GString *str = (GString *) ptr;

  gchar *value_str = gst_value_serialize (value);

  /* some enums can become really long */

  if (strlen (value_str) > 25) {

    gint pos = 24;

    /* truncate */

    value_str[25] = '\0';

    /* mirror any brackets */

    if (value_str[0] == '<')

      value_str[pos--] = '>';

    if (value_str[0] == '[')

      value_str[pos--] = ']';

    if (value_str[0] == '(')

      value_str[pos--] = ')';

    if (value_str[0] == '{')

      value_str[pos--] = '}';

    if (pos != 24)

      value_str[pos--] = ' ';

    /* elippsize */

    value_str[pos--] = '.';

    value_str[pos--] = '.';

    value_str[pos--] = '.';

  }

  g_string_append_printf (str, "  %18s: %s\\l", g_quark_to_string (field),

      value_str);

  g_free (value_str);

  return TRUE;

}

static gchar *

debug_dump_describe_caps (GstCaps * caps, GstDebugGraphDetails details,

    gboolean * need_free)

{

  gchar *media = NULL;

  if (details & GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS) {

    if (gst_caps_is_any (caps) || gst_caps_is_empty (caps)) {

      media = gst_caps_to_string (caps);

      *need_free = TRUE;

    } else {

      GString *str = NULL;

      guint i;

      guint slen = 0;

      for (i = 0; i < gst_caps_get_size (caps); i++) {

        slen += 25 +

            STRUCTURE_ESTIMATED_STRING_LEN (gst_caps_get_structure (caps, i));

      }

      str = g_string_sized_new (slen);

      for (i = 0; i < gst_caps_get_size (caps); i++) {

        GstStructure *structure = gst_caps_get_structure (caps, i);

        g_string_append (str, gst_structure_get_name (structure));

        g_string_append (str, "\\l");

        gst_structure_foreach (structure, string_append_field, (gpointer) str);

      }

      media = g_string_free (str, FALSE);

      *need_free = TRUE;

    }

  } else {

    if (GST_CAPS_IS_SIMPLE (caps))

      media =

          (gchar *) gst_structure_get_name (gst_caps_get_structure (caps, 0));

    else

      media = "*";

    *need_free = FALSE;

  }

  return media;

}

static void

debug_dump_element_pad_link (GstPad * pad, GstElement * element,

    GstDebugGraphDetails details, FILE * out, const gint indent)

{

  GstElement *peer_element, *target_element;

  GstPad *peer_pad, *target_pad, *tmp_pad;

  GstCaps *caps, *peer_caps;

  gboolean free_caps, free_peer_caps;

  gboolean free_media, free_media_src, free_media_sink;

  gchar *media = NULL;

  gchar *media_src = NULL, *media_sink = NULL;

  gchar *pad_name, *element_name;

  gchar *peer_pad_name, *peer_element_name;

  gchar *target_pad_name, *target_element_name;

  const gchar *spc = &spaces[MAX (sizeof (spaces) - (1 + indent * 2), 0)];

  if ((peer_pad = gst_pad_get_peer (pad))) {

    free_media = free_media_src = free_media_sink = FALSE;

    if ((details & GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE) ||

        (details & GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS)

        ) {

      if ((caps = gst_pad_get_negotiated_caps (pad))) {

        free_caps = TRUE;

      } else {

        free_caps = FALSE;

        if (!(caps = (GstCaps *)

                gst_pad_get_pad_template_caps (pad))) {

          /* this should not happen */

          media = "?";

        }

      }

      if ((peer_caps = gst_pad_get_negotiated_caps (peer_pad))) {

        free_peer_caps = TRUE;

      } else {

        free_peer_caps = FALSE;

        peer_caps = (GstCaps *) gst_pad_get_pad_template_caps (peer_pad);

      }

      if (caps) {

        media = debug_dump_describe_caps (caps, details, &free_media);

        /* check if peer caps are different */

        if (peer_caps && !gst_caps_is_equal (caps, peer_caps)) {

          gchar *tmp;

          gboolean free_tmp;

          tmp = debug_dump_describe_caps (peer_caps, details, &free_tmp);

          if (gst_pad_get_direction (pad) == GST_PAD_SRC) {

            media_src = media;

            free_media_src = free_media;

            media_sink = tmp;

            free_media_sink = free_tmp;

          } else {

            media_src = tmp;

            free_media_src = free_tmp;

            media_sink = media;

            free_media_sink = free_media;

          }

          media = NULL;

          free_media = FALSE;

        }

        if (free_caps) {

          gst_caps_unref (caps);

        }

      }

      if (free_peer_caps && peer_caps) {

        gst_caps_unref (peer_caps);

      }

    }

    pad_name = debug_dump_make_object_name (GST_OBJECT (pad));

    if (element) {

      element_name = debug_dump_make_object_name (GST_OBJECT (element));

    } else {

      element_name = "";

    }

    peer_pad_name = debug_dump_make_object_name (GST_OBJECT (peer_pad));

    if ((peer_element = gst_pad_get_parent_element (peer_pad))) {

      peer_element_name =

          debug_dump_make_object_name (GST_OBJECT (peer_element));

    } else {

      peer_element_name = "";

    }

    if (GST_IS_GHOST_PAD (pad)) {

      if ((tmp_pad = gst_ghost_pad_get_target (GST_GHOST_PAD (pad)))) {

        if ((target_pad = gst_pad_get_peer (tmp_pad))) {

          target_pad_name =

              debug_dump_make_object_name (GST_OBJECT (target_pad));

          if ((target_element = gst_pad_get_parent_element (target_pad))) {

            target_element_name =

                debug_dump_make_object_name (GST_OBJECT (target_element));

          } else {

            target_element_name = "";

          }

          /* src ghostpad relationship */

          fprintf (out, "%s%s_%s -> %s_%s [style=dashed, minlen=0]\n", spc,

              target_element_name, target_pad_name, element_name, pad_name);

          g_free (target_pad_name);

          if (target_element) {

            g_free (target_element_name);

            gst_object_unref (target_element);

          }

          gst_object_unref (target_pad);

        }

        gst_object_unref (tmp_pad);

      }

    }

    if (GST_IS_GHOST_PAD (peer_pad)) {

      if ((tmp_pad = gst_ghost_pad_get_target (GST_GHOST_PAD (peer_pad)))) {

        if ((target_pad = gst_pad_get_peer (tmp_pad))) {

          target_pad_name =

              debug_dump_make_object_name (GST_OBJECT (target_pad));

          if ((target_element = gst_pad_get_parent_element (target_pad))) {

            target_element_name =

                debug_dump_make_object_name (GST_OBJECT (target_element));

          } else {

            target_element_name = "";

          }

          /* sink ghostpad relationship */

          fprintf (out, "%s%s_%s -> %s_%s [style=dashed, minlen=0]\n", spc,

              peer_element_name, peer_pad_name,

              target_element_name, target_pad_name);

          /* FIXME: we are missing links from the proxy pad

           * theoretically we need to:

           * pad=gst_object_ref(target_pad);

           * goto line 280: if ((peer_pad = gst_pad_get_peer (pad)))

           * as this would be ugly we need to refactor ...

           */

          debug_dump_element_pad_link (target_pad, target_element, details, out,

              indent);

          g_free (target_pad_name);

          if (target_element) {

            g_free (target_element_name);

            gst_object_unref (target_element);

          }

          gst_object_unref (target_pad);

        }

        gst_object_unref (tmp_pad);

      }

    }

    /* pad link */

    if (media) {

      fprintf (out, "%s%s_%s -> %s_%s [label=\"%s\"]\n", spc,

          element_name, pad_name, peer_element_name, peer_pad_name, media);

      if (free_media) {

        g_free (media);

      }

    } else if (media_src && media_sink) {

      /* dot has some issues with placement of head and taillabels,

       * we need an empty label to make space */

      fprintf (out, "%s%s_%s -> %s_%s [labeldistance=\"10\", labelangle=\"0\", "

          "label=\"                                                  \", "

          "headlabel=\"%s\", taillabel=\"%s\"]\n",

          spc, element_name, pad_name, peer_element_name, peer_pad_name,

          media_src, media_sink);

      if (free_media_src)

        g_free (media_src);

      if (free_media_sink)

        g_free (media_sink);

    } else {

      fprintf (out, "%s%s_%s -> %s_%s\n", spc,

          element_name, pad_name, peer_element_name, peer_pad_name);

    }

    g_free (pad_name);

    if (element) {

      g_free (element_name);

    }

    g_free (peer_pad_name);

    if (peer_element) {

      g_free (peer_element_name);

      gst_object_unref (peer_element);

    }

    gst_object_unref (peer_pad);

  }

}

  GstElement *element;

  GstPad *pad;

  gchar *element_name;