mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-23 00:36:51 +00:00
0bba976bd3
Original commit message from CVS: * gst-libs/gst/app/gstappsink.c: (gst_app_marshal_OBJECT__VOID), (gst_app_sink_class_init), (gst_app_sink_init), (gst_app_sink_dispose), (gst_app_sink_finalize), (gst_app_sink_set_property), (gst_app_sink_get_property), (gst_app_sink_flush_unlocked), (gst_app_sink_start), (gst_app_sink_event), (gst_app_sink_getcaps), (gst_app_sink_set_caps), (gst_app_sink_get_caps), (gst_app_sink_is_eos), (gst_app_sink_pull_preroll), (gst_app_sink_pull_buffer): * gst-libs/gst/app/gstappsink.h: Add properties, signals and actions to access the element even without linking to the library. Fix some method names and signatures.
646 lines
18 KiB
C
646 lines
18 KiB
C
/* GStreamer
|
|
* Copyright (C) 2007 David Schleef <ds@schleef.org>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <gst/gst.h>
|
|
#include <gst/base/gstbasesink.h>
|
|
#include <gst/gstbuffer.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "gstappsink.h"
|
|
|
|
|
|
GST_DEBUG_CATEGORY (app_sink_debug);
|
|
#define GST_CAT_DEFAULT app_sink_debug
|
|
|
|
static const GstElementDetails app_sink_details =
|
|
GST_ELEMENT_DETAILS ("AppSink",
|
|
"Generic/Sink",
|
|
"Allow the application to get access to raw buffer",
|
|
"David Schleef <ds@schleef.org>, Wim Taymans <wim.taymans@gmail.com");
|
|
|
|
enum
|
|
{
|
|
/* signals */
|
|
SIGNAL_EOS,
|
|
SIGNAL_NEW_PREROLL,
|
|
SIGNAL_NEW_BUFFER,
|
|
|
|
/* acions */
|
|
SIGNAL_PULL_PREROLL,
|
|
SIGNAL_PULL_BUFFER,
|
|
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_CAPS,
|
|
PROP_EOS
|
|
};
|
|
|
|
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_dispose (GObject * object);
|
|
static void gst_app_sink_finalize (GObject * object);
|
|
|
|
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_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 };
|
|
|
|
GST_BOILERPLATE (GstAppSink, gst_app_sink, GstBaseSink, GST_TYPE_BASE_SINK);
|
|
|
|
void
|
|
gst_app_marshal_OBJECT__VOID (GClosure * closure,
|
|
GValue * return_value,
|
|
guint n_param_values,
|
|
const GValue * param_values,
|
|
gpointer invocation_hint, gpointer marshal_data)
|
|
{
|
|
typedef GstBuffer *(*GMarshalFunc_OBJECT__VOID) (gpointer data1,
|
|
gpointer data2);
|
|
register GMarshalFunc_OBJECT__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_OBJECT__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 (element_class, &app_sink_details);
|
|
|
|
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 caps of 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", TRUE, G_PARAM_READABLE));
|
|
|
|
/**
|
|
* GstAppSink::eos:
|
|
* @appsink: the appsink element that emited the signal
|
|
*
|
|
* Signal that the end-of-stream has been reached.
|
|
*/
|
|
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
|
|
* @buffer: the buffer that caused the preroll
|
|
*
|
|
* Signal that a new preroll buffer is available.
|
|
*/
|
|
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__OBJECT, G_TYPE_NONE, 0,
|
|
GST_TYPE_BUFFER);
|
|
/**
|
|
* GstAppSink::new-buffer:
|
|
* @appsink: the appsink element that emited the signal
|
|
* @buffer: the buffer that is available
|
|
*
|
|
* Signal that a new buffer is available.
|
|
*/
|
|
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__OBJECT, G_TYPE_NONE, 0,
|
|
GST_TYPE_BUFFER);
|
|
|
|
/**
|
|
* GstAppSink::pull-preroll:
|
|
* @appsink: the appsink element to emit this signal on
|
|
*
|
|
* Get the last preroll buffer on @appsink.
|
|
*/
|
|
gst_app_sink_signals[SIGNAL_PULL_PREROLL] =
|
|
g_signal_new ("pull-preroll", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstAppSinkClass, pull_preroll), NULL,
|
|
NULL, gst_app_marshal_OBJECT__VOID, GST_TYPE_BUFFER, 0, G_TYPE_NONE);
|
|
/**
|
|
* GstAppSink::pull-buffer:
|
|
* @appsink: the appsink element to emit this signal on
|
|
*
|
|
* Get the next buffer buffer on @appsink.
|
|
*/
|
|
gst_app_sink_signals[SIGNAL_PULL_PREROLL] =
|
|
g_signal_new ("pull-buffer", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (GstAppSinkClass, pull_buffer),
|
|
NULL, NULL, gst_app_marshal_OBJECT__VOID, GST_TYPE_BUFFER, 0,
|
|
G_TYPE_NONE);
|
|
|
|
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;
|
|
}
|
|
|
|
static void
|
|
gst_app_sink_init (GstAppSink * appsink, GstAppSinkClass * klass)
|
|
{
|
|
appsink->mutex = g_mutex_new ();
|
|
appsink->cond = g_cond_new ();
|
|
appsink->queue = g_queue_new ();
|
|
}
|
|
|
|
static void
|
|
gst_app_sink_dispose (GObject * obj)
|
|
{
|
|
GstAppSink *appsink = GST_APP_SINK (obj);
|
|
|
|
if (appsink->caps) {
|
|
gst_caps_unref (appsink->caps);
|
|
appsink->caps = NULL;
|
|
}
|
|
if (appsink->preroll) {
|
|
gst_buffer_unref (appsink->preroll);
|
|
appsink->preroll = NULL;
|
|
}
|
|
g_queue_foreach (appsink->queue, (GFunc) gst_mini_object_unref, NULL);
|
|
|
|
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->mutex);
|
|
g_cond_free (appsink->cond);
|
|
g_queue_free (appsink->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;
|
|
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;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_app_sink_flush_unlocked (GstAppSink * appsink)
|
|
{
|
|
GstBuffer *buffer;
|
|
|
|
GST_DEBUG_OBJECT (appsink, "flushing appsink");
|
|
appsink->is_eos = FALSE;
|
|
gst_buffer_replace (&appsink->preroll, NULL);
|
|
while ((buffer = g_queue_pop_head (appsink->queue)))
|
|
gst_buffer_unref (buffer);
|
|
g_cond_signal (appsink->cond);
|
|
}
|
|
|
|
static gboolean
|
|
gst_app_sink_start (GstBaseSink * psink)
|
|
{
|
|
GstAppSink *appsink = GST_APP_SINK (psink);
|
|
|
|
g_mutex_lock (appsink->mutex);
|
|
appsink->is_eos = FALSE;
|
|
appsink->started = TRUE;
|
|
GST_DEBUG_OBJECT (appsink, "starting");
|
|
g_mutex_unlock (appsink->mutex);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_app_sink_stop (GstBaseSink * psink)
|
|
{
|
|
GstAppSink *appsink = GST_APP_SINK (psink);
|
|
|
|
g_mutex_lock (appsink->mutex);
|
|
GST_DEBUG_OBJECT (appsink, "stopping");
|
|
appsink->started = FALSE;
|
|
gst_app_sink_flush_unlocked (appsink);
|
|
g_mutex_unlock (appsink->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->mutex);
|
|
GST_DEBUG_OBJECT (appsink, "receiving EOS");
|
|
appsink->is_eos = TRUE;
|
|
g_cond_signal (appsink->cond);
|
|
g_mutex_unlock (appsink->mutex);
|
|
break;
|
|
case GST_EVENT_FLUSH_START:
|
|
break;
|
|
case GST_EVENT_FLUSH_STOP:
|
|
g_mutex_lock (appsink->mutex);
|
|
GST_DEBUG_OBJECT (appsink, "received FLUSH_STOP");
|
|
gst_app_sink_flush_unlocked (appsink);
|
|
g_mutex_unlock (appsink->mutex);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_app_sink_preroll (GstBaseSink * psink, GstBuffer * buffer)
|
|
{
|
|
GstAppSink *appsink = GST_APP_SINK (psink);
|
|
|
|
g_mutex_lock (appsink->mutex);
|
|
GST_DEBUG_OBJECT (appsink, "setting preroll buffer %p", buffer);
|
|
gst_buffer_replace (&appsink->preroll, buffer);
|
|
g_cond_signal (appsink->cond);
|
|
g_mutex_unlock (appsink->mutex);
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_app_sink_render (GstBaseSink * psink, GstBuffer * buffer)
|
|
{
|
|
GstAppSink *appsink = GST_APP_SINK (psink);
|
|
|
|
g_mutex_lock (appsink->mutex);
|
|
GST_DEBUG_OBJECT (appsink, "pushing render buffer %p on queue", buffer);
|
|
g_queue_push_tail (appsink->queue, gst_buffer_ref (buffer));
|
|
g_cond_signal (appsink->cond);
|
|
g_mutex_unlock (appsink->mutex);
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
static GstCaps *
|
|
gst_app_sink_getcaps (GstBaseSink * psink)
|
|
{
|
|
GstCaps *caps;
|
|
|
|
GstAppSink *appsink = GST_APP_SINK (psink);
|
|
|
|
GST_OBJECT_LOCK (appsink);
|
|
if ((caps = appsink->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.
|
|
*/
|
|
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);
|
|
old = appsink->caps;
|
|
if (caps)
|
|
appsink->caps = gst_caps_copy (caps);
|
|
else
|
|
appsink->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.
|
|
*/
|
|
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->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.
|
|
*/
|
|
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->mutex);
|
|
if (!appsink->started)
|
|
goto not_started;
|
|
|
|
if (appsink->is_eos && g_queue_is_empty (appsink->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->mutex);
|
|
|
|
return ret;
|
|
|
|
not_started:
|
|
{
|
|
GST_DEBUG_OBJECT (appsink, "we are stopped, return TRUE");
|
|
g_mutex_unlock (appsink->mutex);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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->mutex);
|
|
|
|
while (TRUE) {
|
|
GST_DEBUG_OBJECT (appsink, "trying to grab a buffer");
|
|
if (!appsink->started)
|
|
goto not_started;
|
|
|
|
if (appsink->preroll != NULL)
|
|
break;
|
|
|
|
if (appsink->is_eos)
|
|
goto eos;
|
|
|
|
/* nothing to return, wait */
|
|
GST_DEBUG_OBJECT (appsink, "waiting for the preroll buffer");
|
|
g_cond_wait (appsink->cond, appsink->mutex);
|
|
}
|
|
buf = gst_buffer_ref (appsink->preroll);
|
|
GST_DEBUG_OBJECT (appsink, "we have the preroll buffer %p", buf);
|
|
g_mutex_unlock (appsink->mutex);
|
|
|
|
return buf;
|
|
|
|
/* special conditions */
|
|
eos:
|
|
{
|
|
GST_DEBUG_OBJECT (appsink, "we are EOS, return NULL");
|
|
g_mutex_unlock (appsink->mutex);
|
|
return NULL;
|
|
}
|
|
not_started:
|
|
{
|
|
GST_DEBUG_OBJECT (appsink, "we are stopped, return NULL");
|
|
g_mutex_unlock (appsink->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.
|
|
*/
|
|
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->mutex);
|
|
|
|
while (TRUE) {
|
|
GST_DEBUG_OBJECT (appsink, "trying to grab a buffer");
|
|
if (!appsink->started)
|
|
goto not_started;
|
|
|
|
if (!g_queue_is_empty (appsink->queue))
|
|
break;
|
|
|
|
if (appsink->is_eos)
|
|
goto eos;
|
|
|
|
/* nothing to return, wait */
|
|
GST_DEBUG_OBJECT (appsink, "waiting for a buffer");
|
|
g_cond_wait (appsink->cond, appsink->mutex);
|
|
}
|
|
buf = g_queue_pop_head (appsink->queue);
|
|
GST_DEBUG_OBJECT (appsink, "we have a buffer %p", buf);
|
|
g_mutex_unlock (appsink->mutex);
|
|
|
|
return buf;
|
|
|
|
/* special conditions */
|
|
eos:
|
|
{
|
|
GST_DEBUG_OBJECT (appsink, "we are EOS, return NULL");
|
|
g_mutex_unlock (appsink->mutex);
|
|
return NULL;
|
|
}
|
|
not_started:
|
|
{
|
|
GST_DEBUG_OBJECT (appsink, "we are stopped, return NULL");
|
|
g_mutex_unlock (appsink->mutex);
|
|
return NULL;
|
|
}
|
|
}
|