gstreamer/docs/manual/helloworld2.sgml

<chapter id="cha-hello2">
  <title>Your second application</title>
  <para> 
    In the previous chapter we created a first version of the helloworld
    application. We then explained a better way of creating the elements
    using factories identified by MIME types.
  </para>
  <para> 
    In this chapter we will introduce you to autoplugging. Using the MIME
    types of the elements GStreamer can automatically create a pipeline
    for you.
  </para>

  <sect1>
    <title>Autoplugging helloworld</title>
    <para> 
      We will create a second version of the helloworld application using
      autoplugging. Its source code is considerably more easy to write and
      can also much more data types.
    </para>

    <programlisting>

#include &lt;gst/gst.h&gt;

static gboolean playing;

/* eos will be called when the src element has an end os stream */
void eos(GstSrc *src) 
{
  g_print("have eos, quitting\n");

  playing = FALSE;
}

int main(int argc,char *argv[]) 
{
  GstElement *disksrc, *audiosink;
  GstPipeline *pipeline;

  if (argc != 2) {
    g_print("usage: %s &lt;filename&gt;\n", argv[0]);
    exit(-1);
  }

  gst_init(&amp;argc,&amp;argv);
  gst_plugin_load_all();
  g_print("\n");

  /* create a new bin to hold the elements */
  pipeline = gst_pipeline_new("pipeline");

  /* create a disk reader */
  disksrc = gst_elementfactory_make("disksrc", "disk_source");
  gtk_object_set(GTK_OBJECT(disksrc),"location", argv[1],NULL);
  gtk_signal_connect(GTK_OBJECT(disksrc),"eos",
                     GTK_SIGNAL_FUNC(eos),NULL);

  /* and an audio sink */
  audiosink = gst_elementfactory_make("audiosink", "play_audio");

  /* add objects to the main pipeline */
  gst_bin_add(GST_BIN(pipeline), disksrc);
  gst_bin_add(GST_BIN(pipeline), audiosink);

  if (!gst_pipeline_autoplug(pipeline)) {
    g_print("unable to handle stream\n");
    exit(-1);
  }

  /* find out how to handle this bin */
  gst_bin_create_plan(GST_BIN(pipeline));

  /* make it ready */
  gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_READY);
  /* start playing */
  gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING);

  playing = TRUE;

  while (playing) {
    gst_bin_iterate(GST_BIN(pipeline));
  }

  /* stop the bin */
  gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_NULL);

  gst_pipeline_destroy(pipeline);

  exit(0);
}

    </programlisting>

    <para>
      first of all, we do not use any mpg123 or mp3parse element in this example.
      In fact, we only specify a source element and a sink element and add them
      to a pipeline.
    </para>

    <para>
      The most interesting change however is the following:
    </para>
    <programlisting>

  ...
  if (!gst_pipeline_autoplug(pipeline)) {
    g_print("unable to handle stream\n");
    exit(-1);
  }
  ...

    </programlisting>

    <para>
      This piece of code does all the magic.
    </para>

    <para>
      <itemizedlist>
        <listitem>
          <para>
            The source and the sink elements will be found inside the pipeline
          </para>
        </listitem>
        <listitem>
          <para>
            Since the source has no type, a typedetection will be started on
	    the source element.
          </para>
        </listitem>
        <listitem>
          <para>
	    The best set of elements that connect the MIME type of the source 
	    element to the MIME type of the sink are found.
          </para>
        </listitem>
        <listitem>
          <para>
	    The elements are added to the pipeline and their pads are connected.
          </para>
        </listitem>
      </itemizedlist>
    </para>

    <para>
      After this autoplugging, the pipeline is ready to play. Remember that this
      pipeline will be able to playback all of the media types for which an
      appropriate plugin exists since the autoplugging is all done using MIME
      types.
    </para>

    <para>
      I you really want, you can use the GSteamer components to do the 
      autoplugging yourself. 
    </para>

    <para>
      To compile the helloworld2 example, use: 
    </para>
    <programlisting>
       gcc -Wall `gstreamer-config --cflags` `gtk-config --cflags` helloworld2.c \
             -o helloworld2 `gstreamer-config --libs` `gtk-config --libs`
    </programlisting>
    <para>
      You can run the example with (substitute helloworld.mp3 with you favorite MP3 file):
    </para>
    <programlisting>
      ./helloworld2 helloworld.mp3
    </programlisting>
    <para>
      You can also try to use an AVI or MPEG file as its input. Using autoplugging,
      GStreamer will automatically figure out how to handle the stream. Remember that
      only the audio part will be played because we have only added an audiosink to
      the pipeline.
    </para>
    <programlisting>
      ./helloworld2 helloworld.mpeg
    </programlisting>

  </sect1>
</chapter>