2 * Copyright (C) 2007 David Schleef <ds@schleef.org>
3 * (C) 2008 Wim Taymans <wim.taymans@gmail.com>
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
22 * @short_description: Easy way for applications to inject buffers into a
24 * @see_also: #GstBaseSrc, appsink
26 * The appsrc element can be used by applications to insert data into a
27 * GStreamer pipeline. Unlike most GStreamer elements, Appsrc provides
28 * external API functions.
30 * appsrc can be used by linking with the libgstapp library to access the
31 * methods directly or by using the appsrc action signals.
33 * Before operating appsrc, the caps property must be set to a fixed caps
34 * describing the format of the data that will be pushed with appsrc. An
35 * exception to this is when pushing buffers with unknown caps, in which case no
36 * caps should be set. This is typically true of file-like sources that push raw
39 * The main way of handing data to the appsrc element is by calling the
40 * gst_app_src_push_buffer() method or by emitting the push-buffer action signal.
41 * This will put the buffer onto a queue from which appsrc will read from in its
42 * streaming thread. It is important to note that data transport will not happen
43 * from the thread that performed the push-buffer call.
45 * The "max-bytes" property controls how much data can be queued in appsrc
46 * before appsrc considers the queue full. A filled internal queue will always
47 * signal the "enough-data" signal, which signals the application that it should
48 * stop pushing data into appsrc. The "block" property will cause appsrc to
49 * block the push-buffer method until free data becomes available again.
51 * When the internal queue is running out of data, the "need-data" signal is
52 * emitted, which signals the application that it should start pushing more data
55 * In addition to the "need-data" and "enough-data" signals, appsrc can emit the
56 * "seek-data" signal when the "stream-mode" property is set to "seekable" or
57 * "random-access". The signal argument will contain the new desired position in
58 * the stream expressed in the unit set with the "format" property. After
59 * receiving the seek-data signal, the application should push-buffers from the
62 * These signals allow the application to operate the appsrc in two different
65 * The push model, in which the application repeatedly calls the push-buffer method
66 * with a new buffer. Optionally, the queue size in the appsrc can be controlled
67 * with the enough-data and need-data signals by respectively stopping/starting
68 * the push-buffer calls. This is a typical mode of operation for the
69 * stream-type "stream" and "seekable". Use this model when implementing various
70 * network protocols or hardware devices.
72 * The pull model where the need-data signal triggers the next push-buffer call.
73 * This mode is typically used in the "random-access" stream-type. Use this
74 * model for file access or other randomly accessable sources. In this mode, a
75 * buffer of exactly the amount of bytes given by the need-data signal should be
78 * In all modes, the size property on appsrc should contain the total stream
79 * size in bytes. Setting this property is mandatory in the random-access mode.
80 * For the stream and seekable modes, setting this property is optional but
83 * When the application is finished pushing data into appsrc, it should call
84 * gst_app_src_end_of_stream() or emit the end-of-stream action signal. After
85 * this call, no more buffers can be pushed into appsrc until a flushing seek
86 * happened or the state of the appsrc has gone through READY.
88 * Last reviewed on 2008-12-17 (0.10.10)
98 #include <gst/base/gstbasesrc.h>
102 #include "gstapp-marshal.h"
103 #include "gstappsrc.h"
105 #include "gst/glib-compat-private.h"
107 struct _GstAppSrcPrivate
115 GstAppStreamType stream_type;
123 guint64 queued_bytes;
125 GstAppStreamType current_type;
129 gboolean emit_signals;
132 GstAppSrcCallbacks callbacks;
134 GDestroyNotify notify;
137 GST_DEBUG_CATEGORY_STATIC (app_src_debug);
138 #define GST_CAT_DEFAULT app_src_debug
149 SIGNAL_END_OF_STREAM,
154 #define DEFAULT_PROP_SIZE -1
155 #define DEFAULT_PROP_STREAM_TYPE GST_APP_STREAM_TYPE_STREAM
156 #define DEFAULT_PROP_MAX_BYTES 200000
157 #define DEFAULT_PROP_FORMAT GST_FORMAT_BYTES
158 #define DEFAULT_PROP_BLOCK FALSE
159 #define DEFAULT_PROP_IS_LIVE FALSE
160 #define DEFAULT_PROP_MIN_LATENCY -1
161 #define DEFAULT_PROP_MAX_LATENCY -1
162 #define DEFAULT_PROP_EMIT_SIGNALS TRUE
163 #define DEFAULT_PROP_MIN_PERCENT 0
182 static GstStaticPadTemplate gst_app_src_template =
183 GST_STATIC_PAD_TEMPLATE ("src",
186 GST_STATIC_CAPS_ANY);
189 gst_app_stream_type_get_type (void)
191 static volatile gsize stream_type_type = 0;
192 static const GEnumValue stream_type[] = {
193 {GST_APP_STREAM_TYPE_STREAM, "GST_APP_STREAM_TYPE_STREAM", "stream"},
194 {GST_APP_STREAM_TYPE_SEEKABLE, "GST_APP_STREAM_TYPE_SEEKABLE", "seekable"},
195 {GST_APP_STREAM_TYPE_RANDOM_ACCESS, "GST_APP_STREAM_TYPE_RANDOM_ACCESS",
200 if (g_once_init_enter (&stream_type_type)) {
201 GType tmp = g_enum_register_static ("GstAppStreamType", stream_type);
202 g_once_init_leave (&stream_type_type, tmp);
205 return (GType) stream_type_type;
208 static void gst_app_src_uri_handler_init (gpointer g_iface,
209 gpointer iface_data);
211 static void gst_app_src_dispose (GObject * object);
212 static void gst_app_src_finalize (GObject * object);
214 static void gst_app_src_set_property (GObject * object, guint prop_id,
215 const GValue * value, GParamSpec * pspec);
216 static void gst_app_src_get_property (GObject * object, guint prop_id,
217 GValue * value, GParamSpec * pspec);
219 static void gst_app_src_set_latencies (GstAppSrc * appsrc,
220 gboolean do_min, guint64 min, gboolean do_max, guint64 max);
222 static GstCaps *gst_app_src_internal_get_caps (GstBaseSrc * bsrc);
223 static GstFlowReturn gst_app_src_create (GstBaseSrc * bsrc,
224 guint64 offset, guint size, GstBuffer ** buf);
225 static gboolean gst_app_src_start (GstBaseSrc * bsrc);
226 static gboolean gst_app_src_stop (GstBaseSrc * bsrc);
227 static gboolean gst_app_src_unlock (GstBaseSrc * bsrc);
228 static gboolean gst_app_src_unlock_stop (GstBaseSrc * bsrc);
229 static gboolean gst_app_src_do_seek (GstBaseSrc * src, GstSegment * segment);
230 static gboolean gst_app_src_is_seekable (GstBaseSrc * src);
231 static gboolean gst_app_src_check_get_range (GstBaseSrc * src);
232 static gboolean gst_app_src_do_get_size (GstBaseSrc * src, guint64 * size);
233 static gboolean gst_app_src_query (GstBaseSrc * src, GstQuery * query);
235 static GstFlowReturn gst_app_src_push_buffer_action (GstAppSrc * appsrc,
237 static gboolean gst_app_src_send_event (GstElement * element, GstEvent * event);
239 static guint gst_app_src_signals[LAST_SIGNAL] = { 0 };
242 _do_init (GType filesrc_type)
244 static const GInterfaceInfo urihandler_info = {
245 gst_app_src_uri_handler_init,
249 g_type_add_interface_static (filesrc_type, GST_TYPE_URI_HANDLER,
253 GST_BOILERPLATE_FULL (GstAppSrc, gst_app_src, GstBaseSrc, GST_TYPE_BASE_SRC,
257 gst_app_src_base_init (gpointer g_class)
259 GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
261 GST_DEBUG_CATEGORY_INIT (app_src_debug, "appsrc", 0, "appsrc element");
263 gst_element_class_set_details_simple (element_class, "AppSrc",
264 "Generic/Source", "Allow the application to feed buffers to a pipeline",
265 "David Schleef <ds@schleef.org>, Wim Taymans <wim.taymans@gmail.com>");
267 gst_element_class_add_static_pad_template (element_class,
268 &gst_app_src_template);
272 gst_app_src_class_init (GstAppSrcClass * klass)
274 GObjectClass *gobject_class = (GObjectClass *) klass;
275 GstBaseSrcClass *basesrc_class = (GstBaseSrcClass *) klass;
276 GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);;
278 gobject_class->dispose = gst_app_src_dispose;
279 gobject_class->finalize = gst_app_src_finalize;
281 gobject_class->set_property = gst_app_src_set_property;
282 gobject_class->get_property = gst_app_src_get_property;
283 gstelement_class->send_event = GST_DEBUG_FUNCPTR (gst_app_src_send_event);
288 * The GstCaps that will negotiated downstream and will be put
289 * on outgoing buffers.
291 g_object_class_install_property (gobject_class, PROP_CAPS,
292 g_param_spec_boxed ("caps", "Caps",
293 "The allowed caps for the src pad", GST_TYPE_CAPS,
294 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
298 * The format to use for segment events. When the source is producing
299 * timestamped buffers this property should be set to GST_FORMAT_TIME.
301 g_object_class_install_property (gobject_class, PROP_FORMAT,
302 g_param_spec_enum ("format", "Format",
303 "The format of the segment events and seek", GST_TYPE_FORMAT,
304 DEFAULT_PROP_FORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
308 * The total size in bytes of the data stream. If the total size is known, it
309 * is recommended to configure it with this property.
311 g_object_class_install_property (gobject_class, PROP_SIZE,
312 g_param_spec_int64 ("size", "Size",
313 "The size of the data stream in bytes (-1 if unknown)",
314 -1, G_MAXINT64, DEFAULT_PROP_SIZE,
315 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
317 * GstAppSrc::stream-type
319 * The type of stream that this source is producing. For seekable streams the
320 * application should connect to the seek-data signal.
322 g_object_class_install_property (gobject_class, PROP_STREAM_TYPE,
323 g_param_spec_enum ("stream-type", "Stream Type",
324 "the type of the stream", GST_TYPE_APP_STREAM_TYPE,
325 DEFAULT_PROP_STREAM_TYPE,
326 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
328 * GstAppSrc::max-bytes
330 * The maximum amount of bytes that can be queued internally.
331 * After the maximum amount of bytes are queued, appsrc will emit the
332 * "enough-data" signal.
334 g_object_class_install_property (gobject_class, PROP_MAX_BYTES,
335 g_param_spec_uint64 ("max-bytes", "Max bytes",
336 "The maximum number of bytes to queue internally (0 = unlimited)",
337 0, G_MAXUINT64, DEFAULT_PROP_MAX_BYTES,
338 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
342 * When max-bytes are queued and after the enough-data signal has been emitted,
343 * block any further push-buffer calls until the amount of queued bytes drops
344 * below the max-bytes limit.
346 g_object_class_install_property (gobject_class, PROP_BLOCK,
347 g_param_spec_boolean ("block", "Block",
348 "Block push-buffer when max-bytes are queued",
349 DEFAULT_PROP_BLOCK, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
354 * Instruct the source to behave like a live source. This includes that it
355 * will only push out buffers in the PLAYING state.
357 g_object_class_install_property (gobject_class, PROP_IS_LIVE,
358 g_param_spec_boolean ("is-live", "Is Live",
359 "Whether to act as a live source",
360 DEFAULT_PROP_IS_LIVE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
362 * GstAppSrc::min-latency
364 * The minimum latency of the source. A value of -1 will use the default
365 * latency calculations of #GstBaseSrc.
367 g_object_class_install_property (gobject_class, PROP_MIN_LATENCY,
368 g_param_spec_int64 ("min-latency", "Min Latency",
369 "The minimum latency (-1 = default)",
370 -1, G_MAXINT64, DEFAULT_PROP_MIN_LATENCY,
371 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
373 * GstAppSrc::max-latency
375 * The maximum latency of the source. A value of -1 means an unlimited amout
378 g_object_class_install_property (gobject_class, PROP_MAX_LATENCY,
379 g_param_spec_int64 ("max-latency", "Max Latency",
380 "The maximum latency (-1 = unlimited)",
381 -1, G_MAXINT64, DEFAULT_PROP_MAX_LATENCY,
382 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
385 * GstAppSrc::emit-signals
387 * Make appsrc emit the "need-data", "enough-data" and "seek-data" signals.
388 * This option is by default enabled for backwards compatibility reasons but
389 * can disabled when needed because signal emission is expensive.
393 g_object_class_install_property (gobject_class, PROP_EMIT_SIGNALS,
394 g_param_spec_boolean ("emit-signals", "Emit signals",
395 "Emit need-data, enough-data and seek-data signals",
396 DEFAULT_PROP_EMIT_SIGNALS,
397 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
400 * GstAppSrc::empty-percent
402 * Make appsrc emit the "need-data" signal when the amount of bytes in the
403 * queue drops below this percentage of max-bytes.
407 g_object_class_install_property (gobject_class, PROP_MIN_PERCENT,
408 g_param_spec_uint ("min-percent", "Min Percent",
409 "Emit need-data when queued bytes drops below this percent of max-bytes",
410 0, 100, DEFAULT_PROP_MIN_PERCENT,
411 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
414 * GstAppSrc::need-data:
415 * @appsrc: the appsrc element that emitted the signal
416 * @length: the amount of bytes needed.
418 * Signal that the source needs more data. In the callback or from another
419 * thread you should call push-buffer or end-of-stream.
421 * @length is just a hint and when it is set to -1, any number of bytes can be
422 * pushed into @appsrc.
424 * You can call push-buffer multiple times until the enough-data signal is
427 gst_app_src_signals[SIGNAL_NEED_DATA] =
428 g_signal_new ("need-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
429 G_STRUCT_OFFSET (GstAppSrcClass, need_data),
430 NULL, NULL, __gst_app_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
433 * GstAppSrc::enough-data:
434 * @appsrc: the appsrc element that emitted the signal
436 * Signal that the source has enough data. It is recommended that the
437 * application stops calling push-buffer until the need-data signal is
438 * emitted again to avoid excessive buffer queueing.
440 gst_app_src_signals[SIGNAL_ENOUGH_DATA] =
441 g_signal_new ("enough-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
442 G_STRUCT_OFFSET (GstAppSrcClass, enough_data),
443 NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
446 * GstAppSrc::seek-data:
447 * @appsrc: the appsrc element that emitted the signal
448 * @offset: the offset to seek to
450 * Seek to the given offset. The next push-buffer should produce buffers from
452 * This callback is only called for seekable stream types.
454 * Returns: %TRUE if the seek succeeded.
456 gst_app_src_signals[SIGNAL_SEEK_DATA] =
457 g_signal_new ("seek-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
458 G_STRUCT_OFFSET (GstAppSrcClass, seek_data),
459 NULL, NULL, __gst_app_marshal_BOOLEAN__UINT64, G_TYPE_BOOLEAN, 1,
463 * GstAppSrc::push-buffer:
464 * @appsrc: the appsrc
465 * @buffer: a buffer to push
467 * Adds a buffer to the queue of buffers that the appsrc element will
468 * push to its source pad. This function does not take ownership of the
469 * buffer so the buffer needs to be unreffed after calling this function.
471 * When the block property is TRUE, this function can block until free space
472 * becomes available in the queue.
474 gst_app_src_signals[SIGNAL_PUSH_BUFFER] =
475 g_signal_new ("push-buffer", G_TYPE_FROM_CLASS (klass),
476 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSrcClass,
477 push_buffer), NULL, NULL, __gst_app_marshal_ENUM__OBJECT,
478 GST_TYPE_FLOW_RETURN, 1, GST_TYPE_BUFFER);
481 * GstAppSrc::end-of-stream:
482 * @appsrc: the appsrc
484 * Notify @appsrc that no more buffer are available.
486 gst_app_src_signals[SIGNAL_END_OF_STREAM] =
487 g_signal_new ("end-of-stream", G_TYPE_FROM_CLASS (klass),
488 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSrcClass,
489 end_of_stream), NULL, NULL, __gst_app_marshal_ENUM__VOID,
490 GST_TYPE_FLOW_RETURN, 0, G_TYPE_NONE);
492 basesrc_class->get_caps = gst_app_src_internal_get_caps;
493 basesrc_class->create = gst_app_src_create;
494 basesrc_class->start = gst_app_src_start;
495 basesrc_class->stop = gst_app_src_stop;
496 basesrc_class->unlock = gst_app_src_unlock;
497 basesrc_class->unlock_stop = gst_app_src_unlock_stop;
498 basesrc_class->do_seek = gst_app_src_do_seek;
499 basesrc_class->is_seekable = gst_app_src_is_seekable;
500 basesrc_class->check_get_range = gst_app_src_check_get_range;
501 basesrc_class->get_size = gst_app_src_do_get_size;
502 basesrc_class->get_size = gst_app_src_do_get_size;
503 basesrc_class->query = gst_app_src_query;
505 klass->push_buffer = gst_app_src_push_buffer_action;
506 klass->end_of_stream = gst_app_src_end_of_stream;
508 g_type_class_add_private (klass, sizeof (GstAppSrcPrivate));
512 gst_app_src_init (GstAppSrc * appsrc, GstAppSrcClass * klass)
514 GstAppSrcPrivate *priv;
516 priv = appsrc->priv = G_TYPE_INSTANCE_GET_PRIVATE (appsrc, GST_TYPE_APP_SRC,
519 priv->mutex = g_mutex_new ();
520 priv->cond = g_cond_new ();
521 priv->queue = g_queue_new ();
523 priv->size = DEFAULT_PROP_SIZE;
524 priv->stream_type = DEFAULT_PROP_STREAM_TYPE;
525 priv->max_bytes = DEFAULT_PROP_MAX_BYTES;
526 priv->format = DEFAULT_PROP_FORMAT;
527 priv->block = DEFAULT_PROP_BLOCK;
528 priv->min_latency = DEFAULT_PROP_MIN_LATENCY;
529 priv->max_latency = DEFAULT_PROP_MAX_LATENCY;
530 priv->emit_signals = DEFAULT_PROP_EMIT_SIGNALS;
531 priv->min_percent = DEFAULT_PROP_MIN_PERCENT;
533 gst_base_src_set_live (GST_BASE_SRC (appsrc), DEFAULT_PROP_IS_LIVE);
537 gst_app_src_flush_queued (GstAppSrc * src)
540 GstAppSrcPrivate *priv = src->priv;
542 while ((buf = g_queue_pop_head (priv->queue)))
543 gst_buffer_unref (buf);
544 priv->queued_bytes = 0;
548 gst_app_src_dispose (GObject * obj)
550 GstAppSrc *appsrc = GST_APP_SRC_CAST (obj);
551 GstAppSrcPrivate *priv = appsrc->priv;
554 gst_caps_unref (priv->caps);
557 gst_app_src_flush_queued (appsrc);
559 G_OBJECT_CLASS (parent_class)->dispose (obj);
563 gst_app_src_finalize (GObject * obj)
565 GstAppSrc *appsrc = GST_APP_SRC_CAST (obj);
566 GstAppSrcPrivate *priv = appsrc->priv;
568 g_mutex_free (priv->mutex);
569 g_cond_free (priv->cond);
570 g_queue_free (priv->queue);
572 G_OBJECT_CLASS (parent_class)->finalize (obj);
576 gst_app_src_internal_get_caps (GstBaseSrc * bsrc)
578 return gst_app_src_get_caps (GST_APP_SRC_CAST (bsrc));
582 gst_app_src_set_property (GObject * object, guint prop_id,
583 const GValue * value, GParamSpec * pspec)
585 GstAppSrc *appsrc = GST_APP_SRC_CAST (object);
586 GstAppSrcPrivate *priv = appsrc->priv;
590 gst_app_src_set_caps (appsrc, gst_value_get_caps (value));
593 gst_app_src_set_size (appsrc, g_value_get_int64 (value));
595 case PROP_STREAM_TYPE:
596 gst_app_src_set_stream_type (appsrc, g_value_get_enum (value));
599 gst_app_src_set_max_bytes (appsrc, g_value_get_uint64 (value));
602 priv->format = g_value_get_enum (value);
605 priv->block = g_value_get_boolean (value);
608 gst_base_src_set_live (GST_BASE_SRC (appsrc),
609 g_value_get_boolean (value));
611 case PROP_MIN_LATENCY:
612 gst_app_src_set_latencies (appsrc, TRUE, g_value_get_int64 (value),
615 case PROP_MAX_LATENCY:
616 gst_app_src_set_latencies (appsrc, FALSE, -1, TRUE,
617 g_value_get_int64 (value));
619 case PROP_EMIT_SIGNALS:
620 gst_app_src_set_emit_signals (appsrc, g_value_get_boolean (value));
622 case PROP_MIN_PERCENT:
623 priv->min_percent = g_value_get_uint (value);
626 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
632 gst_app_src_get_property (GObject * object, guint prop_id, GValue * value,
635 GstAppSrc *appsrc = GST_APP_SRC_CAST (object);
636 GstAppSrcPrivate *priv = appsrc->priv;
643 /* we're missing a _take_caps() function to transfer ownership */
644 caps = gst_app_src_get_caps (appsrc);
645 gst_value_set_caps (value, caps);
647 gst_caps_unref (caps);
651 g_value_set_int64 (value, gst_app_src_get_size (appsrc));
653 case PROP_STREAM_TYPE:
654 g_value_set_enum (value, gst_app_src_get_stream_type (appsrc));
657 g_value_set_uint64 (value, gst_app_src_get_max_bytes (appsrc));
660 g_value_set_enum (value, priv->format);
663 g_value_set_boolean (value, priv->block);
666 g_value_set_boolean (value, gst_base_src_is_live (GST_BASE_SRC (appsrc)));
668 case PROP_MIN_LATENCY:
672 gst_app_src_get_latency (appsrc, &min, NULL);
673 g_value_set_int64 (value, min);
676 case PROP_MAX_LATENCY:
680 gst_app_src_get_latency (appsrc, &max, NULL);
681 g_value_set_int64 (value, max);
684 case PROP_EMIT_SIGNALS:
685 g_value_set_boolean (value, gst_app_src_get_emit_signals (appsrc));
687 case PROP_MIN_PERCENT:
688 g_value_set_uint (value, priv->min_percent);
691 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
697 gst_app_src_unlock (GstBaseSrc * bsrc)
699 GstAppSrc *appsrc = GST_APP_SRC_CAST (bsrc);
700 GstAppSrcPrivate *priv = appsrc->priv;
702 g_mutex_lock (priv->mutex);
703 GST_DEBUG_OBJECT (appsrc, "unlock start");
704 priv->flushing = TRUE;
705 g_cond_broadcast (priv->cond);
706 g_mutex_unlock (priv->mutex);
712 gst_app_src_unlock_stop (GstBaseSrc * bsrc)
714 GstAppSrc *appsrc = GST_APP_SRC_CAST (bsrc);
715 GstAppSrcPrivate *priv = appsrc->priv;
717 g_mutex_lock (priv->mutex);
718 GST_DEBUG_OBJECT (appsrc, "unlock stop");
719 priv->flushing = FALSE;
720 g_cond_broadcast (priv->cond);
721 g_mutex_unlock (priv->mutex);
727 gst_app_src_start (GstBaseSrc * bsrc)
729 GstAppSrc *appsrc = GST_APP_SRC_CAST (bsrc);
730 GstAppSrcPrivate *priv = appsrc->priv;
732 g_mutex_lock (priv->mutex);
733 GST_DEBUG_OBJECT (appsrc, "starting");
734 priv->started = TRUE;
735 /* set the offset to -1 so that we always do a first seek. This is only used
736 * in random-access mode. */
738 priv->flushing = FALSE;
739 g_mutex_unlock (priv->mutex);
741 gst_base_src_set_format (bsrc, priv->format);
747 gst_app_src_stop (GstBaseSrc * bsrc)
749 GstAppSrc *appsrc = GST_APP_SRC_CAST (bsrc);
750 GstAppSrcPrivate *priv = appsrc->priv;
752 g_mutex_lock (priv->mutex);
753 GST_DEBUG_OBJECT (appsrc, "stopping");
754 priv->is_eos = FALSE;
755 priv->flushing = TRUE;
756 priv->started = FALSE;
757 gst_app_src_flush_queued (appsrc);
758 g_mutex_unlock (priv->mutex);
764 gst_app_src_is_seekable (GstBaseSrc * src)
766 GstAppSrc *appsrc = GST_APP_SRC_CAST (src);
767 GstAppSrcPrivate *priv = appsrc->priv;
768 gboolean res = FALSE;
770 switch (priv->stream_type) {
771 case GST_APP_STREAM_TYPE_STREAM:
773 case GST_APP_STREAM_TYPE_SEEKABLE:
774 case GST_APP_STREAM_TYPE_RANDOM_ACCESS:
782 gst_app_src_check_get_range (GstBaseSrc * src)
784 GstAppSrc *appsrc = GST_APP_SRC_CAST (src);
785 GstAppSrcPrivate *priv = appsrc->priv;
786 gboolean res = FALSE;
788 switch (priv->stream_type) {
789 case GST_APP_STREAM_TYPE_STREAM:
790 case GST_APP_STREAM_TYPE_SEEKABLE:
792 case GST_APP_STREAM_TYPE_RANDOM_ACCESS:
800 gst_app_src_do_get_size (GstBaseSrc * src, guint64 * size)
802 GstAppSrc *appsrc = GST_APP_SRC_CAST (src);
804 *size = gst_app_src_get_size (appsrc);
810 gst_app_src_query (GstBaseSrc * src, GstQuery * query)
812 GstAppSrc *appsrc = GST_APP_SRC_CAST (src);
813 GstAppSrcPrivate *priv = appsrc->priv;
816 switch (GST_QUERY_TYPE (query)) {
817 case GST_QUERY_LATENCY:
819 GstClockTime min, max;
822 /* Query the parent class for the defaults */
823 res = gst_base_src_query_latency (src, &live, &min, &max);
825 /* overwrite with our values when we need to */
826 g_mutex_lock (priv->mutex);
827 if (priv->min_latency != -1)
828 min = priv->min_latency;
829 if (priv->max_latency != -1)
830 max = priv->max_latency;
831 g_mutex_unlock (priv->mutex);
833 gst_query_set_latency (query, live, min, max);
837 res = GST_BASE_SRC_CLASS (parent_class)->query (src, query);
844 /* will be called in push mode */
846 gst_app_src_do_seek (GstBaseSrc * src, GstSegment * segment)
848 GstAppSrc *appsrc = GST_APP_SRC_CAST (src);
849 GstAppSrcPrivate *priv = appsrc->priv;
850 gint64 desired_position;
851 gboolean res = FALSE;
853 desired_position = segment->last_stop;
855 GST_DEBUG_OBJECT (appsrc, "seeking to %" G_GINT64_FORMAT ", format %s",
856 desired_position, gst_format_get_name (segment->format));
858 /* no need to try to seek in streaming mode */
859 if (priv->stream_type == GST_APP_STREAM_TYPE_STREAM)
862 if (priv->callbacks.seek_data)
863 res = priv->callbacks.seek_data (appsrc, desired_position, priv->user_data);
867 g_mutex_lock (priv->mutex);
868 emit = priv->emit_signals;
869 g_mutex_unlock (priv->mutex);
872 g_signal_emit (appsrc, gst_app_src_signals[SIGNAL_SEEK_DATA], 0,
873 desired_position, &res);
877 GST_DEBUG_OBJECT (appsrc, "flushing queue");
878 gst_app_src_flush_queued (appsrc);
879 priv->is_eos = FALSE;
881 GST_WARNING_OBJECT (appsrc, "seek failed");
887 /* must be called with the appsrc mutex */
889 gst_app_src_emit_seek (GstAppSrc * appsrc, guint64 offset)
891 gboolean res = FALSE;
893 GstAppSrcPrivate *priv = appsrc->priv;
895 emit = priv->emit_signals;
896 g_mutex_unlock (priv->mutex);
898 GST_DEBUG_OBJECT (appsrc,
899 "we are at %" G_GINT64_FORMAT ", seek to %" G_GINT64_FORMAT,
900 priv->offset, offset);
902 if (priv->callbacks.seek_data)
903 res = priv->callbacks.seek_data (appsrc, offset, priv->user_data);
905 g_signal_emit (appsrc, gst_app_src_signals[SIGNAL_SEEK_DATA], 0,
908 g_mutex_lock (priv->mutex);
913 /* must be called with the appsrc mutex. After this call things can be
916 gst_app_src_emit_need_data (GstAppSrc * appsrc, guint size)
919 GstAppSrcPrivate *priv = appsrc->priv;
921 emit = priv->emit_signals;
922 g_mutex_unlock (priv->mutex);
924 /* we have no data, we need some. We fire the signal with the size hint. */
925 if (priv->callbacks.need_data)
926 priv->callbacks.need_data (appsrc, size, priv->user_data);
928 g_signal_emit (appsrc, gst_app_src_signals[SIGNAL_NEED_DATA], 0, size,
931 g_mutex_lock (priv->mutex);
932 /* we can be flushing now because we released the lock */
936 gst_app_src_create (GstBaseSrc * bsrc, guint64 offset, guint size,
939 GstAppSrc *appsrc = GST_APP_SRC_CAST (bsrc);
940 GstAppSrcPrivate *priv = appsrc->priv;
944 GST_OBJECT_LOCK (appsrc);
945 caps = priv->caps ? gst_caps_ref (priv->caps) : NULL;
946 if (G_UNLIKELY (priv->size != bsrc->segment.duration &&
947 bsrc->segment.format == GST_FORMAT_BYTES)) {
948 GST_DEBUG_OBJECT (appsrc,
949 "Size changed from %" G_GINT64_FORMAT " to %" G_GINT64_FORMAT,
950 bsrc->segment.duration, priv->size);
951 gst_segment_set_duration (&bsrc->segment, GST_FORMAT_BYTES, priv->size);
952 GST_OBJECT_UNLOCK (appsrc);
954 gst_element_post_message (GST_ELEMENT (appsrc),
955 gst_message_new_duration (GST_OBJECT (appsrc), GST_FORMAT_BYTES,
958 GST_OBJECT_UNLOCK (appsrc);
961 g_mutex_lock (priv->mutex);
962 /* check flushing first */
963 if (G_UNLIKELY (priv->flushing))
966 if (priv->stream_type == GST_APP_STREAM_TYPE_RANDOM_ACCESS) {
967 /* if we are dealing with a random-access stream, issue a seek if the offset
969 if (G_UNLIKELY (priv->offset != offset)) {
973 res = gst_app_src_emit_seek (appsrc, offset);
975 if (G_UNLIKELY (!res))
976 /* failing to seek is fatal */
979 priv->offset = offset;
984 /* return data as long as we have some */
985 if (!g_queue_is_empty (priv->queue)) {
988 *buf = g_queue_pop_head (priv->queue);
989 buf_size = GST_BUFFER_SIZE (*buf);
991 GST_DEBUG_OBJECT (appsrc, "we have buffer %p of size %u", *buf, buf_size);
993 priv->queued_bytes -= buf_size;
995 /* only update the offset when in random_access mode */
996 if (priv->stream_type == GST_APP_STREAM_TYPE_RANDOM_ACCESS)
997 priv->offset += buf_size;
999 *buf = gst_buffer_make_metadata_writable (*buf);
1000 gst_buffer_set_caps (*buf, caps);
1003 /* signal that we removed an item */
1004 g_cond_broadcast (priv->cond);
1006 /* see if we go lower than the empty-percent */
1007 if (priv->min_percent && priv->max_bytes) {
1008 if (priv->queued_bytes * 100 / priv->max_bytes <= priv->min_percent)
1009 /* ignore flushing state, we got a buffer and we will return it now.
1010 * Errors will be handled in the next round */
1011 gst_app_src_emit_need_data (appsrc, size);
1016 gst_app_src_emit_need_data (appsrc, size);
1018 /* we can be flushing now because we released the lock above */
1019 if (G_UNLIKELY (priv->flushing))
1022 /* if we have a buffer now, continue the loop and try to return it. In
1023 * random-access mode (where a buffer is normally pushed in the above
1024 * signal) we can still be empty because the pushed buffer got flushed or
1025 * when the application pushes the requested buffer later, we support both
1027 if (!g_queue_is_empty (priv->queue))
1030 /* no buffer yet, maybe we are EOS, if not, block for more data. */
1034 if (G_UNLIKELY (priv->is_eos))
1037 /* nothing to return, wait a while for new data or flushing. */
1038 g_cond_wait (priv->cond, priv->mutex);
1040 g_mutex_unlock (priv->mutex);
1042 gst_caps_unref (caps);
1048 GST_DEBUG_OBJECT (appsrc, "we are flushing");
1049 g_mutex_unlock (priv->mutex);
1051 gst_caps_unref (caps);
1052 return GST_FLOW_WRONG_STATE;
1056 GST_DEBUG_OBJECT (appsrc, "we are EOS");
1057 g_mutex_unlock (priv->mutex);
1059 gst_caps_unref (caps);
1060 return GST_FLOW_UNEXPECTED;
1064 g_mutex_unlock (priv->mutex);
1066 gst_caps_unref (caps);
1067 GST_ELEMENT_ERROR (appsrc, RESOURCE, READ, ("failed to seek"),
1069 return GST_FLOW_ERROR;
1076 * gst_app_src_set_caps:
1077 * @appsrc: a #GstAppSrc
1078 * @caps: caps to set
1080 * Set the capabilities on the appsrc element. This function takes
1081 * a copy of the caps structure. After calling this method, the source will
1082 * only produce caps that match @caps. @caps must be fixed and the caps on the
1083 * buffers must match the caps or left NULL.
1088 gst_app_src_set_caps (GstAppSrc * appsrc, const GstCaps * caps)
1091 GstAppSrcPrivate *priv;
1093 g_return_if_fail (GST_IS_APP_SRC (appsrc));
1095 priv = appsrc->priv;
1097 GST_OBJECT_LOCK (appsrc);
1098 GST_DEBUG_OBJECT (appsrc, "setting caps to %" GST_PTR_FORMAT, caps);
1099 if ((old = priv->caps) != caps) {
1101 priv->caps = gst_caps_copy (caps);
1105 gst_caps_unref (old);
1107 GST_OBJECT_UNLOCK (appsrc);
1111 * gst_app_src_get_caps:
1112 * @appsrc: a #GstAppSrc
1114 * Get the configured caps on @appsrc.
1116 * Returns: the #GstCaps produced by the source. gst_caps_unref() after usage.
1121 gst_app_src_get_caps (GstAppSrc * appsrc)
1124 GstAppSrcPrivate *priv;
1126 g_return_val_if_fail (GST_IS_APP_SRC (appsrc), NULL);
1128 priv = appsrc->priv;
1130 GST_OBJECT_LOCK (appsrc);
1131 if ((caps = priv->caps))
1132 gst_caps_ref (caps);
1133 GST_DEBUG_OBJECT (appsrc, "getting caps of %" GST_PTR_FORMAT, caps);
1134 GST_OBJECT_UNLOCK (appsrc);
1140 * gst_app_src_set_size:
1141 * @appsrc: a #GstAppSrc
1142 * @size: the size to set
1144 * Set the size of the stream in bytes. A value of -1 means that the size is
1150 gst_app_src_set_size (GstAppSrc * appsrc, gint64 size)
1152 GstAppSrcPrivate *priv;
1154 g_return_if_fail (GST_IS_APP_SRC (appsrc));
1156 priv = appsrc->priv;
1158 GST_OBJECT_LOCK (appsrc);
1159 GST_DEBUG_OBJECT (appsrc, "setting size of %" G_GINT64_FORMAT, size);
1161 GST_OBJECT_UNLOCK (appsrc);
1165 * gst_app_src_get_size:
1166 * @appsrc: a #GstAppSrc
1168 * Get the size of the stream in bytes. A value of -1 means that the size is
1171 * Returns: the size of the stream previously set with gst_app_src_set_size();
1176 gst_app_src_get_size (GstAppSrc * appsrc)
1179 GstAppSrcPrivate *priv;
1181 g_return_val_if_fail (GST_IS_APP_SRC (appsrc), -1);
1183 priv = appsrc->priv;
1185 GST_OBJECT_LOCK (appsrc);
1187 GST_DEBUG_OBJECT (appsrc, "getting size of %" G_GINT64_FORMAT, size);
1188 GST_OBJECT_UNLOCK (appsrc);
1194 * gst_app_src_set_stream_type:
1195 * @appsrc: a #GstAppSrc
1196 * @type: the new state
1198 * Set the stream type on @appsrc. For seekable streams, the "seek" signal must
1201 * A stream_type stream
1206 gst_app_src_set_stream_type (GstAppSrc * appsrc, GstAppStreamType type)
1208 GstAppSrcPrivate *priv;
1210 g_return_if_fail (GST_IS_APP_SRC (appsrc));
1212 priv = appsrc->priv;
1214 GST_OBJECT_LOCK (appsrc);
1215 GST_DEBUG_OBJECT (appsrc, "setting stream_type of %d", type);
1216 priv->stream_type = type;
1217 GST_OBJECT_UNLOCK (appsrc);
1221 * gst_app_src_get_stream_type:
1222 * @appsrc: a #GstAppSrc
1224 * Get the stream type. Control the stream type of @appsrc
1225 * with gst_app_src_set_stream_type().
1227 * Returns: the stream type.
1232 gst_app_src_get_stream_type (GstAppSrc * appsrc)
1234 gboolean stream_type;
1235 GstAppSrcPrivate *priv;
1237 g_return_val_if_fail (GST_IS_APP_SRC (appsrc), FALSE);
1239 priv = appsrc->priv;
1241 GST_OBJECT_LOCK (appsrc);
1242 stream_type = priv->stream_type;
1243 GST_DEBUG_OBJECT (appsrc, "getting stream_type of %d", stream_type);
1244 GST_OBJECT_UNLOCK (appsrc);
1250 * gst_app_src_set_max_bytes:
1251 * @appsrc: a #GstAppSrc
1252 * @max: the maximum number of bytes to queue
1254 * Set the maximum amount of bytes that can be queued in @appsrc.
1255 * After the maximum amount of bytes are queued, @appsrc will emit the
1256 * "enough-data" signal.
1261 gst_app_src_set_max_bytes (GstAppSrc * appsrc, guint64 max)
1263 GstAppSrcPrivate *priv;
1265 g_return_if_fail (GST_IS_APP_SRC (appsrc));
1267 priv = appsrc->priv;
1269 g_mutex_lock (priv->mutex);
1270 if (max != priv->max_bytes) {
1271 GST_DEBUG_OBJECT (appsrc, "setting max-bytes to %" G_GUINT64_FORMAT, max);
1272 priv->max_bytes = max;
1273 /* signal the change */
1274 g_cond_broadcast (priv->cond);
1276 g_mutex_unlock (priv->mutex);
1280 * gst_app_src_get_max_bytes:
1281 * @appsrc: a #GstAppSrc
1283 * Get the maximum amount of bytes that can be queued in @appsrc.
1285 * Returns: The maximum amount of bytes that can be queued.
1290 gst_app_src_get_max_bytes (GstAppSrc * appsrc)
1293 GstAppSrcPrivate *priv;
1295 g_return_val_if_fail (GST_IS_APP_SRC (appsrc), 0);
1297 priv = appsrc->priv;
1299 g_mutex_lock (priv->mutex);
1300 result = priv->max_bytes;
1301 GST_DEBUG_OBJECT (appsrc, "getting max-bytes of %" G_GUINT64_FORMAT, result);
1302 g_mutex_unlock (priv->mutex);
1308 gst_app_src_set_latencies (GstAppSrc * appsrc, gboolean do_min, guint64 min,
1309 gboolean do_max, guint64 max)
1311 GstAppSrcPrivate *priv = appsrc->priv;
1312 gboolean changed = FALSE;
1314 g_mutex_lock (priv->mutex);
1315 if (do_min && priv->min_latency != min) {
1316 priv->min_latency = min;
1319 if (do_max && priv->max_latency != max) {
1320 priv->max_latency = max;
1323 g_mutex_unlock (priv->mutex);
1326 GST_DEBUG_OBJECT (appsrc, "posting latency changed");
1327 gst_element_post_message (GST_ELEMENT_CAST (appsrc),
1328 gst_message_new_latency (GST_OBJECT_CAST (appsrc)));
1333 * gst_app_src_set_latency:
1334 * @appsrc: a #GstAppSrc
1335 * @min: the min latency
1336 * @max: the min latency
1338 * Configure the @min and @max latency in @src. If @min is set to -1, the
1339 * default latency calculations for pseudo-live sources will be used.
1344 gst_app_src_set_latency (GstAppSrc * appsrc, guint64 min, guint64 max)
1346 gst_app_src_set_latencies (appsrc, TRUE, min, TRUE, max);
1350 * gst_app_src_get_latency:
1351 * @appsrc: a #GstAppSrc
1352 * @min: the min latency
1353 * @max: the min latency
1355 * Retrieve the min and max latencies in @min and @max respectively.
1360 gst_app_src_get_latency (GstAppSrc * appsrc, guint64 * min, guint64 * max)
1362 GstAppSrcPrivate *priv;
1364 g_return_if_fail (GST_IS_APP_SRC (appsrc));
1366 priv = appsrc->priv;
1368 g_mutex_lock (priv->mutex);
1370 *min = priv->min_latency;
1372 *max = priv->max_latency;
1373 g_mutex_unlock (priv->mutex);
1377 * gst_app_src_set_emit_signals:
1378 * @appsrc: a #GstAppSrc
1379 * @emit: the new state
1381 * Make appsrc emit the "new-preroll" and "new-buffer" signals. This option is
1382 * by default disabled because signal emission is expensive and unneeded when
1383 * the application prefers to operate in pull mode.
1388 gst_app_src_set_emit_signals (GstAppSrc * appsrc, gboolean emit)
1390 GstAppSrcPrivate *priv;
1392 g_return_if_fail (GST_IS_APP_SRC (appsrc));
1394 priv = appsrc->priv;
1396 g_mutex_lock (priv->mutex);
1397 priv->emit_signals = emit;
1398 g_mutex_unlock (priv->mutex);
1402 * gst_app_src_get_emit_signals:
1403 * @appsrc: a #GstAppSrc
1405 * Check if appsrc will emit the "new-preroll" and "new-buffer" signals.
1407 * Returns: %TRUE if @appsrc is emitting the "new-preroll" and "new-buffer"
1413 gst_app_src_get_emit_signals (GstAppSrc * appsrc)
1416 GstAppSrcPrivate *priv;
1418 g_return_val_if_fail (GST_IS_APP_SRC (appsrc), FALSE);
1420 priv = appsrc->priv;
1422 g_mutex_lock (priv->mutex);
1423 result = priv->emit_signals;
1424 g_mutex_unlock (priv->mutex);
1429 static GstFlowReturn
1430 gst_app_src_push_buffer_full (GstAppSrc * appsrc, GstBuffer * buffer,
1433 gboolean first = TRUE;
1434 GstAppSrcPrivate *priv;
1436 g_return_val_if_fail (GST_IS_APP_SRC (appsrc), GST_FLOW_ERROR);
1437 g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR);
1439 priv = appsrc->priv;
1441 g_mutex_lock (priv->mutex);
1444 /* can't accept buffers when we are flushing or EOS */
1451 if (priv->max_bytes && priv->queued_bytes >= priv->max_bytes) {
1452 GST_DEBUG_OBJECT (appsrc,
1453 "queue filled (%" G_GUINT64_FORMAT " >= %" G_GUINT64_FORMAT ")",
1454 priv->queued_bytes, priv->max_bytes);
1459 emit = priv->emit_signals;
1460 /* only signal on the first push */
1461 g_mutex_unlock (priv->mutex);
1463 if (priv->callbacks.enough_data)
1464 priv->callbacks.enough_data (appsrc, priv->user_data);
1466 g_signal_emit (appsrc, gst_app_src_signals[SIGNAL_ENOUGH_DATA], 0,
1469 g_mutex_lock (priv->mutex);
1470 /* continue to check for flushing/eos after releasing the lock */
1475 GST_DEBUG_OBJECT (appsrc, "waiting for free space");
1476 /* we are filled, wait until a buffer gets popped or when we
1478 g_cond_wait (priv->cond, priv->mutex);
1480 /* no need to wait for free space, we just pump more data into the
1481 * queue hoping that the caller reacts to the enough-data signal and
1482 * stops pushing buffers. */
1489 GST_DEBUG_OBJECT (appsrc, "queueing buffer %p", buffer);
1491 gst_buffer_ref (buffer);
1492 g_queue_push_tail (priv->queue, buffer);
1493 priv->queued_bytes += GST_BUFFER_SIZE (buffer);
1494 g_cond_broadcast (priv->cond);
1495 g_mutex_unlock (priv->mutex);
1502 GST_DEBUG_OBJECT (appsrc, "refuse buffer %p, we are flushing", buffer);
1504 gst_buffer_unref (buffer);
1505 g_mutex_unlock (priv->mutex);
1506 return GST_FLOW_WRONG_STATE;
1510 GST_DEBUG_OBJECT (appsrc, "refuse buffer %p, we are EOS", buffer);
1512 gst_buffer_unref (buffer);
1513 g_mutex_unlock (priv->mutex);
1514 return GST_FLOW_UNEXPECTED;
1519 * gst_app_src_push_buffer:
1520 * @appsrc: a #GstAppSrc
1521 * @buffer: a #GstBuffer to push
1523 * Adds a buffer to the queue of buffers that the appsrc element will
1524 * push to its source pad. This function takes ownership of the buffer.
1526 * When the block property is TRUE, this function can block until free
1527 * space becomes available in the queue.
1529 * Returns: #GST_FLOW_OK when the buffer was successfuly queued.
1530 * #GST_FLOW_WRONG_STATE when @appsrc is not PAUSED or PLAYING.
1531 * #GST_FLOW_UNEXPECTED when EOS occured.
1536 gst_app_src_push_buffer (GstAppSrc * appsrc, GstBuffer * buffer)
1538 return gst_app_src_push_buffer_full (appsrc, buffer, TRUE);
1541 /* push a buffer without stealing the ref of the buffer. This is used for the
1543 static GstFlowReturn
1544 gst_app_src_push_buffer_action (GstAppSrc * appsrc, GstBuffer * buffer)
1546 return gst_app_src_push_buffer_full (appsrc, buffer, FALSE);
1550 * gst_app_src_end_of_stream:
1551 * @appsrc: a #GstAppSrc
1553 * Indicates to the appsrc element that the last buffer queued in the
1554 * element is the last buffer of the stream.
1556 * Returns: #GST_FLOW_OK when the EOS was successfuly queued.
1557 * #GST_FLOW_WRONG_STATE when @appsrc is not PAUSED or PLAYING.
1562 gst_app_src_end_of_stream (GstAppSrc * appsrc)
1564 GstAppSrcPrivate *priv;
1566 g_return_val_if_fail (GST_IS_APP_SRC (appsrc), GST_FLOW_ERROR);
1568 priv = appsrc->priv;
1570 g_mutex_lock (priv->mutex);
1571 /* can't accept buffers when we are flushing. We can accept them when we are
1572 * EOS although it will not do anything. */
1576 GST_DEBUG_OBJECT (appsrc, "sending EOS");
1577 priv->is_eos = TRUE;
1578 g_cond_broadcast (priv->cond);
1579 g_mutex_unlock (priv->mutex);
1586 g_mutex_unlock (priv->mutex);
1587 GST_DEBUG_OBJECT (appsrc, "refuse EOS, we are flushing");
1588 return GST_FLOW_WRONG_STATE;
1593 * gst_app_src_set_callbacks:
1594 * @appsrc: a #GstAppSrc
1595 * @callbacks: the callbacks
1596 * @user_data: a user_data argument for the callbacks
1597 * @notify: a destroy notify function
1599 * Set callbacks which will be executed when data is needed, enough data has
1600 * been collected or when a seek should be performed.
1601 * This is an alternative to using the signals, it has lower overhead and is thus
1602 * less expensive, but also less flexible.
1604 * If callbacks are installed, no signals will be emitted for performance
1610 gst_app_src_set_callbacks (GstAppSrc * appsrc,
1611 GstAppSrcCallbacks * callbacks, gpointer user_data, GDestroyNotify notify)
1613 GDestroyNotify old_notify;
1614 GstAppSrcPrivate *priv;
1616 g_return_if_fail (GST_IS_APP_SRC (appsrc));
1617 g_return_if_fail (callbacks != NULL);
1619 priv = appsrc->priv;
1621 GST_OBJECT_LOCK (appsrc);
1622 old_notify = priv->notify;
1627 old_data = priv->user_data;
1629 priv->user_data = NULL;
1630 priv->notify = NULL;
1631 GST_OBJECT_UNLOCK (appsrc);
1633 old_notify (old_data);
1635 GST_OBJECT_LOCK (appsrc);
1637 priv->callbacks = *callbacks;
1638 priv->user_data = user_data;
1639 priv->notify = notify;
1640 GST_OBJECT_UNLOCK (appsrc);
1644 gst_app_src_send_event (GstElement * element, GstEvent * event)
1647 gboolean result = FALSE;
1650 src = GST_BASE_SRC (element);
1651 appsrc = GST_APP_SRC (element);
1652 GstAppSrcPrivate *priv = appsrc->priv;
1654 GST_DEBUG_OBJECT (appsrc, "handling event %p %" GST_PTR_FORMAT, event, event);
1656 switch (GST_EVENT_TYPE (event)) {
1657 /* bidirectional events */
1658 case GST_EVENT_FLUSH_STOP:
1659 g_mutex_lock (priv->mutex);
1660 GST_INFO_OBJECT (appsrc, "flushing internal queue");
1661 gst_app_src_flush_queued (appsrc);
1662 priv->flushing = FALSE;
1663 g_mutex_unlock (priv->mutex);
1664 result = gst_pad_push_event (src ->srcpad, event);
1667 case GST_EVENT_FLUSH_START:
1668 g_mutex_lock (priv->mutex);
1669 priv->flushing = TRUE;
1670 g_mutex_unlock (priv->mutex);
1671 result = gst_pad_push_event (src ->srcpad, event);
1673 case GST_EVENT_NEWSEGMENT:
1674 result = gst_pad_push_event (src ->srcpad, event);
1677 result = GST_ELEMENT_CLASS (parent_class)->send_event (element, event);
1684 /*** GSTURIHANDLER INTERFACE *************************************************/
1687 gst_app_src_uri_get_type (void)
1693 gst_app_src_uri_get_protocols (void)
1695 static gchar *protocols[] = { (char *) "appsrc", NULL };
1700 static const gchar *
1701 gst_app_src_uri_get_uri (GstURIHandler * handler)
1707 gst_app_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
1712 protocol = gst_uri_get_protocol (uri);
1713 ret = !strcmp (protocol, "appsrc");
1720 gst_app_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
1722 GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
1724 iface->get_type = gst_app_src_uri_get_type;
1725 iface->get_protocols = gst_app_src_uri_get_protocols;
1726 iface->get_uri = gst_app_src_uri_get_uri;
1727 iface->set_uri = gst_app_src_uri_set_uri;