1 /* GStreamer

     2  *

     3  * addstream.c: sample application to dynamically add streams to a running

     4  * pipeline

     5  *

     6  * Copyright (C) <2007> Wim Taymans <wim dot taymans at gmail dot com>

     7  *

     8  * This library is free software; you can redistribute it and/or

     9  * modify it under the terms of the GNU Library General Public

    10  * License as published by the Free Software Foundation; either

    11  * version 2 of the License, or (at your option) any later version.

    12  *

    13  * This library 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  * Library General Public License for more details.

    17  *

    18  * You should have received a copy of the GNU Library General Public

    19  * License along with this library; if not, write to the

    20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    21  * Boston, MA 02111-1307, USA.

    22  */

    23 

    24 #ifdef HAVE_CONFIG_H

    25 #include "config.h"

    26 #endif

    27 

    28 #include <gst/gst.h>

    29 

    30 static GstElement *pipeline;

    31 static GstClock *theclock;

    32 static GMainLoop *loop;

    33 static GstElement *bin1, *bin2, *bin3, *bin4, *bin5;

    34 

    35 /* start a bin with the given description */

    36 static GstElement *

    37 create_stream (const gchar * descr)

    38 {

    39   GstElement *bin;

    40   GError *error = NULL;

    41 

    42   bin = gst_parse_launch (descr, &error);

    43   if (error) {

    44     g_print ("pipeline could not be constructed: %s\n", error->message);

    45     g_error_free (error);

    46     return NULL;

    47   }

    48 

    49   /* add the bin to the pipeline now, this will set the current base_time of the

    50    * pipeline on the new bin. */

    51   gst_bin_add (GST_BIN_CAST (pipeline), bin);

    52 

    53   return bin;

    54 }

    55 

    56 static gboolean

    57 pause_play_stream (GstElement * bin, gint seconds)

    58 {

    59   gboolean punch_in;

    60   GstStateChangeReturn ret;

    61   GstClockTime now, base_time, running_time;

    62 

    63   /* get current running time, we need this value to continue playback of

    64    * non-live pipelines. */

    65   now = gst_clock_get_time (theclock);

    66   base_time = gst_element_get_base_time (bin);

    67 

    68   running_time = now - base_time;

    69 

    70   /* set the new bin to PAUSED, the parent bin will notice (because of the ASYNC

    71    * message and will perform latency calculations again when going to PLAYING

    72    * later. */

    73   ret = gst_element_set_state (bin, GST_STATE_PAUSED);

    74 

    75   switch (ret) {

    76     case GST_STATE_CHANGE_NO_PREROLL:

    77       /* live source, timestamps are running_time of the pipeline clock. */

    78       punch_in = FALSE;

    79       break;

    80     case GST_STATE_CHANGE_SUCCESS:

    81       /* success, no async state changes, same as async, timestamps start

    82        * from 0 */

    83     case GST_STATE_CHANGE_ASYNC:

    84       /* no live source, bin will preroll. We have to punch it in because in

    85        * this situation timestamps start from 0.  */

    86       punch_in = TRUE;

    87       break;

    88     default:

    89     case GST_STATE_CHANGE_FAILURE:

    90       return FALSE;

    91   }

    92 

    93   if (seconds)

    94     g_usleep (seconds * G_USEC_PER_SEC);

    95 

    96   if (punch_in) {

    97     /* new bin has to be aligned with previous running_time. We do this by taking

    98      * the current absolute clock time and calculating the base time that would

    99      * give the previous running_time. We set this base_time on the bin before

   100      * setting it to PLAYING. */

   101     now = gst_clock_get_time (theclock);

   102     base_time = now - running_time;

   103 

   104     gst_element_set_base_time (bin, base_time);

   105   }

   106 

   107   /* now set the pipeline to PLAYING */

   108   gst_element_set_state (bin, GST_STATE_PLAYING);

   109 

   110   return TRUE;

   111 }

   112 

   113 static void

   114 message_received (GstBus * bus, GstMessage * message, GstPipeline * pipeline)

   115 {

   116   const GstStructure *s;

   117 

   118   s = gst_message_get_structure (message);

   119   g_print ("message from \"%s\" (%s): ",

   120       GST_STR_NULL (GST_ELEMENT_NAME (GST_MESSAGE_SRC (message))),

   121       gst_message_type_get_name (GST_MESSAGE_TYPE (message)));

   122   if (s) {

   123     gchar *sstr;

   124 

   125     sstr = gst_structure_to_string (s);

   126     g_print ("%s\n", sstr);

   127     g_free (sstr);

   128   } else {

   129     g_print ("no message details\n");

   130   }

   131 }

   132 

   133 static void

   134 eos_message_received (GstBus * bus, GstMessage * message,

   135     GstPipeline * pipeline)

   136 {

   137   message_received (bus, message, pipeline);

   138   g_main_loop_quit (loop);

   139 }

   140 

   141 static gboolean

   142 perform_step (gpointer pstep)

   143 {

   144   gint step = GPOINTER_TO_INT (pstep);

   145 

   146   switch (step) {

   147     case 0:

   148       /* live stream locks on to running_time, pipeline configures latency. */

   149       g_print ("creating bin1\n");

   150       bin1 =

   151           create_stream

   152           ("( v4l2src ! ffmpegcolorspace ! timeoverlay ! queue ! xvimagesink name=v4llive )");

   153       pause_play_stream (bin1, 0);

   154       g_timeout_add (1000, (GSourceFunc) perform_step, GINT_TO_POINTER (1));

   155       break;

   156     case 1:

   157       /* live stream locks on to running_time, pipeline reconfigures latency

   158        * together with the previously added bin so that they run synchronized. */

   159       g_print ("creating bin2\n");

   160       bin2 = create_stream ("( alsasrc ! queue ! alsasink name=alsalive )");

   161       pause_play_stream (bin2, 0);

   162       g_timeout_add (1000, (GSourceFunc) perform_step, GINT_TO_POINTER (2));

   163       break;

   164     case 2:

   165       /* non-live stream, need base_time to align with current running live sources. */

   166       g_print ("creating bin3\n");

   167       bin3 = create_stream ("( audiotestsrc ! alsasink name=atnonlive )");

   168       pause_play_stream (bin3, 0);

   169       g_timeout_add (1000, (GSourceFunc) perform_step, GINT_TO_POINTER (3));

   170       break;

   171     case 3:

   172       g_print ("creating bin4\n");

   173       bin4 =

   174           create_stream

   175           ("( videotestsrc ! timeoverlay ! ffmpegcolorspace ! ximagesink name=vtnonlive )");

   176       pause_play_stream (bin4, 0);

   177       g_timeout_add (1000, (GSourceFunc) perform_step, GINT_TO_POINTER (4));

   178       break;

   179     case 4:

   180       /* live stream locks on to running_time */

   181       g_print ("creating bin5\n");

   182       bin5 =

   183           create_stream

   184           ("( videotestsrc is-live=1 ! timeoverlay ! ffmpegcolorspace ! ximagesink name=vtlive )");

   185       pause_play_stream (bin5, 0);

   186       g_timeout_add (1000, (GSourceFunc) perform_step, GINT_TO_POINTER (5));

   187       break;

   188     case 5:

   189       /* pause the fist live stream for 2 seconds */

   190       g_print ("PAUSE bin1 for 2 seconds\n");

   191       pause_play_stream (bin1, 2);

   192       /* pause the non-live stream for 2 seconds */

   193       g_print ("PAUSE bin4 for 2 seconds\n");

   194       pause_play_stream (bin4, 2);

   195       /* pause the pseudo live stream for 2 seconds */

   196       g_print ("PAUSE bin5 for 2 seconds\n");

   197       pause_play_stream (bin5, 2);

   198       g_print ("Waiting 5 seconds\n");

   199       g_timeout_add (5000, (GSourceFunc) perform_step, GINT_TO_POINTER (6));

   200       break;

   201     case 6:

   202       g_print ("quiting\n");

   203       g_main_loop_quit (loop);

   204       break;

   205     default:

   206       break;

   207   }

   208   return FALSE;

   209 }

   210 

   211 int

   212 main (int argc, char *argv[])

   213 {

   214   GstBus *bus;

   215 

   216   gst_init (&argc, &argv);

   217 

   218   loop = g_main_loop_new (NULL, TRUE);

   219 

   220   pipeline = gst_pipeline_new ("pipeline");

   221 

   222   /* setup message handling */

   223   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   224   gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);

   225   g_signal_connect (bus, "message::error", (GCallback) message_received,

   226       pipeline);

   227   g_signal_connect (bus, "message::warning", (GCallback) message_received,

   228       pipeline);

   229   g_signal_connect (bus, "message::eos", (GCallback) eos_message_received,

   230       pipeline);

   231 

   232   /* we set the pipeline to PLAYING, this will distribute a default clock and

   233    * start running. no preroll is needed */

   234   gst_element_set_state (pipeline, GST_STATE_PLAYING);

   235 

   236   /* get the clock now. Since we never set the pipeline to PAUSED again, the

   237    * clock will not change, even when we add new clock providers later.  */

   238   theclock = gst_element_get_clock (pipeline);

   239 

   240   /* start our actions while we are in the mainloop so that we can catch errors

   241    * and other messages. */

   242   g_idle_add ((GSourceFunc) perform_step, GINT_TO_POINTER (0)),

   243       /* go to main loop */

   244       g_main_loop_run (loop);

   245 

   246   gst_element_set_state (pipeline, GST_STATE_NULL);

   247 

   248   gst_object_unref (bus);

   249   gst_object_unref (pipeline);

   250   gst_object_unref (theclock);

   251 

   252   return 0;

   253 }