1 /* GStreamer

     2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

     3  *               2000,2005 Wim Taymans <wim@fluendo.com>

     4  *

     5  * gstbasesrc.c:

     6  *

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

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

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

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

    11  *

    12  * This library is distributed in the hope that it will be useful,

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    15  * Library General Public License for more details.

    16  *

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

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

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

    20  * Boston, MA 02111-1307, USA.

    21  */

    22 

    23 /**

    24  * SECTION:gstbasesrc

    25  * @short_description: Base class for getrange based source elements

    26  * @see_also: #GstPushSrc, #GstBaseTransform, #GstBaseSink

    27  *

    28  * This is a generice base class for source elements. The following

    29  * types of sources are supported:

    30  * <itemizedlist>

    31  *   <listitem><para>random access sources like files</para></listitem>

    32  *   <listitem><para>seekable sources</para></listitem>

    33  *   <listitem><para>live sources</para></listitem>

    34  * </itemizedlist>

    35  *

    36  * <refsect2>

    37  * <para>

    38  * The source can be configured to operate in any #GstFormat with the

    39  * gst_base_src_set_format() method. The currently set format determines 

    40  * the format of the internal #GstSegment and any #GST_EVENT_NEWSEGMENT 

    41  * events. The default format for #GstBaseSrc is #GST_FORMAT_BYTES.

    42  * </para>

    43  * <para>

    44  * #GstBaseSrc always supports push mode scheduling. If the following

    45  * conditions are met, it also supports pull mode scheduling:

    46  * <itemizedlist>

    47  *   <listitem><para>The format is set to #GST_FORMAT_BYTES (default).</para>

    48  *   </listitem>

    49  *   <listitem><para>#GstBaseSrc::is_seekable returns %TRUE.</para>

    50  *   </listitem>

    51  * </itemizedlist>

    52  * </para>

    53  * <para>

    54  * Since 0.10.9, any #GstBaseSrc can enable pull based scheduling at any 

    55  * time by overriding #GstBaseSrc::check_get_range so that it returns %TRUE. 

    56  * </para>

    57  * <para>

    58  * If all the conditions are met for operating in pull mode, #GstBaseSrc is

    59  * automatically seekable in push mode as well. The following conditions must 

    60  * be met to make the element seekable in push mode when the format is not

    61  * #GST_FORMAT_BYTES:

    62  * <itemizedlist>

    63  *   <listitem><para>

    64  *     #GstBaseSrc::is_seekable returns %TRUE.

    65  *   </para></listitem>

    66  *   <listitem><para>

    67  *     #GstBaseSrc::query can convert all supported seek formats to the

    68  *     internal format as set with gst_base_src_set_format().

    69  *   </para></listitem>

    70  *   <listitem><para>

    71  *     #GstBaseSrc::do_seek is implemented, performs the seek and returns %TRUE.

    72  *   </para></listitem>

    73  * </itemizedlist>

    74  * </para>

    75  * <para>

    76  * When the element does not meet the requirements to operate in pull mode,

    77  * the offset and length in the #GstBaseSrc::create method should be ignored.

    78  * It is recommended to subclass #GstPushSrc instead, in this situation. If the

    79  * element can operate in pull mode but only with specific offsets and

    80  * lengths, it is allowed to generate an error when the wrong values are passed

    81  * to the #GstBaseSrc::create function.

    82  * </para>

    83  * <para>

    84  * #GstBaseSrc has support for live sources. Live sources are sources that when

    85  * paused discard data, such as audio or video capture devices. A typical live

    86  * source also produces data at a fixed rate and thus provides a clock to publish

    87  * this rate.

    88  * Use gst_base_src_set_live() to activate the live source mode.

    89  * </para>

    90  * <para>

    91  * A live source does not produce data in the PAUSED state. This means that the 

    92  * #GstBaseSrc::create method will not be called in PAUSED but only in PLAYING.

    93  * To signal the pipeline that the element will not produce data, the return

    94  * value from the READY to PAUSED state will be #GST_STATE_CHANGE_NO_PREROLL.

    95  * </para>

    96  * <para>

    97  * A typical live source will timestamp the buffers it creates with the 

    98  * current running time of the pipeline. This is one reason why a live source

    99  * can only produce data in the PLAYING state, when the clock is actually 

   100  * distributed and running. 

   101  * </para>

   102  * <para>

   103  * Live sources that synchronize and block on the clock (an audio source, for

   104  * example) can since 0.10.12 use gst_base_src_wait_playing() when the ::create

   105  * function was interrupted by a state change to PAUSED.

   106  * </para>

   107  * <para>

   108  * The #GstBaseSrc::get_times method can be used to implement pseudo-live 

   109  * sources.

   110  * It only makes sense to implement the ::get_times function if the source is 

   111  * a live source. The ::get_times function should return timestamps starting

   112  * from 0, as if it were a non-live source. The base class will make sure that

   113  * the timestamps are transformed into the current running_time.

   114  * The base source will then wait for the calculated running_time before pushing

   115  * out the buffer.

   116  * </para>

   117  * <para>

   118  * For live sources, the base class will by default report a latency of 0.

   119  * For pseudo live sources, the base class will by default measure the difference

   120  * between the first buffer timestamp and the start time of get_times and will

   121  * report this value as the latency. 

   122  * Subclasses should override the query function when this behaviour is not

   123  * acceptable.

   124  * </para>

   125  * <para>

   126  * There is only support in #GstBaseSrc for exactly one source pad, which 

   127  * should be named "src". A source implementation (subclass of #GstBaseSrc) 

   128  * should install a pad template in its class_init function, like so:

   129  * </para>

   130  * <para>

   131  * <programlisting>

   132  * static void

   133  * my_element_class_init (GstMyElementClass *klass)

   134  * {

   135  *   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);

   136  *   // srctemplate should be a #GstStaticPadTemplate with direction

   137  *   // #GST_PAD_SRC and name "src"

   138  *   gst_element_class_add_pad_template (gstelement_class,

   139  *       gst_static_pad_template_get (&srctemplate));

   140  *   // see #GstElementDetails

   141  *   gst_element_class_set_details (gstelement_class, &details);

   142  * }

   143  * </programlisting>

   144  * </para>

   145  * <title>Controlled shutdown of live sources in applications</title>

   146  * <para>

   147  * Applications that record from a live source may want to stop recording

   148  * in a controlled way, so that the recording is stopped, but the data

   149  * already in the pipeline is processed to the end (remember that many live

   150  * sources would go on recording forever otherwise). For that to happen the

   151  * application needs to make the source stop recording and send an EOS

   152  * event down the pipeline. The application would then wait for an

   153  * EOS message posted on the pipeline's bus to know when all data has

   154  * been processed and the pipeline can safely be stopped.

   155  * </para>

   156  * <para>

   157  * Since GStreamer 0.10.16 an application may send an EOS event to a source

   158  * element to make it send an EOS event downstream. This can typically be done

   159  * with the gst_element_send_event() function on the element or its parent bin.

   160  * </para>

   161  * <para>

   162  * After the EOS has been sent to the element, the application should wait for

   163  * an EOS message to be posted on the pipeline's bus. Once this EOS message is

   164  * received, it may safely shut down the entire pipeline.

   165  * </para>

   166  * <para>

   167  * The old behaviour for controlled shutdown introduced since GStreamer 0.10.3

   168  * is still available but deprecated as it is dangerous and less flexible.

   169  * </para>

   170  * <para>

   171  * Last reviewed on 2007-12-19 (0.10.16)

   172  * </para>

   173  * </refsect2>

   174  */

   175 

   176 #ifdef HAVE_CONFIG_H

   177 #  include "config.h"

   178 #endif

   179 

   180 #ifdef __SYMBIAN32__

   181 #include <gst_global.h>

   182 #endif

   183 #include <stdlib.h>

   184 #include <string.h>

   185 

   186 #include "gstbasesrc.h"

   187 #include "gsttypefindhelper.h"

   188 #include <gst/gstmarshal.h>

   189 #include <gst/gst-i18n-lib.h>

   190 

   191 #ifdef __SYMBIAN32__

   192 #include <glib_global.h>

   193 #include <gobject_global.h>

   194 #endif

   195 GST_DEBUG_CATEGORY_STATIC (gst_base_src_debug);

   196 #ifndef __SYMBIAN32__

   197 #define GST_CAT_DEFAULT gst_base_src_debug

   198 #endif

   199 

   200 #define GST_LIVE_GET_LOCK(elem)               (GST_BASE_SRC_CAST(elem)->live_lock)

   201 #define GST_LIVE_LOCK(elem)                   g_mutex_lock(GST_LIVE_GET_LOCK(elem))

   202 #define GST_LIVE_TRYLOCK(elem)                g_mutex_trylock(GST_LIVE_GET_LOCK(elem))

   203 #define GST_LIVE_UNLOCK(elem)                 g_mutex_unlock(GST_LIVE_GET_LOCK(elem))

   204 #define GST_LIVE_GET_COND(elem)               (GST_BASE_SRC_CAST(elem)->live_cond)

   205 #define GST_LIVE_WAIT(elem)                   g_cond_wait (GST_LIVE_GET_COND (elem), GST_LIVE_GET_LOCK (elem))

   206 #define GST_LIVE_TIMED_WAIT(elem, timeval)    g_cond_timed_wait (GST_LIVE_GET_COND (elem), GST_LIVE_GET_LOCK (elem),\

   207                                                                                 timeval)

   208 #define GST_LIVE_SIGNAL(elem)                 g_cond_signal (GST_LIVE_GET_COND (elem));

   209 #define GST_LIVE_BROADCAST(elem)              g_cond_broadcast (GST_LIVE_GET_COND (elem));

   210 

   211 /* BaseSrc signals and args */

   212 enum

   213 {

   214   /* FILL ME */

   215   LAST_SIGNAL

   216 };

   217 

   218 #define DEFAULT_BLOCKSIZE       4096

   219 #define DEFAULT_NUM_BUFFERS     -1

   220 #define DEFAULT_TYPEFIND	FALSE

   221 #define DEFAULT_DO_TIMESTAMP	FALSE

   222 

   223 enum

   224 {

   225   PROP_0,

   226   PROP_BLOCKSIZE,

   227   PROP_NUM_BUFFERS,

   228   PROP_TYPEFIND,

   229   PROP_DO_TIMESTAMP

   230 };

   231 

   232 #define GST_BASE_SRC_GET_PRIVATE(obj)  \

   233    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_SRC, GstBaseSrcPrivate))

   234 

   235 struct _GstBaseSrcPrivate

   236 {

   237   gboolean last_sent_eos;       /* last thing we did was send an EOS (we set this

   238                                  * to avoid the sending of two EOS in some cases) */

   239   gboolean discont;

   240   gboolean flushing;

   241 

   242   /* two segments to be sent in the streaming thread with STREAM_LOCK */

   243   GstEvent *close_segment;

   244   GstEvent *start_segment;

   245 

   246   /* if EOS is pending */

   247   gboolean pending_eos;

   248 

   249   /* startup latency is the time it takes between going to PLAYING and producing

   250    * the first BUFFER with running_time 0. This value is included in the latency

   251    * reporting. */

   252   GstClockTime latency;

   253   /* timestamp offset, this is the offset add to the values of gst_times for

   254    * pseudo live sources */

   255   GstClockTimeDiff ts_offset;

   256 

   257   gboolean do_timestamp;

   258 };

   259 

   260 static GstElementClass *parent_class = NULL;

   261 

   262 static void gst_base_src_base_init (gpointer g_class);

   263 static void gst_base_src_class_init (GstBaseSrcClass * klass);

   264 static void gst_base_src_init (GstBaseSrc * src, gpointer g_class);

   265 static void gst_base_src_finalize (GObject * object);

   266 #ifdef __SYMBIAN32__

   267 EXPORT_C

   268 #endif

   269 

   270 

   271 

   272 GType

   273 gst_base_src_get_type (void)

   274 {

   275   static GType base_src_type = 0;

   276 

   277   if (G_UNLIKELY (base_src_type == 0)) {

   278     static const GTypeInfo base_src_info = {

   279       sizeof (GstBaseSrcClass),

   280       (GBaseInitFunc) gst_base_src_base_init,

   281       NULL,

   282       (GClassInitFunc) gst_base_src_class_init,

   283       NULL,

   284       NULL,

   285       sizeof (GstBaseSrc),

   286       0,

   287       (GInstanceInitFunc) gst_base_src_init,

   288     };

   289 

   290     base_src_type = g_type_register_static (GST_TYPE_ELEMENT,

   291         "GstBaseSrc", &base_src_info, G_TYPE_FLAG_ABSTRACT);

   292   }

   293   return base_src_type;

   294 }

   295 static GstCaps *gst_base_src_getcaps (GstPad * pad);

   296 static gboolean gst_base_src_setcaps (GstPad * pad, GstCaps * caps);

   297 static void gst_base_src_fixate (GstPad * pad, GstCaps * caps);

   298 

   299 static gboolean gst_base_src_activate_push (GstPad * pad, gboolean active);

   300 static gboolean gst_base_src_activate_pull (GstPad * pad, gboolean active);

   301 static void gst_base_src_set_property (GObject * object, guint prop_id,

   302     const GValue * value, GParamSpec * pspec);

   303 static void gst_base_src_get_property (GObject * object, guint prop_id,

   304     GValue * value, GParamSpec * pspec);

   305 static gboolean gst_base_src_event_handler (GstPad * pad, GstEvent * event);

   306 static gboolean gst_base_src_send_event (GstElement * elem, GstEvent * event);

   307 static gboolean gst_base_src_default_event (GstBaseSrc * src, GstEvent * event);

   308 static const GstQueryType *gst_base_src_get_query_types (GstElement * element);

   309 

   310 static gboolean gst_base_src_query (GstPad * pad, GstQuery * query);

   311 

   312 static gboolean gst_base_src_default_negotiate (GstBaseSrc * basesrc);

   313 static gboolean gst_base_src_default_do_seek (GstBaseSrc * src,

   314     GstSegment * segment);

   315 static gboolean gst_base_src_default_query (GstBaseSrc * src, GstQuery * query);

   316 static gboolean gst_base_src_default_prepare_seek_segment (GstBaseSrc * src,

   317     GstEvent * event, GstSegment * segment);

   318 

   319 static gboolean gst_base_src_set_flushing (GstBaseSrc * basesrc,

   320     gboolean flushing, gboolean live_play, gboolean unlock, gboolean * playing);

   321 static gboolean gst_base_src_start (GstBaseSrc * basesrc);

   322 static gboolean gst_base_src_stop (GstBaseSrc * basesrc);

   323 

   324 static GstStateChangeReturn gst_base_src_change_state (GstElement * element,

   325     GstStateChange transition);

   326 

   327 static void gst_base_src_loop (GstPad * pad);

   328 static gboolean gst_base_src_pad_check_get_range (GstPad * pad);

   329 static gboolean gst_base_src_default_check_get_range (GstBaseSrc * bsrc);

   330 static GstFlowReturn gst_base_src_pad_get_range (GstPad * pad, guint64 offset,

   331     guint length, GstBuffer ** buf);

   332 static GstFlowReturn gst_base_src_get_range (GstBaseSrc * src, guint64 offset,

   333     guint length, GstBuffer ** buf);

   334 

   335 static void

   336 gst_base_src_base_init (gpointer g_class)

   337 {

   338   GST_DEBUG_CATEGORY_INIT (gst_base_src_debug, "basesrc", 0, "basesrc element");

   339 }

   340 

   341 static void

   342 gst_base_src_class_init (GstBaseSrcClass * klass)

   343 {

   344   GObjectClass *gobject_class;

   345   GstElementClass *gstelement_class;

   346 

   347   gobject_class = G_OBJECT_CLASS (klass);

   348   gstelement_class = GST_ELEMENT_CLASS (klass);

   349 

   350   g_type_class_add_private (klass, sizeof (GstBaseSrcPrivate));

   351 

   352   parent_class = g_type_class_peek_parent (klass);

   353 

   354   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_base_src_finalize);

   355   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_base_src_set_property);

   356   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_base_src_get_property);

   357 

   358   g_object_class_install_property (gobject_class, PROP_BLOCKSIZE,

   359       g_param_spec_ulong ("blocksize", "Block size",

   360           "Size in bytes to read per buffer (0 = default)", 0, G_MAXULONG,

   361           DEFAULT_BLOCKSIZE, G_PARAM_READWRITE));

   362   g_object_class_install_property (gobject_class, PROP_NUM_BUFFERS,

   363       g_param_spec_int ("num-buffers", "num-buffers",

   364           "Number of buffers to output before sending EOS", -1, G_MAXINT,

   365           DEFAULT_NUM_BUFFERS, G_PARAM_READWRITE));

   366   g_object_class_install_property (gobject_class, PROP_TYPEFIND,

   367       g_param_spec_boolean ("typefind", "Typefind",

   368           "Run typefind before negotiating", DEFAULT_TYPEFIND,

   369           G_PARAM_READWRITE));

   370   g_object_class_install_property (gobject_class, PROP_DO_TIMESTAMP,

   371       g_param_spec_boolean ("do-timestamp", "Do timestamp",

   372           "Apply current stream time to buffers", DEFAULT_DO_TIMESTAMP,

   373           G_PARAM_READWRITE));

   374 

   375   gstelement_class->change_state =

   376       GST_DEBUG_FUNCPTR (gst_base_src_change_state);

   377   gstelement_class->send_event = GST_DEBUG_FUNCPTR (gst_base_src_send_event);

   378   gstelement_class->get_query_types =

   379       GST_DEBUG_FUNCPTR (gst_base_src_get_query_types);

   380 

   381   klass->negotiate = GST_DEBUG_FUNCPTR (gst_base_src_default_negotiate);

   382   klass->event = GST_DEBUG_FUNCPTR (gst_base_src_default_event);

   383   klass->do_seek = GST_DEBUG_FUNCPTR (gst_base_src_default_do_seek);

   384   klass->query = GST_DEBUG_FUNCPTR (gst_base_src_default_query);

   385   klass->check_get_range =

   386       GST_DEBUG_FUNCPTR (gst_base_src_default_check_get_range);

   387   klass->prepare_seek_segment =

   388       GST_DEBUG_FUNCPTR (gst_base_src_default_prepare_seek_segment);

   389 }

   390 

   391 static void

   392 gst_base_src_init (GstBaseSrc * basesrc, gpointer g_class)

   393 {

   394   GstPad *pad;

   395   GstPadTemplate *pad_template;

   396 

   397   basesrc->priv = GST_BASE_SRC_GET_PRIVATE (basesrc);

   398 

   399   basesrc->is_live = FALSE;

   400   basesrc->live_lock = g_mutex_new ();

   401   basesrc->live_cond = g_cond_new ();

   402   basesrc->num_buffers = DEFAULT_NUM_BUFFERS;

   403   basesrc->num_buffers_left = -1;

   404 

   405   basesrc->can_activate_push = TRUE;

   406   basesrc->pad_mode = GST_ACTIVATE_NONE;

   407 

   408   pad_template =

   409       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "src");

   410   g_return_if_fail (pad_template != NULL);

   411 

   412   GST_DEBUG_OBJECT (basesrc, "creating src pad");

   413   pad = gst_pad_new_from_template (pad_template, "src");

   414 

   415   GST_DEBUG_OBJECT (basesrc, "setting functions on src pad");

   416   gst_pad_set_activatepush_function (pad,

   417       GST_DEBUG_FUNCPTR (gst_base_src_activate_push));

   418   gst_pad_set_activatepull_function (pad,

   419       GST_DEBUG_FUNCPTR (gst_base_src_activate_pull));

   420   gst_pad_set_event_function (pad,

   421       GST_DEBUG_FUNCPTR (gst_base_src_event_handler));

   422   gst_pad_set_query_function (pad, GST_DEBUG_FUNCPTR (gst_base_src_query));

   423   gst_pad_set_checkgetrange_function (pad,

   424       GST_DEBUG_FUNCPTR (gst_base_src_pad_check_get_range));

   425   gst_pad_set_getrange_function (pad,

   426       GST_DEBUG_FUNCPTR (gst_base_src_pad_get_range));

   427   gst_pad_set_getcaps_function (pad, GST_DEBUG_FUNCPTR (gst_base_src_getcaps));

   428   gst_pad_set_setcaps_function (pad, GST_DEBUG_FUNCPTR (gst_base_src_setcaps));

   429   gst_pad_set_fixatecaps_function (pad,

   430       GST_DEBUG_FUNCPTR (gst_base_src_fixate));

   431 

   432   /* hold pointer to pad */

   433   basesrc->srcpad = pad;

   434   GST_DEBUG_OBJECT (basesrc, "adding src pad");

   435   gst_element_add_pad (GST_ELEMENT (basesrc), pad);

   436 

   437   basesrc->blocksize = DEFAULT_BLOCKSIZE;

   438   basesrc->clock_id = NULL;

   439   /* we operate in BYTES by default */

   440   gst_base_src_set_format (basesrc, GST_FORMAT_BYTES);

   441   basesrc->data.ABI.typefind = DEFAULT_TYPEFIND;

   442   basesrc->priv->do_timestamp = DEFAULT_DO_TIMESTAMP;

   443 

   444   GST_OBJECT_FLAG_UNSET (basesrc, GST_BASE_SRC_STARTED);

   445 

   446   GST_DEBUG_OBJECT (basesrc, "init done");

   447 }

   448 

   449 static void

   450 gst_base_src_finalize (GObject * object)

   451 {

   452   GstBaseSrc *basesrc;

   453   GstEvent **event_p;

   454 

   455   basesrc = GST_BASE_SRC (object);

   456 

   457   g_mutex_free (basesrc->live_lock);

   458   g_cond_free (basesrc->live_cond);

   459 

   460   event_p = &basesrc->data.ABI.pending_seek;

   461   gst_event_replace (event_p, NULL);

   462 

   463   G_OBJECT_CLASS (parent_class)->finalize (object);

   464 }

   465 

   466 /**

   467  * gst_base_src_wait_playing:

   468  * @src: the src

   469  *

   470  * If the #GstBaseSrcClass::create method performs its own synchronisation against

   471  * the clock it must unblock when going from PLAYING to the PAUSED state and call

   472  * this method before continuing to produce the remaining data.

   473  *

   474  * This function will block until a state change to PLAYING happens (in which

   475  * case this function returns #GST_FLOW_OK) or the processing must be stopped due

   476  * to a state change to READY or a FLUSH event (in which case this function

   477  * returns #GST_FLOW_WRONG_STATE).

   478  *

   479  * Since: 0.10.12

   480  *

   481  * Returns: #GST_FLOW_OK if @src is PLAYING and processing can

   482  * continue. Any other return value should be returned from the create vmethod.

   483  */

   484 #ifdef __SYMBIAN32__

   485 EXPORT_C

   486 #endif

   487 

   488 GstFlowReturn

   489 gst_base_src_wait_playing (GstBaseSrc * src)

   490 {

   491   /* block until the state changes, or we get a flush, or something */

   492   GST_DEBUG_OBJECT (src, "live source waiting for running state");

   493   GST_LIVE_WAIT (src);

   494   if (src->priv->flushing)

   495     goto flushing;

   496   GST_DEBUG_OBJECT (src, "live source unlocked");

   497 

   498   return GST_FLOW_OK;

   499 

   500   /* ERRORS */

   501 flushing:

   502   {

   503     GST_DEBUG_OBJECT (src, "we are flushing");

   504     return GST_FLOW_WRONG_STATE;

   505   }

   506 }

   507 

   508 /**

   509  * gst_base_src_set_live:

   510  * @src: base source instance

   511  * @live: new live-mode

   512  *

   513  * If the element listens to a live source, @live should

   514  * be set to %TRUE. 

   515  *

   516  * A live source will not produce data in the PAUSED state and

   517  * will therefore not be able to participate in the PREROLL phase

   518  * of a pipeline. To signal this fact to the application and the 

   519  * pipeline, the state change return value of the live source will

   520  * be GST_STATE_CHANGE_NO_PREROLL.

   521  */

   522 #ifdef __SYMBIAN32__

   523 EXPORT_C

   524 #endif

   525 

   526 void

   527 gst_base_src_set_live (GstBaseSrc * src, gboolean live)

   528 {

   529   GST_OBJECT_LOCK (src);

   530   src->is_live = live;

   531   GST_OBJECT_UNLOCK (src);

   532 }

   533 

   534 /**

   535  * gst_base_src_is_live:

   536  * @src: base source instance

   537  *

   538  * Check if an element is in live mode.

   539  *

   540  * Returns: %TRUE if element is in live mode.

   541  */

   542 #ifdef __SYMBIAN32__

   543 EXPORT_C

   544 #endif

   545 

   546 gboolean

   547 gst_base_src_is_live (GstBaseSrc * src)

   548 {

   549   gboolean result;

   550 

   551   GST_OBJECT_LOCK (src);

   552   result = src->is_live;

   553   GST_OBJECT_UNLOCK (src);

   554 

   555   return result;

   556 }

   557 

   558 /**

   559  * gst_base_src_set_format:

   560  * @src: base source instance

   561  * @format: the format to use

   562  *

   563  * Sets the default format of the source. This will be the format used

   564  * for sending NEW_SEGMENT events and for performing seeks.

   565  *

   566  * If a format of GST_FORMAT_BYTES is set, the element will be able to

   567  * operate in pull mode if the #GstBaseSrc::is_seekable returns TRUE.

   568  *

   569  * Since: 0.10.1

   570  */

   571 #ifdef __SYMBIAN32__

   572 EXPORT_C

   573 #endif

   574 

   575 void

   576 gst_base_src_set_format (GstBaseSrc * src, GstFormat format)

   577 {

   578   gst_segment_init (&src->segment, format);

   579 }

   580 

   581 /**

   582  * gst_base_src_query_latency:

   583  * @src: the source

   584  * @live: if the source is live

   585  * @min_latency: the min latency of the source

   586  * @max_latency: the max latency of the source

   587  *

   588  * Query the source for the latency parameters. @live will be TRUE when @src is

   589  * configured as a live source. @min_latency will be set to the difference

   590  * between the running time and the timestamp of the first buffer.

   591  * @max_latency is always the undefined value of -1.

   592  *

   593  * This function is mostly used by subclasses. 

   594  *

   595  * Returns: TRUE if the query succeeded.

   596  *

   597  * Since: 0.10.13

   598  */

   599 #ifdef __SYMBIAN32__

   600 EXPORT_C

   601 #endif

   602 

   603 gboolean

   604 gst_base_src_query_latency (GstBaseSrc * src, gboolean * live,

   605     GstClockTime * min_latency, GstClockTime * max_latency)

   606 {

   607   GstClockTime min;

   608 

   609   GST_OBJECT_LOCK (src);

   610   if (live)

   611     *live = src->is_live;

   612 

   613   /* if we have a startup latency, report this one, else report 0. Subclasses

   614    * are supposed to override the query function if they want something

   615    * else. */

   616   if (src->priv->latency != -1)

   617     min = src->priv->latency;

   618   else

   619     min = 0;

   620 

   621   if (min_latency)

   622     *min_latency = min;

   623   if (max_latency)

   624     *max_latency = -1;

   625 

   626   GST_LOG_OBJECT (src, "latency: live %d, min %" GST_TIME_FORMAT

   627       ", max %" GST_TIME_FORMAT, src->is_live, GST_TIME_ARGS (min),

   628       GST_TIME_ARGS (-1));

   629   GST_OBJECT_UNLOCK (src);

   630 

   631   return TRUE;

   632 }

   633 

   634 /**

   635  * gst_base_src_set_do_timestamp:

   636  * @src: the source

   637  * @timestamp: enable or disable timestamping

   638  *

   639  * Configure @src to automatically timestamp outgoing buffers based on the

   640  * current running_time of the pipeline. This property is mostly useful for live

   641  * sources.

   642  *

   643  * Since: 0.10.15

   644  */

   645 #ifdef __SYMBIAN32__

   646 EXPORT_C

   647 #endif

   648 

   649 void

   650 gst_base_src_set_do_timestamp (GstBaseSrc * src, gboolean timestamp)

   651 {

   652   GST_OBJECT_LOCK (src);

   653   src->priv->do_timestamp = timestamp;

   654   GST_OBJECT_UNLOCK (src);

   655 }

   656 

   657 /**

   658  * gst_base_src_get_do_timestamp:

   659  * @src: the source

   660  *

   661  * Query if @src timestamps outgoing buffers based on the current running_time.

   662  *

   663  * Returns: %TRUE if the base class will automatically timestamp outgoing buffers.

   664  *

   665  * Since: 0.10.15

   666  */

   667 #ifdef __SYMBIAN32__

   668 EXPORT_C

   669 #endif

   670 

   671 gboolean

   672 gst_base_src_get_do_timestamp (GstBaseSrc * src)

   673 {

   674   gboolean res;

   675 

   676   GST_OBJECT_LOCK (src);

   677   res = src->priv->do_timestamp;

   678   GST_OBJECT_UNLOCK (src);

   679 

   680   return res;

   681 }

   682 

   683 static gboolean

   684 gst_base_src_setcaps (GstPad * pad, GstCaps * caps)

   685 {

   686   GstBaseSrcClass *bclass;

   687   GstBaseSrc *bsrc;

   688   gboolean res = TRUE;

   689 

   690   bsrc = GST_BASE_SRC (GST_PAD_PARENT (pad));

   691   bclass = GST_BASE_SRC_GET_CLASS (bsrc);

   692 

   693   if (bclass->set_caps)

   694     res = bclass->set_caps (bsrc, caps);

   695 

   696   return res;

   697 }

   698 

   699 static GstCaps *

   700 gst_base_src_getcaps (GstPad * pad)

   701 {

   702   GstBaseSrcClass *bclass;

   703   GstBaseSrc *bsrc;

   704   GstCaps *caps = NULL;

   705 

   706   bsrc = GST_BASE_SRC (GST_PAD_PARENT (pad));

   707   bclass = GST_BASE_SRC_GET_CLASS (bsrc);

   708   if (bclass->get_caps)

   709     caps = bclass->get_caps (bsrc);

   710 

   711   if (caps == NULL) {

   712     GstPadTemplate *pad_template;

   713 

   714     pad_template =

   715         gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "src");

   716     if (pad_template != NULL) {

   717       caps = gst_caps_ref (gst_pad_template_get_caps (pad_template));

   718     }

   719   }

   720   return caps;

   721 }

   722 

   723 static void

   724 gst_base_src_fixate (GstPad * pad, GstCaps * caps)

   725 {

   726   GstBaseSrcClass *bclass;

   727   GstBaseSrc *bsrc;

   728 

   729   bsrc = GST_BASE_SRC (gst_pad_get_parent (pad));

   730   bclass = GST_BASE_SRC_GET_CLASS (bsrc);

   731 

   732   if (bclass->fixate)

   733     bclass->fixate (bsrc, caps);

   734 

   735   gst_object_unref (bsrc);

   736 }

   737 

   738 static gboolean

   739 gst_base_src_default_query (GstBaseSrc * src, GstQuery * query)

   740 {

   741   gboolean res;

   742 

   743   switch (GST_QUERY_TYPE (query)) {

   744     case GST_QUERY_POSITION:

   745     {

   746       GstFormat format;

   747 

   748       gst_query_parse_position (query, &format, NULL);

   749       switch (format) {

   750         case GST_FORMAT_PERCENT:

   751         {

   752           gint64 percent;

   753           gint64 position;

   754           gint64 duration;

   755 

   756           position = src->segment.last_stop;

   757           duration = src->segment.duration;

   758 

   759           if (position != -1 && duration != -1) {

   760             if (position < duration)

   761               percent = gst_util_uint64_scale (GST_FORMAT_PERCENT_MAX, position,

   762                   duration);

   763             else

   764               percent = GST_FORMAT_PERCENT_MAX;

   765           } else

   766             percent = -1;

   767 

   768           gst_query_set_position (query, GST_FORMAT_PERCENT, percent);

   769           res = TRUE;

   770           break;

   771         }

   772         default:

   773         {

   774           gint64 position;

   775 

   776           position = src->segment.last_stop;

   777 

   778           if (position != -1) {

   779             /* convert to requested format */

   780             res =

   781                 gst_pad_query_convert (src->srcpad, src->segment.format,

   782                 position, &format, &position);

   783           } else

   784             res = TRUE;

   785 

   786           gst_query_set_position (query, format, position);

   787           break;

   788         }

   789       }

   790       break;

   791     }

   792     case GST_QUERY_DURATION:

   793     {

   794       GstFormat format;

   795 

   796       gst_query_parse_duration (query, &format, NULL);

   797 

   798       GST_DEBUG_OBJECT (src, "duration query in format %s",

   799           gst_format_get_name (format));

   800       switch (format) {

   801         case GST_FORMAT_PERCENT:

   802           gst_query_set_duration (query, GST_FORMAT_PERCENT,

   803               GST_FORMAT_PERCENT_MAX);

   804           res = TRUE;

   805           break;

   806         default:

   807         {

   808           gint64 duration;

   809 

   810           /* this is the duration as configured by the subclass. */

   811           duration = src->segment.duration;

   812 

   813           if (duration != -1) {

   814             /* convert to requested format, if this fails, we have a duration

   815              * but we cannot answer the query, we must return FALSE. */

   816             res =

   817                 gst_pad_query_convert (src->srcpad, src->segment.format,

   818                 duration, &format, &duration);

   819           } else {

   820             /* The subclass did not configure a duration, we assume that the

   821              * media has an unknown duration then and we return TRUE to report

   822              * this. Note that this is not the same as returning FALSE, which

   823              * means that we cannot report the duration at all. */

   824             res = TRUE;

   825           }

   826           gst_query_set_duration (query, format, duration);

   827           break;

   828         }

   829       }

   830       break;

   831     }

   832 

   833     case GST_QUERY_SEEKING:

   834     {

   835       gst_query_set_seeking (query, src->segment.format,

   836           src->seekable, 0, src->segment.duration);

   837       res = TRUE;

   838       break;

   839     }

   840     case GST_QUERY_SEGMENT:

   841     {

   842       gint64 start, stop;

   843 

   844       /* no end segment configured, current duration then */

   845       if ((stop = src->segment.stop) == -1)

   846         stop = src->segment.duration;

   847       start = src->segment.start;

   848 

   849       /* adjust to stream time */

   850       if (src->segment.time != -1) {

   851         start -= src->segment.time;

   852         if (stop != -1)

   853           stop -= src->segment.time;

   854       }

   855       gst_query_set_segment (query, src->segment.rate, src->segment.format,

   856           start, stop);

   857       res = TRUE;

   858       break;

   859     }

   860 

   861     case GST_QUERY_FORMATS:

   862     {

   863       gst_query_set_formats (query, 3, GST_FORMAT_DEFAULT,

   864           GST_FORMAT_BYTES, GST_FORMAT_PERCENT);

   865       res = TRUE;

   866       break;

   867     }

   868     case GST_QUERY_CONVERT:

   869     {

   870       GstFormat src_fmt, dest_fmt;

   871       gint64 src_val, dest_val;

   872 

   873       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);

   874 

   875       /* we can only convert between equal formats... */

   876       if (src_fmt == dest_fmt) {

   877         dest_val = src_val;

   878         res = TRUE;

   879       } else

   880         res = FALSE;

   881 

   882       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);

   883       break;

   884     }

   885     case GST_QUERY_LATENCY:

   886     {

   887       GstClockTime min, max;

   888       gboolean live;

   889 

   890       /* Subclasses should override and implement something usefull */

   891       res = gst_base_src_query_latency (src, &live, &min, &max);

   892 

   893       GST_LOG_OBJECT (src, "report latency: live %d, min %" GST_TIME_FORMAT

   894           ", max %" GST_TIME_FORMAT, live, GST_TIME_ARGS (min),

   895           GST_TIME_ARGS (max));

   896 

   897       gst_query_set_latency (query, live, min, max);

   898       break;

   899     }

   900     case GST_QUERY_JITTER:

   901     case GST_QUERY_RATE:

   902     default:

   903       res = FALSE;

   904       break;

   905   }

   906   GST_DEBUG_OBJECT (src, "query %s returns %d", GST_QUERY_TYPE_NAME (query),

   907       res);

   908   return res;

   909 }

   910 

   911 static gboolean

   912 gst_base_src_query (GstPad * pad, GstQuery * query)

   913 {

   914   GstBaseSrc *src;

   915   GstBaseSrcClass *bclass;

   916   gboolean result = FALSE;

   917 

   918   src = GST_BASE_SRC (gst_pad_get_parent (pad));

   919 

   920   bclass = GST_BASE_SRC_GET_CLASS (src);

   921 

   922   if (bclass->query)

   923     result = bclass->query (src, query);

   924   else

   925     result = gst_pad_query_default (pad, query);

   926 

   927   gst_object_unref (src);

   928 

   929   return result;

   930 }

   931 

   932 static gboolean

   933 gst_base_src_default_do_seek (GstBaseSrc * src, GstSegment * segment)

   934 {

   935   gboolean res = TRUE;

   936 

   937   /* update our offset if the start/stop position was updated */

   938   if (segment->format == GST_FORMAT_BYTES) {

   939     segment->time = segment->start;

   940   } else if (segment->start == 0) {

   941     /* seek to start, we can implement a default for this. */

   942     segment->time = 0;

   943     res = TRUE;

   944   } else

   945     res = FALSE;

   946 

   947   return res;

   948 }

   949 

   950 static gboolean

   951 gst_base_src_do_seek (GstBaseSrc * src, GstSegment * segment)

   952 {

   953   GstBaseSrcClass *bclass;

   954   gboolean result = FALSE;

   955 

   956   bclass = GST_BASE_SRC_GET_CLASS (src);

   957 

   958   if (bclass->do_seek)

   959     result = bclass->do_seek (src, segment);

   960 

   961   return result;

   962 }

   963 

   964 #define SEEK_TYPE_IS_RELATIVE(t) (((t) != GST_SEEK_TYPE_NONE) && ((t) != GST_SEEK_TYPE_SET))

   965 

   966 static gboolean

   967 gst_base_src_default_prepare_seek_segment (GstBaseSrc * src, GstEvent * event,

   968     GstSegment * segment)

   969 {

   970   /* By default, we try one of 2 things:

   971    *   - For absolute seek positions, convert the requested position to our 

   972    *     configured processing format and place it in the output segment \

   973    *   - For relative seek positions, convert our current (input) values to the

   974    *     seek format, adjust by the relative seek offset and then convert back to

   975    *     the processing format

   976    */

   977   GstSeekType cur_type, stop_type;

   978   gint64 cur, stop;

   979   GstSeekFlags flags;

   980   GstFormat seek_format, dest_format;

   981   gdouble rate;

   982   gboolean update;

   983   gboolean res = TRUE;

   984 

   985   gst_event_parse_seek (event, &rate, &seek_format, &flags,

   986       &cur_type, &cur, &stop_type, &stop);

   987   dest_format = segment->format;

   988 

   989   if (seek_format == dest_format) {

   990     gst_segment_set_seek (segment, rate, seek_format, flags,

   991         cur_type, cur, stop_type, stop, &update);

   992     return TRUE;

   993   }

   994 

   995   if (cur_type != GST_SEEK_TYPE_NONE) {

   996     /* FIXME: Handle seek_cur & seek_end by converting the input segment vals */

   997     res =

   998         gst_pad_query_convert (src->srcpad, seek_format, cur, &dest_format,

   999         &cur);

  1000     cur_type = GST_SEEK_TYPE_SET;

  1001   }

  1002 

  1003   if (res && stop_type != GST_SEEK_TYPE_NONE) {

  1004     /* FIXME: Handle seek_cur & seek_end by converting the input segment vals */

  1005     res =

  1006         gst_pad_query_convert (src->srcpad, seek_format, stop, &dest_format,

  1007         &stop);

  1008     stop_type = GST_SEEK_TYPE_SET;

  1009   }

  1010 

  1011   /* And finally, configure our output segment in the desired format */

  1012   gst_segment_set_seek (segment, rate, dest_format, flags, cur_type, cur,

  1013       stop_type, stop, &update);

  1014 

  1015   if (!res)

  1016     goto no_format;

  1017 

  1018   return res;

  1019 

  1020 no_format:

  1021   {

  1022     GST_DEBUG_OBJECT (src, "undefined format given, seek aborted.");

  1023     return FALSE;

  1024   }

  1025 }

  1026 

  1027 static gboolean

  1028 gst_base_src_prepare_seek_segment (GstBaseSrc * src, GstEvent * event,

  1029     GstSegment * seeksegment)

  1030 {

  1031   GstBaseSrcClass *bclass;

  1032   gboolean result = FALSE;

  1033 

  1034   bclass = GST_BASE_SRC_GET_CLASS (src);

  1035 

  1036   if (bclass->prepare_seek_segment)

  1037     result = bclass->prepare_seek_segment (src, event, seeksegment);

  1038 

  1039   return result;

  1040 }

  1041 

  1042 /* this code implements the seeking. It is a good example

  1043  * handling all cases.

  1044  *

  1045  * A seek updates the currently configured segment.start

  1046  * and segment.stop values based on the SEEK_TYPE. If the

  1047  * segment.start value is updated, a seek to this new position

  1048  * should be performed.

  1049  *

  1050  * The seek can only be executed when we are not currently

  1051  * streaming any data, to make sure that this is the case, we

  1052  * acquire the STREAM_LOCK which is taken when we are in the

  1053  * _loop() function or when a getrange() is called. Normally

  1054  * we will not receive a seek if we are operating in pull mode

  1055  * though. When we operate as a live source we might block on the live

  1056  * cond, which does not release the STREAM_LOCK. Therefore we will try

  1057  * to grab the LIVE_LOCK instead of the STREAM_LOCK to make sure it is

  1058  * safe to perform the seek.

  1059  *

  1060  * When we are in the loop() function, we might be in the middle

  1061  * of pushing a buffer, which might block in a sink. To make sure

  1062  * that the push gets unblocked we push out a FLUSH_START event.

  1063  * Our loop function will get a WRONG_STATE return value from

  1064  * the push and will pause, effectively releasing the STREAM_LOCK.

  1065  *

  1066  * For a non-flushing seek, we pause the task, which might eventually

  1067  * release the STREAM_LOCK. We say eventually because when the sink

  1068  * blocks on the sample we might wait a very long time until the sink

  1069  * unblocks the sample. In any case we acquire the STREAM_LOCK and

  1070  * can continue the seek. A non-flushing seek is normally done in a 

  1071  * running pipeline to perform seamless playback, this means that the sink is

  1072  * PLAYING and will return from its chain function.

  1073  * In the case of a non-flushing seek we need to make sure that the

  1074  * data we output after the seek is continuous with the previous data,

  1075  * this is because a non-flushing seek does not reset the running-time

  1076  * to 0. We do this by closing the currently running segment, ie. sending

  1077  * a new_segment event with the stop position set to the last processed 

  1078  * position.

  1079  *

  1080  * After updating the segment.start/stop values, we prepare for

  1081  * streaming again. We push out a FLUSH_STOP to make the peer pad

  1082  * accept data again and we start our task again.

  1083  *

  1084  * A segment seek posts a message on the bus saying that the playback

  1085  * of the segment started. We store the segment flag internally because

  1086  * when we reach the segment.stop we have to post a segment.done

  1087  * instead of EOS when doing a segment seek.

  1088  */

  1089 /* FIXME (0.11), we have the unlock gboolean here because most current 

  1090  * implementations (fdsrc, -base/gst/tcp/, ...) unconditionally unlock, even when

  1091  * the streaming thread isn't running, resulting in bogus unlocks later when it 

  1092  * starts. This is fixed by adding unlock_stop, but we should still avoid unlocking

  1093  * unnecessarily for backwards compatibility. Ergo, the unlock variable stays

  1094  * until 0.11

  1095  */

  1096 static gboolean

  1097 gst_base_src_perform_seek (GstBaseSrc * src, GstEvent * event, gboolean unlock)

  1098 {

  1099   gboolean res = TRUE;

  1100   gdouble rate;

  1101   GstFormat seek_format, dest_format;

  1102   GstSeekFlags flags;

  1103   GstSeekType cur_type, stop_type;

  1104   gint64 cur, stop;

  1105   gboolean flush, playing;

  1106   gboolean update;

  1107   gboolean relative_seek = FALSE;

  1108   gboolean seekseg_configured = FALSE;

  1109   GstSegment seeksegment;

  1110 

  1111   GST_DEBUG_OBJECT (src, "doing seek");

  1112 

  1113   dest_format = src->segment.format;

  1114 

  1115   if (event) {

  1116     gst_event_parse_seek (event, &rate, &seek_format, &flags,

  1117         &cur_type, &cur, &stop_type, &stop);

  1118 

  1119     relative_seek = SEEK_TYPE_IS_RELATIVE (cur_type) ||

  1120         SEEK_TYPE_IS_RELATIVE (stop_type);

  1121 

  1122     if (dest_format != seek_format && !relative_seek) {

  1123       /* If we have an ABSOLUTE position (SEEK_SET only), we can convert it

  1124        * here before taking the stream lock, otherwise we must convert it later,

  1125        * once we have the stream lock and can read the current position */

  1126       gst_segment_init (&seeksegment, dest_format);

  1127 

  1128       if (!gst_base_src_prepare_seek_segment (src, event, &seeksegment))

  1129         goto prepare_failed;

  1130 

  1131       seekseg_configured = TRUE;

  1132     }

  1133 

  1134     flush = flags & GST_SEEK_FLAG_FLUSH;