diff -r 000000000000 -r 0e761a78d257 gst_plugins_base/gst-libs/gst/app/gstappsink.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gst_plugins_base/gst-libs/gst/app/gstappsink.c Thu Dec 17 08:53:32 2009 +0200 @@ -0,0 +1,1253 @@ +/* GStreamer + * Copyright (C) 2007 David Schleef + * (C) 2008 Wim Taymans + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/** + * SECTION:element-appsink + * + * Appsink is a sink plugin that supports many different methods for making + * the application get a handle on the GStreamer data in a pipeline. Unlike + * most GStreamer elements, Appsink provides external API functions. + * + * For the documentation of the API, please see the + * libgstapp section in + * the GStreamer Plugins Base Libraries documentation. + * + * Since: 0.10.22 + */ + + +/** + * SECTION:gstappsink + * @see_also: #GstBaseSink, appsrc + * + * Appsink is a sink plugin that supports many different methods for making + * the application get a handle on the GStreamer data in a pipeline. Unlike + * most GStreamer elements, Appsink provides external API functions. + * + * appsink can be used by linking to the gstappsink.h header file to access the + * methods or by using the appsink action signals and properties. + * + * The normal way of retrieving buffers from appsink is by using the + * gst_app_sink_pull_buffer() and gst_app_sink_pull_preroll() methods. + * These methods block until a buffer becomes available in the sink or when the + * sink is shut down or reaches EOS. + * + * Appsink will internally use a queue to collect buffers from the streaming + * thread. If the application is not pulling buffers fast enough, this queue + * will consume a lot of memory over time. The "max-buffers" property can be + * used to limit the queue size. The "drop" property controls whether the + * streaming thread blocks or if older buffers are dropped when the maximum + * queue size is reached. Note that blocking the streaming thread can negatively + * affect real-time performance and should be avoided. + * + * If a blocking behaviour is not desirable, setting the "emit-signals" property + * to %TRUE will make appsink emit the "new-buffer" and "new-preroll" signals + * when a buffer can be pulled without blocking. + * + * The "caps" property on appsink can be used to control the formats that + * appsink can receive. This property can contain non-fixed caps, the format of + * the pulled buffers can be obtained by getting the buffer caps. + * + * If one of the pull-preroll or pull-buffer methods return %NULL, the appsink + * is stopped or in the EOS state. You can check for the EOS state with the + * "eos" property or with the gst_app_sink_is_eos() method. + * + * The eos signal can also be used to be informed when the EOS state is reached + * to avoid polling. + * + * Last reviewed on 2008-12-17 (0.10.22) + * + * Since: 0.10.22 + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include + +#include + +#include "gstappsink.h" +#ifdef __SYMBIAN32__ +#include +#endif +struct _GstAppSinkPrivate +{ + GstCaps *caps; + gboolean emit_signals; + guint max_buffers; + gboolean drop; + + GCond *cond; + GMutex *mutex; + GQueue *queue; + GstBuffer *preroll; + gboolean flushing; + gboolean started; + gboolean is_eos; + + GstAppSinkCallbacks callbacks; + gpointer user_data; + GDestroyNotify notify; +}; + +GST_DEBUG_CATEGORY_STATIC (app_sink_debug); +#define GST_CAT_DEFAULT app_sink_debug + +enum +{ + /* signals */ + SIGNAL_EOS, + SIGNAL_NEW_PREROLL, + SIGNAL_NEW_BUFFER, + + /* actions */ + SIGNAL_PULL_PREROLL, + SIGNAL_PULL_BUFFER, + + LAST_SIGNAL +}; + +#define DEFAULT_PROP_EOS TRUE +#define DEFAULT_PROP_EMIT_SIGNALS FALSE +#define DEFAULT_PROP_MAX_BUFFERS 0 +#define DEFAULT_PROP_DROP FALSE + +enum +{ + PROP_0, + PROP_CAPS, + PROP_EOS, + PROP_EMIT_SIGNALS, + PROP_MAX_BUFFERS, + PROP_DROP, + PROP_LAST +}; + +static GstStaticPadTemplate gst_app_sink_template = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS_ANY); + +static void gst_app_sink_uri_handler_init (gpointer g_iface, + gpointer iface_data); + +static void gst_app_sink_dispose (GObject * object); +static void gst_app_sink_finalize (GObject * object); + +#ifdef __SYMBIAN32__ +static void gst_app_sink_class_init (GstAppSinkClass * klass); +static void gst_app_sink_init (GstAppSink * appsink, GstAppSinkClass * klass); +static void gst_app_sink_base_init (gpointer g_class); +#endif + +static void gst_app_sink_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_app_sink_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static gboolean gst_app_sink_unlock_start (GstBaseSink * bsink); +static gboolean gst_app_sink_unlock_stop (GstBaseSink * bsink); +static gboolean gst_app_sink_start (GstBaseSink * psink); +static gboolean gst_app_sink_stop (GstBaseSink * psink); +static gboolean gst_app_sink_event (GstBaseSink * sink, GstEvent * event); +static GstFlowReturn gst_app_sink_preroll (GstBaseSink * psink, + GstBuffer * buffer); +static GstFlowReturn gst_app_sink_render (GstBaseSink * psink, + GstBuffer * buffer); +static GstCaps *gst_app_sink_getcaps (GstBaseSink * psink); + +static guint gst_app_sink_signals[LAST_SIGNAL] = { 0 }; + +static void +_do_init (GType filesrc_type) +{ + static const GInterfaceInfo urihandler_info = { + gst_app_sink_uri_handler_init, + NULL, + NULL + }; + g_type_add_interface_static (filesrc_type, GST_TYPE_URI_HANDLER, + &urihandler_info); +} +#ifndef __SYMBIAN32__ +GST_BOILERPLATE_FULL (GstAppSink, gst_app_sink, GstBaseSink, GST_TYPE_BASE_SINK, + _do_init); +#else +static GstBaseSinkClass *parent_class = NULL; +static void +gst_app_sink_class_init_trampoline (gpointer g_class, + gpointer data) +{ + parent_class = (GstBaseSinkClass *) + g_type_class_peek_parent (g_class); + gst_app_sink_class_init ((GstAppSinkClass *)g_class); +} + +EXPORT_C GType +gst_app_sink_get_type (void) +{ +static GType object_type = 0; + if (G_UNLIKELY (object_type == 0)) { + object_type = gst_type_register_static_full(GST_TYPE_BASE_SINK, + "GstAppSink", + sizeof (GstAppSinkClass), + (GBaseInitFunc) gst_app_sink_base_init, + NULL, + (GClassInitFunc) gst_app_sink_class_init_trampoline, + NULL, + NULL, + sizeof (GstAppSink), + 0, + (GInstanceInitFunc) gst_app_sink_init, + NULL, + (GTypeFlags) 0); + _do_init (object_type); + } + return object_type; +} +#endif +/* Can't use glib-genmarshal for this, as it doesn't know how to handle + * GstMiniObject-based types, which are a new fundamental type */ +static void +gst_app_marshal_BUFFER__VOID (GClosure * closure, + GValue * return_value, + guint n_param_values, + const GValue * param_values, + gpointer invocation_hint, gpointer marshal_data) +{ + typedef GstBuffer *(*GMarshalFunc_BUFFER__VOID) (gpointer data1, + gpointer data2); + register GMarshalFunc_BUFFER__VOID callback; + register GCClosure *cc = (GCClosure *) closure; + register gpointer data1, data2; + GstBuffer *v_return; + + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 1); + + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = g_value_peek_pointer (param_values + 0); + } else { + data1 = g_value_peek_pointer (param_values + 0); + data2 = closure->data; + } + callback = + (GMarshalFunc_BUFFER__VOID) (marshal_data ? marshal_data : cc->callback); + + v_return = callback (data1, data2); + + gst_value_take_buffer (return_value, v_return); +} + +static void +gst_app_sink_base_init (gpointer g_class) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); + + GST_DEBUG_CATEGORY_INIT (app_sink_debug, "appsink", 0, "appsink element"); + + gst_element_class_set_details_simple (element_class, "AppSink", + "Generic/Sink", "Allow the application to get access to raw buffer", + "David Schleef , Wim Taymans "); + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_app_sink_template)); +} + +static void +gst_app_sink_class_init (GstAppSinkClass * klass) +{ + GObjectClass *gobject_class = (GObjectClass *) klass; + GstBaseSinkClass *basesink_class = (GstBaseSinkClass *) klass; + + gobject_class->dispose = gst_app_sink_dispose; + gobject_class->finalize = gst_app_sink_finalize; + + gobject_class->set_property = gst_app_sink_set_property; + gobject_class->get_property = gst_app_sink_get_property; + + g_object_class_install_property (gobject_class, PROP_CAPS, + g_param_spec_boxed ("caps", "Caps", + "The allowed caps for the sink pad", GST_TYPE_CAPS, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, PROP_EOS, + g_param_spec_boolean ("eos", "EOS", + "Check if the sink is EOS or not started", DEFAULT_PROP_EOS, + G_PARAM_READABLE)); + + g_object_class_install_property (gobject_class, PROP_EMIT_SIGNALS, + g_param_spec_boolean ("emit-signals", "Emit signals", + "Emit new-preroll and new-buffer signals", DEFAULT_PROP_EMIT_SIGNALS, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, PROP_MAX_BUFFERS, + g_param_spec_uint ("max-buffers", "Max Buffers", + "The maximum number of buffers to queue internally (0 = unlimited)", + 0, G_MAXUINT, DEFAULT_PROP_MAX_BUFFERS, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, PROP_DROP, + g_param_spec_boolean ("drop", "Drop", + "Drop old buffers when the buffer queue is filled", DEFAULT_PROP_DROP, + G_PARAM_READWRITE)); + + /** + * GstAppSink::eos: + * @appsink: the appsink element that emited the signal + * + * Signal that the end-of-stream has been reached. This signal is emited from + * the steaming thread. + */ + gst_app_sink_signals[SIGNAL_EOS] = + g_signal_new ("eos", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GstAppSinkClass, eos), + NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE); + /** + * GstAppSink::new-preroll: + * @appsink: the appsink element that emited the signal + * + * Signal that a new preroll buffer is available. + * + * This signal is emited from the steaming thread and only when the + * "emit-signals" property is %TRUE. + * + * The new preroll buffer can be retrieved with the "pull-preroll" action + * signal or gst_app_sink_pull_preroll() either from this signal callback + * or from any other thread. + * + * Note that this signal is only emited when the "emit-signals" property is + * set to %TRUE, which it is not by default for performance reasons. + */ + gst_app_sink_signals[SIGNAL_NEW_PREROLL] = + g_signal_new ("new-preroll", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GstAppSinkClass, new_preroll), + NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE); + /** + * GstAppSink::new-buffer: + * @appsink: the appsink element that emited the signal + * + * Signal that a new buffer is available. + * + * This signal is emited from the steaming thread and only when the + * "emit-signals" property is %TRUE. + * + * The new buffer can be retrieved with the "pull-buffer" action + * signal or gst_app_sink_pull_buffer() either from this signal callback + * or from any other thread. + * + * Note that this signal is only emited when the "emit-signals" property is + * set to %TRUE, which it is not by default for performance reasons. + */ + gst_app_sink_signals[SIGNAL_NEW_BUFFER] = + g_signal_new ("new-buffer", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GstAppSinkClass, new_buffer), + NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE); + + /** + * GstAppSink::pull-preroll: + * @appsink: the appsink element to emit this signal on + * + * Get the last preroll buffer in @appsink. This was the buffer that caused the + * appsink to preroll in the PAUSED state. This buffer can be pulled many times + * and remains available to the application even after EOS. + * + * This function is typically used when dealing with a pipeline in the PAUSED + * state. Calling this function after doing a seek will give the buffer right + * after the seek position. + * + * Note that the preroll buffer will also be returned as the first buffer + * when calling gst_app_sink_pull_buffer() or the "pull-buffer" action signal. + * + * If an EOS event was received before any buffers, this function returns + * %NULL. Use gst_app_sink_is_eos () to check for the EOS condition. + * + * This function blocks until a preroll buffer or EOS is received or the appsink + * element is set to the READY/NULL state. + * + * Returns: a #GstBuffer or NULL when the appsink is stopped or EOS. + */ + gst_app_sink_signals[SIGNAL_PULL_PREROLL] = + g_signal_new ("pull-preroll", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSinkClass, + pull_preroll), NULL, NULL, gst_app_marshal_BUFFER__VOID, + GST_TYPE_BUFFER, 0, G_TYPE_NONE); + /** + * GstAppSink::pull-buffer: + * @appsink: the appsink element to emit this signal on + * + * This function blocks until a buffer or EOS becomes available or the appsink + * element is set to the READY/NULL state. + * + * This function will only return buffers when the appsink is in the PLAYING + * state. All rendered buffers will be put in a queue so that the application + * can pull buffers at its own rate. + * + * Note that when the application does not pull buffers fast enough, the + * queued buffers could consume a lot of memory, especially when dealing with + * raw video frames. It's possible to control the behaviour of the queue with + * the "drop" and "max-buffers" properties. + * + * If an EOS event was received before any buffers, this function returns + * %NULL. Use gst_app_sink_is_eos () to check for the EOS condition. + * + * Returns: a #GstBuffer or NULL when the appsink is stopped or EOS. + */ + gst_app_sink_signals[SIGNAL_PULL_BUFFER] = + g_signal_new ("pull-buffer", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSinkClass, + pull_buffer), NULL, NULL, gst_app_marshal_BUFFER__VOID, + GST_TYPE_BUFFER, 0, G_TYPE_NONE); + + basesink_class->unlock = gst_app_sink_unlock_start; + basesink_class->unlock_stop = gst_app_sink_unlock_stop; + basesink_class->start = gst_app_sink_start; + basesink_class->stop = gst_app_sink_stop; + basesink_class->event = gst_app_sink_event; + basesink_class->preroll = gst_app_sink_preroll; + basesink_class->render = gst_app_sink_render; + basesink_class->get_caps = gst_app_sink_getcaps; + + klass->pull_preroll = gst_app_sink_pull_preroll; + klass->pull_buffer = gst_app_sink_pull_buffer; + + g_type_class_add_private (klass, sizeof (GstAppSinkPrivate)); +} + +static void +gst_app_sink_init (GstAppSink * appsink, GstAppSinkClass * klass) +{ + appsink->priv = G_TYPE_INSTANCE_GET_PRIVATE (appsink, GST_TYPE_APP_SINK, + GstAppSinkPrivate); + + appsink->priv->mutex = g_mutex_new (); + appsink->priv->cond = g_cond_new (); + appsink->priv->queue = g_queue_new (); + + appsink->priv->emit_signals = DEFAULT_PROP_EMIT_SIGNALS; + appsink->priv->max_buffers = DEFAULT_PROP_MAX_BUFFERS; + appsink->priv->drop = DEFAULT_PROP_DROP; +} + +static void +gst_app_sink_dispose (GObject * obj) +{ + GstAppSink *appsink = GST_APP_SINK (obj); + GstBuffer *buffer; + + GST_OBJECT_LOCK (appsink); + if (appsink->priv->caps) { + gst_caps_unref (appsink->priv->caps); + appsink->priv->caps = NULL; + } + if (appsink->priv->notify) { + appsink->priv->notify (appsink->priv->user_data); + } + appsink->priv->user_data = NULL; + appsink->priv->notify = NULL; + + GST_OBJECT_UNLOCK (appsink); + + g_mutex_lock (appsink->priv->mutex); + if (appsink->priv->preroll) { + gst_buffer_unref (appsink->priv->preroll); + appsink->priv->preroll = NULL; + } + while ((buffer = g_queue_pop_head (appsink->priv->queue))) + gst_buffer_unref (buffer); + g_mutex_unlock (appsink->priv->mutex); + + G_OBJECT_CLASS (parent_class)->dispose (obj); +} + +static void +gst_app_sink_finalize (GObject * obj) +{ + GstAppSink *appsink = GST_APP_SINK (obj); + + g_mutex_free (appsink->priv->mutex); + g_cond_free (appsink->priv->cond); + g_queue_free (appsink->priv->queue); + + G_OBJECT_CLASS (parent_class)->finalize (obj); +} + +static void +gst_app_sink_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstAppSink *appsink = GST_APP_SINK (object); + + switch (prop_id) { + case PROP_CAPS: + gst_app_sink_set_caps (appsink, gst_value_get_caps (value)); + break; + case PROP_EMIT_SIGNALS: + gst_app_sink_set_emit_signals (appsink, g_value_get_boolean (value)); + break; + case PROP_MAX_BUFFERS: + gst_app_sink_set_max_buffers (appsink, g_value_get_uint (value)); + break; + case PROP_DROP: + gst_app_sink_set_drop (appsink, g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_app_sink_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstAppSink *appsink = GST_APP_SINK (object); + + switch (prop_id) { + case PROP_CAPS: + { + GstCaps *caps; + + caps = gst_app_sink_get_caps (appsink); + gst_value_set_caps (value, caps); + if (caps) + gst_caps_unref (caps); + break; + } + case PROP_EOS: + g_value_set_boolean (value, gst_app_sink_is_eos (appsink)); + break; + case PROP_EMIT_SIGNALS: + g_value_set_boolean (value, gst_app_sink_get_emit_signals (appsink)); + break; + case PROP_MAX_BUFFERS: + g_value_set_uint (value, gst_app_sink_get_max_buffers (appsink)); + break; + case PROP_DROP: + g_value_set_boolean (value, gst_app_sink_get_drop (appsink)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static gboolean +gst_app_sink_unlock_start (GstBaseSink * bsink) +{ + GstAppSink *appsink = GST_APP_SINK (bsink); + + g_mutex_lock (appsink->priv->mutex); + GST_DEBUG_OBJECT (appsink, "unlock start"); + appsink->priv->flushing = TRUE; + g_cond_signal (appsink->priv->cond); + g_mutex_unlock (appsink->priv->mutex); + + return TRUE; +} + +static gboolean +gst_app_sink_unlock_stop (GstBaseSink * bsink) +{ + GstAppSink *appsink = GST_APP_SINK (bsink); + + g_mutex_lock (appsink->priv->mutex); + GST_DEBUG_OBJECT (appsink, "unlock stop"); + appsink->priv->flushing = FALSE; + g_cond_signal (appsink->priv->cond); + g_mutex_unlock (appsink->priv->mutex); + + return TRUE; +} + +static void +gst_app_sink_flush_unlocked (GstAppSink * appsink) +{ + GstBuffer *buffer; + + GST_DEBUG_OBJECT (appsink, "flush stop appsink"); + appsink->priv->is_eos = FALSE; + gst_buffer_replace (&appsink->priv->preroll, NULL); + while ((buffer = g_queue_pop_head (appsink->priv->queue))) + gst_buffer_unref (buffer); + g_cond_signal (appsink->priv->cond); +} + +static gboolean +gst_app_sink_start (GstBaseSink * psink) +{ + GstAppSink *appsink = GST_APP_SINK (psink); + + g_mutex_lock (appsink->priv->mutex); + GST_DEBUG_OBJECT (appsink, "starting"); + appsink->priv->started = TRUE; + g_mutex_unlock (appsink->priv->mutex); + + return TRUE; +} + +static gboolean +gst_app_sink_stop (GstBaseSink * psink) +{ + GstAppSink *appsink = GST_APP_SINK (psink); + + g_mutex_lock (appsink->priv->mutex); + GST_DEBUG_OBJECT (appsink, "stopping"); + appsink->priv->flushing = TRUE; + appsink->priv->started = FALSE; + gst_app_sink_flush_unlocked (appsink); + g_mutex_unlock (appsink->priv->mutex); + + return TRUE; +} + +static gboolean +gst_app_sink_event (GstBaseSink * sink, GstEvent * event) +{ + GstAppSink *appsink = GST_APP_SINK (sink); + + switch (event->type) { + case GST_EVENT_EOS: + + g_mutex_lock (appsink->priv->mutex); + GST_DEBUG_OBJECT (appsink, "receiving EOS"); + appsink->priv->is_eos = TRUE; + g_cond_signal (appsink->priv->cond); + g_mutex_unlock (appsink->priv->mutex); + + /* emit EOS now */ + if (appsink->priv->callbacks.eos) + appsink->priv->callbacks.eos (appsink, appsink->priv->user_data); + else + g_signal_emit (appsink, gst_app_sink_signals[SIGNAL_EOS], 0); + + break; + case GST_EVENT_FLUSH_START: + /* we don't have to do anything here, the base class will call unlock + * which will make sure we exit the _render method */ + GST_DEBUG_OBJECT (appsink, "received FLUSH_START"); + break; + case GST_EVENT_FLUSH_STOP: + g_mutex_lock (appsink->priv->mutex); + GST_DEBUG_OBJECT (appsink, "received FLUSH_STOP"); + gst_app_sink_flush_unlocked (appsink); + g_mutex_unlock (appsink->priv->mutex); + break; + default: + break; + } + return TRUE; +} + +static GstFlowReturn +gst_app_sink_preroll (GstBaseSink * psink, GstBuffer * buffer) +{ + GstFlowReturn res = GST_FLOW_OK; + GstAppSink *appsink = GST_APP_SINK (psink); + gboolean emit; + + g_mutex_lock (appsink->priv->mutex); + if (appsink->priv->flushing) + goto flushing; + + GST_DEBUG_OBJECT (appsink, "setting preroll buffer %p", buffer); + gst_buffer_replace (&appsink->priv->preroll, buffer); + + g_cond_signal (appsink->priv->cond); + emit = appsink->priv->emit_signals; + g_mutex_unlock (appsink->priv->mutex); + + if (appsink->priv->callbacks.new_preroll) + res = + appsink->priv->callbacks.new_preroll (appsink, + appsink->priv->user_data); + else if (emit) + g_signal_emit (appsink, gst_app_sink_signals[SIGNAL_NEW_PREROLL], 0); + + return res; + +flushing: + { + GST_DEBUG_OBJECT (appsink, "we are flushing"); + g_mutex_unlock (appsink->priv->mutex); + return GST_FLOW_WRONG_STATE; + } +} + +static GstFlowReturn +gst_app_sink_render (GstBaseSink * psink, GstBuffer * buffer) +{ + GstFlowReturn res = GST_FLOW_OK; + GstAppSink *appsink = GST_APP_SINK (psink); + gboolean emit; + + g_mutex_lock (appsink->priv->mutex); + if (appsink->priv->flushing) + goto flushing; + + GST_DEBUG_OBJECT (appsink, "pushing render buffer %p on queue (%d)", + buffer, appsink->priv->queue->length); + + while (appsink->priv->max_buffers > 0 && + appsink->priv->queue->length >= appsink->priv->max_buffers) { + if (appsink->priv->drop) { + GstBuffer *buf; + + /* we need to drop the oldest buffer and try again */ + buf = g_queue_pop_head (appsink->priv->queue); + GST_DEBUG_OBJECT (appsink, "dropping old buffer %p", buf); + gst_buffer_unref (buf); + } else { + GST_DEBUG_OBJECT (appsink, "waiting for free space, length %d >= %d", + appsink->priv->queue->length, appsink->priv->max_buffers); + /* wait for a buffer to be removed or flush */ + g_cond_wait (appsink->priv->cond, appsink->priv->mutex); + if (appsink->priv->flushing) + goto flushing; + } + } + /* we need to ref the buffer when pushing it in the queue */ + g_queue_push_tail (appsink->priv->queue, gst_buffer_ref (buffer)); + + g_cond_signal (appsink->priv->cond); + emit = appsink->priv->emit_signals; + g_mutex_unlock (appsink->priv->mutex); + + if (appsink->priv->callbacks.new_buffer) + res = + appsink->priv->callbacks.new_buffer (appsink, appsink->priv->user_data); + else if (emit) + g_signal_emit (appsink, gst_app_sink_signals[SIGNAL_NEW_BUFFER], 0); + + return res; + +flushing: + { + GST_DEBUG_OBJECT (appsink, "we are flushing"); + g_mutex_unlock (appsink->priv->mutex); + return GST_FLOW_WRONG_STATE; + } +} + +static GstCaps * +gst_app_sink_getcaps (GstBaseSink * psink) +{ + GstCaps *caps; + + GstAppSink *appsink = GST_APP_SINK (psink); + + GST_OBJECT_LOCK (appsink); + if ((caps = appsink->priv->caps)) + gst_caps_ref (caps); + GST_DEBUG_OBJECT (appsink, "got caps %" GST_PTR_FORMAT, caps); + GST_OBJECT_UNLOCK (appsink); + + return caps; +} + +/* external API */ + +/** + * gst_app_sink_set_caps: + * @appsink: a #GstAppSink + * @caps: caps to set + * + * Set the capabilities on the appsink element. This function takes + * a copy of the caps structure. After calling this method, the sink will only + * accept caps that match @caps. If @caps is non-fixed, you must check the caps + * on the buffers to get the actual used caps. + * + * Since: 0.10.22 + */ +EXPORT_C void +gst_app_sink_set_caps (GstAppSink * appsink, const GstCaps * caps) +{ + GstCaps *old; + + g_return_if_fail (appsink != NULL); + g_return_if_fail (GST_IS_APP_SINK (appsink)); + + GST_OBJECT_LOCK (appsink); + GST_DEBUG_OBJECT (appsink, "setting caps to %" GST_PTR_FORMAT, caps); + if ((old = appsink->priv->caps) != caps) { + if (caps) + appsink->priv->caps = gst_caps_copy (caps); + else + appsink->priv->caps = NULL; + if (old) + gst_caps_unref (old); + } + GST_OBJECT_UNLOCK (appsink); +} + +/** + * gst_app_sink_get_caps: + * @appsink: a #GstAppSink + * + * Get the configured caps on @appsink. + * + * Returns: the #GstCaps accepted by the sink. gst_caps_unref() after usage. + * + * Since: 0.10.22 + */ +EXPORT_C GstCaps * +gst_app_sink_get_caps (GstAppSink * appsink) +{ + GstCaps *caps; + + g_return_val_if_fail (appsink != NULL, NULL); + g_return_val_if_fail (GST_IS_APP_SINK (appsink), NULL); + + GST_OBJECT_LOCK (appsink); + if ((caps = appsink->priv->caps)) + gst_caps_ref (caps); + GST_DEBUG_OBJECT (appsink, "getting caps of %" GST_PTR_FORMAT, caps); + GST_OBJECT_UNLOCK (appsink); + + return caps; +} + +/** + * gst_app_sink_is_eos: + * @appsink: a #GstAppSink + * + * Check if @appsink is EOS, which is when no more buffers can be pulled because + * an EOS event was received. + * + * This function also returns %TRUE when the appsink is not in the PAUSED or + * PLAYING state. + * + * Returns: %TRUE if no more buffers can be pulled and the appsink is EOS. + * + * Since: 0.10.22 + */ +EXPORT_C gboolean +gst_app_sink_is_eos (GstAppSink * appsink) +{ + gboolean ret; + + g_return_val_if_fail (appsink != NULL, FALSE); + g_return_val_if_fail (GST_IS_APP_SINK (appsink), FALSE); + + g_mutex_lock (appsink->priv->mutex); + if (!appsink->priv->started) + goto not_started; + + if (appsink->priv->is_eos && g_queue_is_empty (appsink->priv->queue)) { + GST_DEBUG_OBJECT (appsink, "we are EOS and the queue is empty"); + ret = TRUE; + } else { + GST_DEBUG_OBJECT (appsink, "we are not yet EOS"); + ret = FALSE; + } + g_mutex_unlock (appsink->priv->mutex); + + return ret; + +not_started: + { + GST_DEBUG_OBJECT (appsink, "we are stopped, return TRUE"); + g_mutex_unlock (appsink->priv->mutex); + return TRUE; + } +} + +/** + * gst_app_sink_set_emit_signals: + * @appsink: a #GstAppSink + * @emit: the new state + * + * Make appsink emit the "new-preroll" and "new-buffer" signals. This option is + * by default disabled because signal emission is expensive and unneeded when + * the application prefers to operate in pull mode. + * + * Since: 0.10.22 + */ +EXPORT_C void +gst_app_sink_set_emit_signals (GstAppSink * appsink, gboolean emit) +{ + g_return_if_fail (GST_IS_APP_SINK (appsink)); + + g_mutex_lock (appsink->priv->mutex); + appsink->priv->emit_signals = emit; + g_mutex_unlock (appsink->priv->mutex); +} + +/** + * gst_app_sink_get_emit_signals: + * @appsink: a #GstAppSink + * + * Check if appsink will emit the "new-preroll" and "new-buffer" signals. + * + * Returns: %TRUE if @appsink is emiting the "new-preroll" and "new-buffer" + * signals. + * + * Since: 0.10.22 + */ +EXPORT_C gboolean +gst_app_sink_get_emit_signals (GstAppSink * appsink) +{ + gboolean result; + + g_return_val_if_fail (GST_IS_APP_SINK (appsink), FALSE); + + g_mutex_lock (appsink->priv->mutex); + result = appsink->priv->emit_signals; + g_mutex_unlock (appsink->priv->mutex); + + return result; +} + +/** + * gst_app_sink_set_max_buffers: + * @appsink: a #GstAppSink + * @max: the maximum number of buffers to queue + * + * Set the maximum amount of buffers that can be queued in @appsink. After this + * amount of buffers are queued in appsink, any more buffers will block upstream + * elements until a buffer is pulled from @appsink. + * + * Since: 0.10.22 + */ +EXPORT_C void +gst_app_sink_set_max_buffers (GstAppSink * appsink, guint max) +{ + g_return_if_fail (GST_IS_APP_SINK (appsink)); + + g_mutex_lock (appsink->priv->mutex); + if (max != appsink->priv->max_buffers) { + appsink->priv->max_buffers = max; + /* signal the change */ + g_cond_signal (appsink->priv->cond); + } + g_mutex_unlock (appsink->priv->mutex); +} + +/** + * gst_app_sink_get_max_buffers: + * @appsink: a #GstAppSink + * + * Get the maximum amount of buffers that can be queued in @appsink. + * + * Returns: The maximum amount of buffers that can be queued. + * + * Since: 0.10.22 + */ +EXPORT_C guint +gst_app_sink_get_max_buffers (GstAppSink * appsink) +{ + guint result; + + g_return_val_if_fail (GST_IS_APP_SINK (appsink), 0); + + g_mutex_lock (appsink->priv->mutex); + result = appsink->priv->max_buffers; + g_mutex_unlock (appsink->priv->mutex); + + return result; +} + +/** + * gst_app_sink_set_drop: + * @appsink: a #GstAppSink + * @drop: the new state + * + * Instruct @appsink to drop old buffers when the maximum amount of queued + * buffers is reached. + * + * Since: 0.10.22 + */ +EXPORT_C void +gst_app_sink_set_drop (GstAppSink * appsink, gboolean drop) +{ + g_return_if_fail (GST_IS_APP_SINK (appsink)); + + g_mutex_lock (appsink->priv->mutex); + if (appsink->priv->drop != drop) { + appsink->priv->drop = drop; + /* signal the change */ + g_cond_signal (appsink->priv->cond); + } + g_mutex_unlock (appsink->priv->mutex); +} + +/** + * gst_app_sink_get_drop: + * @appsink: a #GstAppSink + * + * Check if @appsink will drop old buffers when the maximum amount of queued + * buffers is reached. + * + * Returns: %TRUE if @appsink is dropping old buffers when the queue is + * filled. + * + * Since: 0.10.22 + */ +EXPORT_C gboolean +gst_app_sink_get_drop (GstAppSink * appsink) +{ + gboolean result; + + g_return_val_if_fail (GST_IS_APP_SINK (appsink), FALSE); + + g_mutex_lock (appsink->priv->mutex); + result = appsink->priv->drop; + g_mutex_unlock (appsink->priv->mutex); + + return result; +} + +/** + * gst_app_sink_pull_preroll: + * @appsink: a #GstAppSink + * + * Get the last preroll buffer in @appsink. This was the buffer that caused the + * appsink to preroll in the PAUSED state. This buffer can be pulled many times + * and remains available to the application even after EOS. + * + * This function is typically used when dealing with a pipeline in the PAUSED + * state. Calling this function after doing a seek will give the buffer right + * after the seek position. + * + * Note that the preroll buffer will also be returned as the first buffer + * when calling gst_app_sink_pull_buffer(). + * + * If an EOS event was received before any buffers, this function returns + * %NULL. Use gst_app_sink_is_eos () to check for the EOS condition. + * + * This function blocks until a preroll buffer or EOS is received or the appsink + * element is set to the READY/NULL state. + * + * Returns: a #GstBuffer or NULL when the appsink is stopped or EOS. + * + * Since: 0.10.22 + */ +EXPORT_C GstBuffer * +gst_app_sink_pull_preroll (GstAppSink * appsink) +{ + GstBuffer *buf = NULL; + + g_return_val_if_fail (appsink != NULL, NULL); + g_return_val_if_fail (GST_IS_APP_SINK (appsink), NULL); + + g_mutex_lock (appsink->priv->mutex); + + while (TRUE) { + GST_DEBUG_OBJECT (appsink, "trying to grab a buffer"); + if (!appsink->priv->started) + goto not_started; + + if (appsink->priv->preroll != NULL) + break; + + if (appsink->priv->is_eos) + goto eos; + + /* nothing to return, wait */ + GST_DEBUG_OBJECT (appsink, "waiting for the preroll buffer"); + g_cond_wait (appsink->priv->cond, appsink->priv->mutex); + } + buf = gst_buffer_ref (appsink->priv->preroll); + GST_DEBUG_OBJECT (appsink, "we have the preroll buffer %p", buf); + g_mutex_unlock (appsink->priv->mutex); + + return buf; + + /* special conditions */ +eos: + { + GST_DEBUG_OBJECT (appsink, "we are EOS, return NULL"); + g_mutex_unlock (appsink->priv->mutex); + return NULL; + } +not_started: + { + GST_DEBUG_OBJECT (appsink, "we are stopped, return NULL"); + g_mutex_unlock (appsink->priv->mutex); + return NULL; + } +} + +/** + * gst_app_sink_pull_buffer: + * @appsink: a #GstAppSink + * + * This function blocks until a buffer or EOS becomes available or the appsink + * element is set to the READY/NULL state. + * + * This function will only return buffers when the appsink is in the PLAYING + * state. All rendered buffers will be put in a queue so that the application + * can pull buffers at its own rate. Note that when the application does not + * pull buffers fast enough, the queued buffers could consume a lot of memory, + * especially when dealing with raw video frames. + * + * If an EOS event was received before any buffers, this function returns + * %NULL. Use gst_app_sink_is_eos () to check for the EOS condition. + * + * Returns: a #GstBuffer or NULL when the appsink is stopped or EOS. + * + * Since: 0.10.22 + */ +EXPORT_C GstBuffer * +gst_app_sink_pull_buffer (GstAppSink * appsink) +{ + GstBuffer *buf = NULL; + + g_return_val_if_fail (appsink != NULL, NULL); + g_return_val_if_fail (GST_IS_APP_SINK (appsink), NULL); + + g_mutex_lock (appsink->priv->mutex); + + while (TRUE) { + GST_DEBUG_OBJECT (appsink, "trying to grab a buffer"); + if (!appsink->priv->started) + goto not_started; + + if (!g_queue_is_empty (appsink->priv->queue)) + break; + + if (appsink->priv->is_eos) + goto eos; + + /* nothing to return, wait */ + GST_DEBUG_OBJECT (appsink, "waiting for a buffer"); + g_cond_wait (appsink->priv->cond, appsink->priv->mutex); + } + buf = g_queue_pop_head (appsink->priv->queue); + GST_DEBUG_OBJECT (appsink, "we have a buffer %p", buf); + g_cond_signal (appsink->priv->cond); + g_mutex_unlock (appsink->priv->mutex); + + return buf; + + /* special conditions */ +eos: + { + GST_DEBUG_OBJECT (appsink, "we are EOS, return NULL"); + g_mutex_unlock (appsink->priv->mutex); + return NULL; + } +not_started: + { + GST_DEBUG_OBJECT (appsink, "we are stopped, return NULL"); + g_mutex_unlock (appsink->priv->mutex); + return NULL; + } +} + +/** + * gst_app_sink_set_callbacks: + * @appsink: a #GstAppSink + * @callbacks: the callbacks + * @user_data: a user_data argument for the callbacks + * @notify: a destroy notify function + * + * Set callbacks which will be executed for each new preroll, new buffer and eos. + * This is an alternative to using the signals, it has lower overhead and is thus + * less expensive, but also less flexible. + * + * If callbacks are installed, no signals will be emited for performance + * reasons. + * + * Since: 0.10.23 + */ +void +gst_app_sink_set_callbacks (GstAppSink * appsink, + GstAppSinkCallbacks * callbacks, gpointer user_data, GDestroyNotify notify) +{ + GDestroyNotify old_notify; + + g_return_if_fail (appsink != NULL); + g_return_if_fail (GST_IS_APP_SINK (appsink)); + g_return_if_fail (callbacks != NULL); + + GST_OBJECT_LOCK (appsink); + old_notify = appsink->priv->notify; + + if (old_notify) { + gpointer old_data; + + old_data = appsink->priv->user_data; + + appsink->priv->user_data = NULL; + appsink->priv->notify = NULL; + GST_OBJECT_UNLOCK (appsink); + + old_notify (old_data); + + GST_OBJECT_LOCK (appsink); + } + appsink->priv->callbacks = *callbacks; + appsink->priv->user_data = user_data; + appsink->priv->notify = notify; + GST_OBJECT_UNLOCK (appsink); +} + +/*** GSTURIHANDLER INTERFACE *************************************************/ + +static GstURIType +gst_app_sink_uri_get_type (void) +{ + return GST_URI_SINK; +} + +static gchar ** +gst_app_sink_uri_get_protocols (void) +{ + static gchar *protocols[] = { "appsink", NULL }; + + return protocols; +} + +static const gchar * +gst_app_sink_uri_get_uri (GstURIHandler * handler) +{ + return "appsink"; +} + +static gboolean +gst_app_sink_uri_set_uri (GstURIHandler * handler, const gchar * uri) +{ + gchar *protocol; + gboolean ret; + + protocol = gst_uri_get_protocol (uri); + ret = !strcmp (protocol, "appsink"); + g_free (protocol); + + return ret; +} + +static void +gst_app_sink_uri_handler_init (gpointer g_iface, gpointer iface_data) +{ + GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface; + + iface->get_type = gst_app_sink_uri_get_type; + iface->get_protocols = gst_app_sink_uri_get_protocols; + iface->get_uri = gst_app_sink_uri_get_uri; + iface->set_uri = gst_app_sink_uri_set_uri; +}