mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-28 03:00:35 +00:00
99103be50c
Might just be paranoia, but better safe than sorry. Make sure the compiler really always passes a 64-bit integer to the g_object_set() vararg function.
4987 lines
162 KiB
C
4987 lines
162 KiB
C
/* GStreamer
|
|
* Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>
|
|
* Copyright (C) <2011> Sebastian Dröge <sebastian.droege@collabora.co.uk>
|
|
*
|
|
* 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 <string.h>
|
|
#include <gst/gst.h>
|
|
|
|
#include <gst/gst-i18n-plugin.h>
|
|
#include <gst/pbutils/pbutils.h>
|
|
#include <gst/video/video.h>
|
|
#include <gst/audio/streamvolume.h>
|
|
#include <gst/video/colorbalance.h>
|
|
#include <gst/video/videooverlay.h>
|
|
#include <gst/video/navigation.h>
|
|
|
|
#include "gstplaysink.h"
|
|
#include "gststreamsynchronizer.h"
|
|
#include "gstplaysinkvideoconvert.h"
|
|
#include "gstplaysinkaudioconvert.h"
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (gst_play_sink_debug);
|
|
#define GST_CAT_DEFAULT gst_play_sink_debug
|
|
|
|
#define VOLUME_MAX_DOUBLE 10.0
|
|
|
|
#define DEFAULT_FLAGS GST_PLAY_FLAG_AUDIO | GST_PLAY_FLAG_VIDEO | GST_PLAY_FLAG_TEXT | \
|
|
GST_PLAY_FLAG_SOFT_VOLUME | GST_PLAY_FLAG_SOFT_COLORBALANCE
|
|
|
|
#define GST_PLAY_CHAIN(c) ((GstPlayChain *)(c))
|
|
|
|
/* enum types */
|
|
/**
|
|
* GstPlaySinkSendEventMode:
|
|
* @MODE_DEFAULT: default GstBin's send_event handling
|
|
* @MODE_FIRST: send event only to the first sink that return true
|
|
*
|
|
* Send event handling to use
|
|
*/
|
|
typedef enum
|
|
{
|
|
MODE_DEFAULT = 0,
|
|
MODE_FIRST = 1
|
|
} GstPlaySinkSendEventMode;
|
|
|
|
|
|
#define GST_TYPE_PLAY_SINK_SEND_EVENT_MODE (gst_play_sink_send_event_mode_get_type ())
|
|
static GType
|
|
gst_play_sink_send_event_mode_get_type (void)
|
|
{
|
|
static GType gtype = 0;
|
|
|
|
if (gtype == 0) {
|
|
static const GEnumValue values[] = {
|
|
{MODE_DEFAULT, "Default GstBin's send_event handling (default)",
|
|
"default"},
|
|
{MODE_FIRST, "Sends the event to sinks until the first one handles it",
|
|
"first"},
|
|
{0, NULL, NULL}
|
|
};
|
|
|
|
gtype = g_enum_register_static ("GstPlaySinkSendEventMode", values);
|
|
}
|
|
return gtype;
|
|
}
|
|
|
|
/* holds the common data fields for the audio and video pipelines. We keep them
|
|
* in a structure to more easily have all the info available. */
|
|
typedef struct
|
|
{
|
|
GstPlaySink *playsink;
|
|
GstElement *bin;
|
|
gboolean added;
|
|
gboolean activated;
|
|
gboolean raw;
|
|
} GstPlayChain;
|
|
|
|
typedef struct
|
|
{
|
|
GstPlayChain chain;
|
|
GstPad *sinkpad;
|
|
GstElement *queue;
|
|
GstElement *conv;
|
|
GstElement *volume; /* element with the volume property */
|
|
gboolean sink_volume; /* if the volume was provided by the sink */
|
|
GstElement *mute; /* element with the mute property */
|
|
GstElement *sink;
|
|
GstElement *ts_offset;
|
|
} GstPlayAudioChain;
|
|
|
|
typedef struct
|
|
{
|
|
GstPlayChain chain;
|
|
GstPad *sinkpad, *srcpad;
|
|
GstElement *conv;
|
|
GstElement *deinterlace;
|
|
} GstPlayVideoDeinterlaceChain;
|
|
|
|
typedef struct
|
|
{
|
|
GstPlayChain chain;
|
|
GstPad *sinkpad;
|
|
GstElement *queue;
|
|
GstElement *conv;
|
|
GstElement *sink;
|
|
gboolean async;
|
|
GstElement *ts_offset;
|
|
} GstPlayVideoChain;
|
|
|
|
typedef struct
|
|
{
|
|
GstPlayChain chain;
|
|
GstPad *sinkpad;
|
|
GstElement *queue;
|
|
GstElement *conv;
|
|
GstElement *resample;
|
|
GstPad *blockpad; /* srcpad of resample, used for switching the vis */
|
|
GstPad *vissinkpad; /* visualisation sinkpad, */
|
|
GstElement *vis;
|
|
GstPad *vissrcpad; /* visualisation srcpad, */
|
|
GstPad *srcpad; /* outgoing srcpad, used to connect to the next
|
|
* chain */
|
|
} GstPlayVisChain;
|
|
|
|
typedef struct
|
|
{
|
|
GstPlayChain chain;
|
|
GstPad *sinkpad;
|
|
GstElement *queue;
|
|
GstElement *identity;
|
|
GstElement *overlay;
|
|
GstPad *videosinkpad;
|
|
GstPad *textsinkpad;
|
|
GstPad *srcpad; /* outgoing srcpad, used to connect to the next
|
|
* chain */
|
|
GstElement *sink; /* custom sink to receive subtitle buffers */
|
|
} GstPlayTextChain;
|
|
|
|
#define GST_PLAY_SINK_GET_LOCK(playsink) (&((GstPlaySink *)playsink)->lock)
|
|
#define GST_PLAY_SINK_LOCK(playsink) G_STMT_START { \
|
|
GST_LOG_OBJECT (playsink, "locking from thread %p", g_thread_self ()); \
|
|
g_rec_mutex_lock (GST_PLAY_SINK_GET_LOCK (playsink)); \
|
|
GST_LOG_OBJECT (playsink, "locked from thread %p", g_thread_self ()); \
|
|
} G_STMT_END
|
|
#define GST_PLAY_SINK_UNLOCK(playsink) G_STMT_START { \
|
|
GST_LOG_OBJECT (playsink, "unlocking from thread %p", g_thread_self ()); \
|
|
g_rec_mutex_unlock (GST_PLAY_SINK_GET_LOCK (playsink)); \
|
|
} G_STMT_END
|
|
|
|
#define PENDING_FLAG_SET(playsink, flagtype) \
|
|
((playsink->pending_blocked_pads) |= (1 << flagtype))
|
|
#define PENDING_FLAG_UNSET(playsink, flagtype) \
|
|
((playsink->pending_blocked_pads) &= ~(1 << flagtype))
|
|
#define PENDING_FLAG_IS_SET(playsink, flagtype) \
|
|
((playsink->pending_blocked_pads) & (1 << flagtype))
|
|
#define PENDING_VIDEO_BLOCK(playsink) \
|
|
((playsink->pending_blocked_pads) & (1 << GST_PLAY_SINK_TYPE_VIDEO_RAW | 1 << GST_PLAY_SINK_TYPE_VIDEO))
|
|
#define PENDING_AUDIO_BLOCK(playsink) \
|
|
((playsink->pending_blocked_pads) & (1 << GST_PLAY_SINK_TYPE_AUDIO_RAW | 1 << GST_PLAY_SINK_TYPE_AUDIO))
|
|
#define PENDING_TEXT_BLOCK(playsink) \
|
|
PENDING_FLAG_IS_SET(playsink, GST_PLAY_SINK_TYPE_TEXT)
|
|
|
|
struct _GstPlaySink
|
|
{
|
|
GstBin bin;
|
|
|
|
GRecMutex lock;
|
|
|
|
gboolean async_pending;
|
|
gboolean need_async_start;
|
|
|
|
GstPlayFlags flags;
|
|
|
|
GstStreamSynchronizer *stream_synchronizer;
|
|
|
|
/* chains */
|
|
GstPlayAudioChain *audiochain;
|
|
GstPlayVideoDeinterlaceChain *videodeinterlacechain;
|
|
GstPlayVideoChain *videochain;
|
|
GstPlayVisChain *vischain;
|
|
GstPlayTextChain *textchain;
|
|
|
|
/* audio */
|
|
GstPad *audio_pad;
|
|
gboolean audio_pad_raw;
|
|
gboolean audio_pad_blocked;
|
|
GstPad *audio_srcpad_stream_synchronizer;
|
|
GstPad *audio_sinkpad_stream_synchronizer;
|
|
gulong audio_block_id;
|
|
/* audio tee */
|
|
GstElement *audio_tee;
|
|
GstPad *audio_tee_sink;
|
|
GstPad *audio_tee_asrc;
|
|
GstPad *audio_tee_vissrc;
|
|
/* video */
|
|
GstPad *video_pad;
|
|
gboolean video_pad_raw;
|
|
gboolean video_pad_blocked;
|
|
GstPad *video_srcpad_stream_synchronizer;
|
|
GstPad *video_sinkpad_stream_synchronizer;
|
|
gulong video_block_id;
|
|
/* text */
|
|
GstPad *text_pad;
|
|
gboolean text_pad_blocked;
|
|
GstPad *text_srcpad_stream_synchronizer;
|
|
GstPad *text_sinkpad_stream_synchronizer;
|
|
gulong text_block_id;
|
|
|
|
guint32 pending_blocked_pads;
|
|
|
|
/* properties */
|
|
GstElement *audio_sink;
|
|
GstElement *video_sink;
|
|
GstElement *visualisation;
|
|
GstElement *text_sink;
|
|
gdouble volume;
|
|
gboolean mute;
|
|
gchar *font_desc; /* font description */
|
|
gchar *subtitle_encoding; /* subtitle encoding */
|
|
guint connection_speed; /* connection speed in bits/sec (0 = unknown) */
|
|
guint count;
|
|
gboolean volume_changed; /* volume/mute changed while no audiochain */
|
|
gboolean mute_changed; /* ... has been created yet */
|
|
gint64 av_offset;
|
|
GstPlaySinkSendEventMode send_event_mode;
|
|
gboolean force_aspect_ratio;
|
|
|
|
/* videooverlay proxy interface */
|
|
GstVideoOverlay *overlay_element; /* protected with LOCK */
|
|
gboolean overlay_handle_set;
|
|
guintptr overlay_handle;
|
|
gboolean overlay_render_rectangle_set;
|
|
gint overlay_x, overlay_y, overlay_width, overlay_height;
|
|
gboolean overlay_handle_events_set;
|
|
gboolean overlay_handle_events;
|
|
|
|
/* colorbalance proxy interface */
|
|
GstColorBalance *colorbalance_element;
|
|
GList *colorbalance_channels; /* CONTRAST, BRIGHTNESS, HUE, SATURATION */
|
|
gint colorbalance_values[4];
|
|
|
|
/* sending audio/video flushes break stream changes when the pipeline
|
|
* is paused and played again in 0.10 */
|
|
#if 0
|
|
GstSegment video_segment;
|
|
gboolean video_custom_flush_finished;
|
|
gboolean video_ignore_wrong_state;
|
|
gboolean video_pending_flush;
|
|
|
|
GstSegment audio_segment;
|
|
gboolean audio_custom_flush_finished;
|
|
gboolean audio_ignore_wrong_state;
|
|
gboolean audio_pending_flush;
|
|
#endif
|
|
|
|
GstSegment text_segment;
|
|
gboolean text_custom_flush_finished;
|
|
gboolean text_ignore_wrong_state;
|
|
gboolean text_pending_flush;
|
|
};
|
|
|
|
struct _GstPlaySinkClass
|
|
{
|
|
GstBinClass parent_class;
|
|
|
|
gboolean (*reconfigure) (GstPlaySink * playsink);
|
|
|
|
GstSample *(*convert_sample) (GstPlaySink * playsink, GstCaps * caps);
|
|
};
|
|
|
|
|
|
static GstStaticPadTemplate audiotemplate =
|
|
GST_STATIC_PAD_TEMPLATE ("audio_sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_REQUEST,
|
|
GST_STATIC_CAPS_ANY);
|
|
static GstStaticPadTemplate videotemplate =
|
|
GST_STATIC_PAD_TEMPLATE ("video_sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_REQUEST,
|
|
GST_STATIC_CAPS_ANY);
|
|
static GstStaticPadTemplate texttemplate = GST_STATIC_PAD_TEMPLATE ("text_sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_REQUEST,
|
|
GST_STATIC_CAPS_ANY);
|
|
|
|
/* FIXME 0.11: Remove */
|
|
static GstStaticPadTemplate audiorawtemplate =
|
|
GST_STATIC_PAD_TEMPLATE ("audio_raw_sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_REQUEST,
|
|
GST_STATIC_CAPS_ANY);
|
|
static GstStaticPadTemplate videorawtemplate =
|
|
GST_STATIC_PAD_TEMPLATE ("video_raw_sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_REQUEST,
|
|
GST_STATIC_CAPS_ANY);
|
|
|
|
|
|
/* props */
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_FLAGS,
|
|
PROP_MUTE,
|
|
PROP_VOLUME,
|
|
PROP_FONT_DESC,
|
|
PROP_SUBTITLE_ENCODING,
|
|
PROP_VIS_PLUGIN,
|
|
PROP_SAMPLE,
|
|
PROP_AV_OFFSET,
|
|
PROP_VIDEO_SINK,
|
|
PROP_AUDIO_SINK,
|
|
PROP_TEXT_SINK,
|
|
PROP_SEND_EVENT_MODE,
|
|
PROP_FORCE_ASPECT_RATIO,
|
|
PROP_LAST
|
|
};
|
|
|
|
/* signals */
|
|
enum
|
|
{
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
static void gst_play_sink_dispose (GObject * object);
|
|
static void gst_play_sink_finalize (GObject * object);
|
|
static void gst_play_sink_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * spec);
|
|
static void gst_play_sink_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * spec);
|
|
|
|
static GstPad *gst_play_sink_request_new_pad (GstElement * element,
|
|
GstPadTemplate * templ, const gchar * name, const GstCaps * caps);
|
|
static void gst_play_sink_release_request_pad (GstElement * element,
|
|
GstPad * pad);
|
|
static gboolean gst_play_sink_send_event (GstElement * element,
|
|
GstEvent * event);
|
|
static GstStateChangeReturn gst_play_sink_change_state (GstElement * element,
|
|
GstStateChange transition);
|
|
|
|
static void gst_play_sink_handle_message (GstBin * bin, GstMessage * message);
|
|
|
|
/* sending audio/video flushes break stream changes when the pipeline
|
|
* is paused and played again in 0.10 */
|
|
#if 0
|
|
static gboolean gst_play_sink_video_sink_event (GstPad * pad, GstEvent * event);
|
|
static GstFlowReturn gst_play_sink_video_sink_chain (GstPad * pad,
|
|
GstBuffer * buffer);
|
|
static gboolean gst_play_sink_audio_sink_event (GstPad * pad, GstEvent * event);
|
|
static GstFlowReturn gst_play_sink_audio_sink_chain (GstPad * pad,
|
|
GstBuffer * buffer);
|
|
#endif
|
|
static gboolean gst_play_sink_text_sink_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event);
|
|
static GstFlowReturn gst_play_sink_text_sink_chain (GstPad * pad,
|
|
GstObject * parent, GstBuffer * buffer);
|
|
|
|
static void notify_volume_cb (GObject * object, GParamSpec * pspec,
|
|
GstPlaySink * playsink);
|
|
static void notify_mute_cb (GObject * object, GParamSpec * pspec,
|
|
GstPlaySink * playsink);
|
|
|
|
static void update_av_offset (GstPlaySink * playsink);
|
|
|
|
static gboolean gst_play_sink_do_reconfigure (GstPlaySink * playsink);
|
|
|
|
static GQuark _playsink_reset_segment_event_marker_id = 0;
|
|
|
|
/* static guint gst_play_sink_signals[LAST_SIGNAL] = { 0 }; */
|
|
|
|
static void gst_play_sink_overlay_init (gpointer g_iface,
|
|
gpointer g_iface_data);
|
|
static void gst_play_sink_navigation_init (gpointer g_iface,
|
|
gpointer g_iface_data);
|
|
static void gst_play_sink_colorbalance_init (gpointer g_iface,
|
|
gpointer g_iface_data);
|
|
|
|
static void
|
|
_do_init (GType type)
|
|
{
|
|
static const GInterfaceInfo svol_info = {
|
|
NULL, NULL, NULL
|
|
};
|
|
static const GInterfaceInfo ov_info = {
|
|
gst_play_sink_overlay_init,
|
|
NULL, NULL
|
|
};
|
|
static const GInterfaceInfo nav_info = {
|
|
gst_play_sink_navigation_init,
|
|
NULL, NULL
|
|
};
|
|
static const GInterfaceInfo col_info = {
|
|
gst_play_sink_colorbalance_init,
|
|
NULL, NULL
|
|
};
|
|
|
|
g_type_add_interface_static (type, GST_TYPE_STREAM_VOLUME, &svol_info);
|
|
g_type_add_interface_static (type, GST_TYPE_VIDEO_OVERLAY, &ov_info);
|
|
g_type_add_interface_static (type, GST_TYPE_NAVIGATION, &nav_info);
|
|
g_type_add_interface_static (type, GST_TYPE_COLOR_BALANCE, &col_info);
|
|
}
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GstPlaySink, gst_play_sink, GST_TYPE_BIN,
|
|
_do_init (g_define_type_id));
|
|
|
|
static void
|
|
gst_play_sink_class_init (GstPlaySinkClass * klass)
|
|
{
|
|
GObjectClass *gobject_klass;
|
|
GstElementClass *gstelement_klass;
|
|
GstBinClass *gstbin_klass;
|
|
|
|
gobject_klass = (GObjectClass *) klass;
|
|
gstelement_klass = (GstElementClass *) klass;
|
|
gstbin_klass = (GstBinClass *) klass;
|
|
|
|
gobject_klass->dispose = gst_play_sink_dispose;
|
|
gobject_klass->finalize = gst_play_sink_finalize;
|
|
gobject_klass->set_property = gst_play_sink_set_property;
|
|
gobject_klass->get_property = gst_play_sink_get_property;
|
|
|
|
|
|
/**
|
|
* GstPlaySink:flags
|
|
*
|
|
* Control the behaviour of playsink.
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_FLAGS,
|
|
g_param_spec_flags ("flags", "Flags", "Flags to control behaviour",
|
|
GST_TYPE_PLAY_FLAGS, DEFAULT_FLAGS,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GstPlaySink:volume:
|
|
*
|
|
* Get or set the current audio stream volume. 1.0 means 100%,
|
|
* 0.0 means mute. This uses a linear volume scale.
|
|
*
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_VOLUME,
|
|
g_param_spec_double ("volume", "Volume", "The audio volume, 1.0=100%",
|
|
0.0, VOLUME_MAX_DOUBLE, 1.0,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
g_object_class_install_property (gobject_klass, PROP_MUTE,
|
|
g_param_spec_boolean ("mute", "Mute",
|
|
"Mute the audio channel without changing the volume", FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
g_object_class_install_property (gobject_klass, PROP_FONT_DESC,
|
|
g_param_spec_string ("subtitle-font-desc",
|
|
"Subtitle font description",
|
|
"Pango font description of font "
|
|
"to be used for subtitle rendering", NULL,
|
|
G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
|
|
g_object_class_install_property (gobject_klass, PROP_SUBTITLE_ENCODING,
|
|
g_param_spec_string ("subtitle-encoding", "subtitle encoding",
|
|
"Encoding to assume if input subtitles are not in UTF-8 encoding. "
|
|
"If not set, the GST_SUBTITLE_ENCODING environment variable will "
|
|
"be checked for an encoding to use. If that is not set either, "
|
|
"ISO-8859-15 will be assumed.", NULL,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
g_object_class_install_property (gobject_klass, PROP_VIS_PLUGIN,
|
|
g_param_spec_object ("vis-plugin", "Vis plugin",
|
|
"the visualization element to use (NULL = default)",
|
|
GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
/**
|
|
* GstPlaySink:sample:
|
|
*
|
|
* Get the currently rendered or prerolled sample in the video sink.
|
|
* The #GstCaps in the sample will describe the format of the buffer.
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_SAMPLE,
|
|
g_param_spec_boxed ("sample", "Sample",
|
|
"The last sample (NULL = no video available)",
|
|
GST_TYPE_SAMPLE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
/**
|
|
* GstPlaySink:av-offset:
|
|
*
|
|
* Control the synchronisation offset between the audio and video streams.
|
|
* Positive values make the audio ahead of the video and negative values make
|
|
* the audio go behind the video.
|
|
*
|
|
* Since: 0.10.30
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_AV_OFFSET,
|
|
g_param_spec_int64 ("av-offset", "AV Offset",
|
|
"The synchronisation offset between audio and video in nanoseconds",
|
|
G_MININT64, G_MAXINT64, 0,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GstPlaySink:video-sink:
|
|
*
|
|
* Set the used video sink element. NULL will use the default sink. playsink
|
|
* must be in %GST_STATE_NULL
|
|
*
|
|
* Since: 0.10.36
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_VIDEO_SINK,
|
|
g_param_spec_object ("video-sink", "Video Sink",
|
|
"the video output element to use (NULL = default sink)",
|
|
GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
/**
|
|
* GstPlaySink:audio-sink:
|
|
*
|
|
* Set the used audio sink element. NULL will use the default sink. playsink
|
|
* must be in %GST_STATE_NULL
|
|
*
|
|
* Since: 0.10.36
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_AUDIO_SINK,
|
|
g_param_spec_object ("audio-sink", "Audio Sink",
|
|
"the audio output element to use (NULL = default sink)",
|
|
GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GstPlaySink:text-sink:
|
|
*
|
|
* Set the used text sink element. NULL will use the default sink. playsink
|
|
* must be in %GST_STATE_NULL
|
|
*
|
|
* Since: 0.10.36
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_TEXT_SINK,
|
|
g_param_spec_object ("text-sink", "Text sink",
|
|
"the text output element to use (NULL = default subtitleoverlay)",
|
|
GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GstPlaySink::send-event-mode:
|
|
*
|
|
* Sets the handling method used for events received from send_event
|
|
* function. The default is %MODE_DEFAULT, that uses %GstBin's default
|
|
* handling (push the event to all internal sinks).
|
|
*
|
|
* Since: 0.10.37
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_SEND_EVENT_MODE,
|
|
g_param_spec_enum ("send-event-mode", "Send event mode",
|
|
"How to send events received in send_event function",
|
|
GST_TYPE_PLAY_SINK_SEND_EVENT_MODE, MODE_DEFAULT,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GstPlaySink::force-aspect-ratio:
|
|
*
|
|
* Requests the video sink to enforce the video display aspect ratio.
|
|
*
|
|
* Since: 0.10.37
|
|
*/
|
|
g_object_class_install_property (gobject_klass, PROP_FORCE_ASPECT_RATIO,
|
|
g_param_spec_boolean ("force-aspect-ratio", "Force Aspect Ratio",
|
|
"When enabled, scaling will respect original aspect ratio", TRUE,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_signal_new ("reconfigure", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstPlaySinkClass,
|
|
reconfigure), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_BOOLEAN,
|
|
0, G_TYPE_NONE);
|
|
/**
|
|
* GstPlaySink::convert-sample
|
|
* @playsink: a #GstPlaySink
|
|
* @caps: the target format of the sample
|
|
*
|
|
* Action signal to retrieve the currently playing video sample in the format
|
|
* specified by @caps.
|
|
* If @caps is %NULL, no conversion will be performed and this function is
|
|
* equivalent to the #GstPlaySink::sample property.
|
|
*
|
|
* Returns: a #GstSample of the current video sample converted to #caps.
|
|
* The caps in the sample will describe the final layout of the buffer data.
|
|
* %NULL is returned when no current sample can be retrieved or when the
|
|
* conversion failed.
|
|
*/
|
|
g_signal_new ("convert-sample", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
G_STRUCT_OFFSET (GstPlaySinkClass, convert_sample), NULL, NULL,
|
|
g_cclosure_marshal_generic, GST_TYPE_SAMPLE, 1, GST_TYPE_CAPS);
|
|
|
|
gst_element_class_add_pad_template (gstelement_klass,
|
|
gst_static_pad_template_get (&audiorawtemplate));
|
|
gst_element_class_add_pad_template (gstelement_klass,
|
|
gst_static_pad_template_get (&audiotemplate));
|
|
gst_element_class_add_pad_template (gstelement_klass,
|
|
gst_static_pad_template_get (&videorawtemplate));
|
|
gst_element_class_add_pad_template (gstelement_klass,
|
|
gst_static_pad_template_get (&videotemplate));
|
|
gst_element_class_add_pad_template (gstelement_klass,
|
|
gst_static_pad_template_get (&texttemplate));
|
|
gst_element_class_set_static_metadata (gstelement_klass, "Player Sink",
|
|
"Generic/Bin/Sink",
|
|
"Convenience sink for multiple streams",
|
|
"Wim Taymans <wim.taymans@gmail.com>");
|
|
|
|
gstelement_klass->change_state =
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_change_state);
|
|
gstelement_klass->send_event = GST_DEBUG_FUNCPTR (gst_play_sink_send_event);
|
|
gstelement_klass->request_new_pad =
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_request_new_pad);
|
|
gstelement_klass->release_pad =
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_release_request_pad);
|
|
|
|
gstbin_klass->handle_message =
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_handle_message);
|
|
|
|
klass->reconfigure = GST_DEBUG_FUNCPTR (gst_play_sink_reconfigure);
|
|
klass->convert_sample = GST_DEBUG_FUNCPTR (gst_play_sink_convert_sample);
|
|
|
|
_playsink_reset_segment_event_marker_id =
|
|
g_quark_from_static_string ("gst-playsink-reset-segment-event-marker");
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_init (GstPlaySink * playsink)
|
|
{
|
|
GstColorBalanceChannel *channel;
|
|
|
|
/* init groups */
|
|
playsink->video_sink = NULL;
|
|
playsink->audio_sink = NULL;
|
|
playsink->visualisation = NULL;
|
|
playsink->text_sink = NULL;
|
|
playsink->volume = 1.0;
|
|
playsink->font_desc = NULL;
|
|
playsink->subtitle_encoding = NULL;
|
|
playsink->flags = DEFAULT_FLAGS;
|
|
playsink->send_event_mode = MODE_DEFAULT;
|
|
playsink->force_aspect_ratio = TRUE;
|
|
|
|
playsink->stream_synchronizer =
|
|
g_object_new (GST_TYPE_STREAM_SYNCHRONIZER, NULL);
|
|
gst_bin_add (GST_BIN_CAST (playsink),
|
|
GST_ELEMENT_CAST (playsink->stream_synchronizer));
|
|
|
|
g_rec_mutex_init (&playsink->lock);
|
|
GST_OBJECT_FLAG_SET (playsink, GST_ELEMENT_FLAG_SINK);
|
|
|
|
channel =
|
|
GST_COLOR_BALANCE_CHANNEL (g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL,
|
|
NULL));
|
|
channel->label = g_strdup ("CONTRAST");
|
|
channel->min_value = -1000;
|
|
channel->max_value = 1000;
|
|
playsink->colorbalance_channels =
|
|
g_list_append (playsink->colorbalance_channels, channel);
|
|
playsink->colorbalance_values[0] = 0;
|
|
|
|
channel =
|
|
GST_COLOR_BALANCE_CHANNEL (g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL,
|
|
NULL));
|
|
channel->label = g_strdup ("BRIGHTNESS");
|
|
channel->min_value = -1000;
|
|
channel->max_value = 1000;
|
|
playsink->colorbalance_channels =
|
|
g_list_append (playsink->colorbalance_channels, channel);
|
|
playsink->colorbalance_values[1] = 0;
|
|
|
|
channel =
|
|
GST_COLOR_BALANCE_CHANNEL (g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL,
|
|
NULL));
|
|
channel->label = g_strdup ("HUE");
|
|
channel->min_value = -1000;
|
|
channel->max_value = 1000;
|
|
playsink->colorbalance_channels =
|
|
g_list_append (playsink->colorbalance_channels, channel);
|
|
playsink->colorbalance_values[2] = 0;
|
|
|
|
channel =
|
|
GST_COLOR_BALANCE_CHANNEL (g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL,
|
|
NULL));
|
|
channel->label = g_strdup ("SATURATION");
|
|
channel->min_value = -1000;
|
|
channel->max_value = 1000;
|
|
playsink->colorbalance_channels =
|
|
g_list_append (playsink->colorbalance_channels, channel);
|
|
playsink->colorbalance_values[3] = 0;
|
|
}
|
|
|
|
static void
|
|
disconnect_chain (GstPlayAudioChain * chain, GstPlaySink * playsink)
|
|
{
|
|
if (chain) {
|
|
if (chain->volume)
|
|
g_signal_handlers_disconnect_by_func (chain->volume, notify_volume_cb,
|
|
playsink);
|
|
if (chain->mute)
|
|
g_signal_handlers_disconnect_by_func (chain->mute, notify_mute_cb,
|
|
playsink);
|
|
}
|
|
}
|
|
|
|
static void
|
|
free_chain (GstPlayChain * chain)
|
|
{
|
|
if (chain) {
|
|
if (chain->bin)
|
|
gst_object_unref (chain->bin);
|
|
g_free (chain);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_dispose (GObject * object)
|
|
{
|
|
GstPlaySink *playsink;
|
|
|
|
playsink = GST_PLAY_SINK (object);
|
|
|
|
if (playsink->audio_sink != NULL) {
|
|
gst_element_set_state (playsink->audio_sink, GST_STATE_NULL);
|
|
gst_object_unref (playsink->audio_sink);
|
|
playsink->audio_sink = NULL;
|
|
}
|
|
if (playsink->video_sink != NULL) {
|
|
gst_element_set_state (playsink->video_sink, GST_STATE_NULL);
|
|
gst_object_unref (playsink->video_sink);
|
|
playsink->video_sink = NULL;
|
|
}
|
|
if (playsink->visualisation != NULL) {
|
|
gst_element_set_state (playsink->visualisation, GST_STATE_NULL);
|
|
gst_object_unref (playsink->visualisation);
|
|
playsink->visualisation = NULL;
|
|
}
|
|
if (playsink->text_sink != NULL) {
|
|
gst_element_set_state (playsink->text_sink, GST_STATE_NULL);
|
|
gst_object_unref (playsink->text_sink);
|
|
playsink->text_sink = NULL;
|
|
}
|
|
|
|
free_chain ((GstPlayChain *) playsink->videodeinterlacechain);
|
|
playsink->videodeinterlacechain = NULL;
|
|
free_chain ((GstPlayChain *) playsink->videochain);
|
|
playsink->videochain = NULL;
|
|
free_chain ((GstPlayChain *) playsink->audiochain);
|
|
playsink->audiochain = NULL;
|
|
free_chain ((GstPlayChain *) playsink->vischain);
|
|
playsink->vischain = NULL;
|
|
free_chain ((GstPlayChain *) playsink->textchain);
|
|
playsink->textchain = NULL;
|
|
|
|
if (playsink->audio_tee_sink) {
|
|
gst_object_unref (playsink->audio_tee_sink);
|
|
playsink->audio_tee_sink = NULL;
|
|
}
|
|
|
|
if (playsink->audio_tee_vissrc) {
|
|
gst_element_release_request_pad (playsink->audio_tee,
|
|
playsink->audio_tee_vissrc);
|
|
gst_object_unref (playsink->audio_tee_vissrc);
|
|
playsink->audio_tee_vissrc = NULL;
|
|
}
|
|
|
|
if (playsink->audio_tee_asrc) {
|
|
gst_element_release_request_pad (playsink->audio_tee,
|
|
playsink->audio_tee_asrc);
|
|
gst_object_unref (playsink->audio_tee_asrc);
|
|
playsink->audio_tee_asrc = NULL;
|
|
}
|
|
|
|
g_free (playsink->font_desc);
|
|
playsink->font_desc = NULL;
|
|
|
|
g_free (playsink->subtitle_encoding);
|
|
playsink->subtitle_encoding = NULL;
|
|
|
|
playsink->stream_synchronizer = NULL;
|
|
|
|
g_list_foreach (playsink->colorbalance_channels, (GFunc) gst_object_unref,
|
|
NULL);
|
|
g_list_free (playsink->colorbalance_channels);
|
|
playsink->colorbalance_channels = NULL;
|
|
|
|
G_OBJECT_CLASS (gst_play_sink_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_finalize (GObject * object)
|
|
{
|
|
GstPlaySink *playsink;
|
|
|
|
playsink = GST_PLAY_SINK (object);
|
|
|
|
g_rec_mutex_clear (&playsink->lock);
|
|
|
|
G_OBJECT_CLASS (gst_play_sink_parent_class)->finalize (object);
|
|
}
|
|
|
|
void
|
|
gst_play_sink_set_sink (GstPlaySink * playsink, GstPlaySinkType type,
|
|
GstElement * sink)
|
|
{
|
|
GstElement **elem = NULL, *old = NULL;
|
|
|
|
GST_LOG ("Setting sink %" GST_PTR_FORMAT " as sink type %d", sink, type);
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
switch (type) {
|
|
case GST_PLAY_SINK_TYPE_AUDIO:
|
|
case GST_PLAY_SINK_TYPE_AUDIO_RAW:
|
|
elem = &playsink->audio_sink;
|
|
break;
|
|
case GST_PLAY_SINK_TYPE_VIDEO:
|
|
case GST_PLAY_SINK_TYPE_VIDEO_RAW:
|
|
elem = &playsink->video_sink;
|
|
break;
|
|
case GST_PLAY_SINK_TYPE_TEXT:
|
|
elem = &playsink->text_sink;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (elem) {
|
|
old = *elem;
|
|
if (sink)
|
|
gst_object_ref (sink);
|
|
*elem = sink;
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
if (old) {
|
|
if (old != sink)
|
|
gst_element_set_state (old, GST_STATE_NULL);
|
|
gst_object_unref (old);
|
|
}
|
|
}
|
|
|
|
GstElement *
|
|
gst_play_sink_get_sink (GstPlaySink * playsink, GstPlaySinkType type)
|
|
{
|
|
GstElement *result = NULL;
|
|
GstElement *elem = NULL, *chainp = NULL;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
switch (type) {
|
|
case GST_PLAY_SINK_TYPE_AUDIO:
|
|
case GST_PLAY_SINK_TYPE_AUDIO_RAW:
|
|
{
|
|
GstPlayAudioChain *chain;
|
|
if ((chain = (GstPlayAudioChain *) playsink->audiochain))
|
|
chainp = chain->sink;
|
|
elem = playsink->audio_sink;
|
|
break;
|
|
}
|
|
case GST_PLAY_SINK_TYPE_VIDEO:
|
|
case GST_PLAY_SINK_TYPE_VIDEO_RAW:
|
|
{
|
|
GstPlayVideoChain *chain;
|
|
if ((chain = (GstPlayVideoChain *) playsink->videochain))
|
|
chainp = chain->sink;
|
|
elem = playsink->video_sink;
|
|
break;
|
|
}
|
|
case GST_PLAY_SINK_TYPE_TEXT:
|
|
{
|
|
GstPlayTextChain *chain;
|
|
if ((chain = (GstPlayTextChain *) playsink->textchain))
|
|
chainp = chain->sink;
|
|
elem = playsink->text_sink;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
if (chainp) {
|
|
/* we have an active chain with a sink, get the sink */
|
|
result = gst_object_ref (chainp);
|
|
}
|
|
/* nothing found, return last configured sink */
|
|
if (result == NULL && elem)
|
|
result = gst_object_ref (elem);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return result;
|
|
}
|
|
|
|
static GstPadProbeReturn
|
|
gst_play_sink_vis_blocked (GstPad * tee_pad, GstPadProbeInfo * info,
|
|
gpointer user_data)
|
|
{
|
|
GstPlaySink *playsink;
|
|
GstPlayVisChain *chain;
|
|
|
|
playsink = GST_PLAY_SINK (user_data);
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
GST_DEBUG_OBJECT (playsink, "vis pad blocked");
|
|
/* now try to change the plugin in the running vis chain */
|
|
if (!(chain = (GstPlayVisChain *) playsink->vischain))
|
|
goto done;
|
|
|
|
/* unlink the old plugin and unghost the pad */
|
|
gst_pad_unlink (chain->blockpad, chain->vissinkpad);
|
|
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (chain->srcpad), NULL);
|
|
|
|
/* set the old plugin to NULL and remove */
|
|
gst_element_set_state (chain->vis, GST_STATE_NULL);
|
|
gst_bin_remove (GST_BIN_CAST (chain->chain.bin), chain->vis);
|
|
|
|
/* add new plugin and set state to playing */
|
|
chain->vis = playsink->visualisation;
|
|
gst_bin_add (GST_BIN_CAST (chain->chain.bin), chain->vis);
|
|
gst_element_set_state (chain->vis, GST_STATE_PLAYING);
|
|
|
|
/* get pads */
|
|
chain->vissinkpad = gst_element_get_static_pad (chain->vis, "sink");
|
|
chain->vissrcpad = gst_element_get_static_pad (chain->vis, "src");
|
|
|
|
/* link pads */
|
|
gst_pad_link_full (chain->blockpad, chain->vissinkpad,
|
|
GST_PAD_LINK_CHECK_NOTHING);
|
|
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (chain->srcpad),
|
|
chain->vissrcpad);
|
|
|
|
done:
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
/* remove the probe and unblock the pad */
|
|
return GST_PAD_PROBE_REMOVE;
|
|
}
|
|
|
|
void
|
|
gst_play_sink_set_vis_plugin (GstPlaySink * playsink, GstElement * vis)
|
|
{
|
|
GstPlayVisChain *chain;
|
|
|
|
/* setting NULL means creating the default vis plugin */
|
|
if (vis == NULL)
|
|
vis = gst_element_factory_make ("goom", "vis");
|
|
|
|
/* simply return if we don't have a vis plugin here */
|
|
if (vis == NULL)
|
|
return;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
/* first store the new vis */
|
|
if (playsink->visualisation)
|
|
gst_object_unref (playsink->visualisation);
|
|
/* take ownership */
|
|
gst_object_ref_sink (vis);
|
|
playsink->visualisation = vis;
|
|
|
|
/* now try to change the plugin in the running vis chain, if we have no chain,
|
|
* we don't bother, any future vis chain will be created with the new vis
|
|
* plugin. */
|
|
if (!(chain = (GstPlayVisChain *) playsink->vischain))
|
|
goto done;
|
|
|
|
/* block the pad, the next time the callback is called we can change the
|
|
* visualisation. It's possible that this never happens or that the pad was
|
|
* already blocked. If the callback never happens, we don't have new data so
|
|
* we don't need the new vis plugin. If the pad was already blocked, the
|
|
* function returns FALSE but the previous pad block will do the right thing
|
|
* anyway. */
|
|
GST_DEBUG_OBJECT (playsink, "blocking vis pad");
|
|
gst_pad_add_probe (chain->blockpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
|
|
gst_play_sink_vis_blocked, playsink, NULL);
|
|
done:
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return;
|
|
}
|
|
|
|
GstElement *
|
|
gst_play_sink_get_vis_plugin (GstPlaySink * playsink)
|
|
{
|
|
GstElement *result = NULL;
|
|
GstPlayVisChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
if ((chain = (GstPlayVisChain *) playsink->vischain)) {
|
|
/* we have an active chain, get the sink */
|
|
if (chain->vis)
|
|
result = gst_object_ref (chain->vis);
|
|
}
|
|
/* nothing found, return last configured sink */
|
|
if (result == NULL && playsink->visualisation)
|
|
result = gst_object_ref (playsink->visualisation);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
gst_play_sink_set_volume (GstPlaySink * playsink, gdouble volume)
|
|
{
|
|
GstPlayAudioChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
playsink->volume = volume;
|
|
chain = (GstPlayAudioChain *) playsink->audiochain;
|
|
if (chain && chain->volume) {
|
|
GST_LOG_OBJECT (playsink, "elements: volume=%" GST_PTR_FORMAT ", mute=%"
|
|
GST_PTR_FORMAT "; new volume=%.03f, mute=%d", chain->volume,
|
|
chain->mute, volume, playsink->mute);
|
|
/* if there is a mute element or we are not muted, set the volume */
|
|
if (chain->mute || !playsink->mute)
|
|
g_object_set (chain->volume, "volume", volume, NULL);
|
|
} else {
|
|
GST_LOG_OBJECT (playsink, "no volume element");
|
|
playsink->volume_changed = TRUE;
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
gdouble
|
|
gst_play_sink_get_volume (GstPlaySink * playsink)
|
|
{
|
|
gdouble result;
|
|
GstPlayAudioChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
chain = (GstPlayAudioChain *) playsink->audiochain;
|
|
result = playsink->volume;
|
|
if (chain && chain->volume) {
|
|
if (chain->mute || !playsink->mute) {
|
|
g_object_get (chain->volume, "volume", &result, NULL);
|
|
playsink->volume = result;
|
|
}
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
gst_play_sink_set_mute (GstPlaySink * playsink, gboolean mute)
|
|
{
|
|
GstPlayAudioChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
playsink->mute = mute;
|
|
chain = (GstPlayAudioChain *) playsink->audiochain;
|
|
if (chain) {
|
|
if (chain->mute) {
|
|
g_object_set (chain->mute, "mute", mute, NULL);
|
|
} else if (chain->volume) {
|
|
if (mute)
|
|
g_object_set (chain->volume, "volume", (gdouble) 0.0, NULL);
|
|
else
|
|
g_object_set (chain->volume, "volume", (gdouble) playsink->volume,
|
|
NULL);
|
|
}
|
|
} else {
|
|
playsink->mute_changed = TRUE;
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
gboolean
|
|
gst_play_sink_get_mute (GstPlaySink * playsink)
|
|
{
|
|
gboolean result;
|
|
GstPlayAudioChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
chain = (GstPlayAudioChain *) playsink->audiochain;
|
|
if (chain && chain->mute) {
|
|
g_object_get (chain->mute, "mute", &result, NULL);
|
|
playsink->mute = result;
|
|
} else {
|
|
result = playsink->mute;
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return result;
|
|
}
|
|
|
|
static void
|
|
post_missing_element_message (GstPlaySink * playsink, const gchar * name)
|
|
{
|
|
GstMessage *msg;
|
|
|
|
msg = gst_missing_element_message_new (GST_ELEMENT_CAST (playsink), name);
|
|
gst_element_post_message (GST_ELEMENT_CAST (playsink), msg);
|
|
}
|
|
|
|
static gboolean
|
|
add_chain (GstPlayChain * chain, gboolean add)
|
|
{
|
|
if (chain->added == add)
|
|
return TRUE;
|
|
|
|
if (add)
|
|
gst_bin_add (GST_BIN_CAST (chain->playsink), chain->bin);
|
|
else {
|
|
gst_bin_remove (GST_BIN_CAST (chain->playsink), chain->bin);
|
|
/* we don't want to lose our sink status */
|
|
GST_OBJECT_FLAG_SET (chain->playsink, GST_ELEMENT_FLAG_SINK);
|
|
}
|
|
|
|
chain->added = add;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
activate_chain (GstPlayChain * chain, gboolean activate)
|
|
{
|
|
GstState state;
|
|
|
|
if (chain->activated == activate)
|
|
return TRUE;
|
|
|
|
GST_OBJECT_LOCK (chain->playsink);
|
|
state = GST_STATE_TARGET (chain->playsink);
|
|
GST_OBJECT_UNLOCK (chain->playsink);
|
|
|
|
if (activate)
|
|
gst_element_set_state (chain->bin, state);
|
|
else
|
|
gst_element_set_state (chain->bin, GST_STATE_NULL);
|
|
|
|
chain->activated = activate;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
element_is_sink (GstElement * element)
|
|
{
|
|
gboolean is_sink;
|
|
|
|
GST_OBJECT_LOCK (element);
|
|
is_sink = GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_SINK);
|
|
GST_OBJECT_UNLOCK (element);
|
|
|
|
GST_DEBUG_OBJECT (element, "is a sink: %s", (is_sink) ? "yes" : "no");
|
|
return is_sink;
|
|
}
|
|
|
|
static gboolean
|
|
element_has_property (GstElement * element, const gchar * pname, GType type)
|
|
{
|
|
GParamSpec *pspec;
|
|
|
|
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (element), pname);
|
|
|
|
if (pspec == NULL) {
|
|
GST_DEBUG_OBJECT (element, "no %s property", pname);
|
|
return FALSE;
|
|
}
|
|
|
|
if (type == G_TYPE_INVALID || type == pspec->value_type ||
|
|
g_type_is_a (pspec->value_type, type)) {
|
|
GST_DEBUG_OBJECT (element, "has %s property of type %s", pname,
|
|
(type == G_TYPE_INVALID) ? "any type" : g_type_name (type));
|
|
return TRUE;
|
|
}
|
|
|
|
GST_WARNING_OBJECT (element, "has %s property, but property is of type %s "
|
|
"and we expected it to be of type %s", pname,
|
|
g_type_name (pspec->value_type), g_type_name (type));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
const gchar *prop_name;
|
|
GType prop_type;
|
|
gboolean need_sink;
|
|
} FindPropertyHelper;
|
|
|
|
static gint
|
|
find_property (const GValue * item, FindPropertyHelper * helper)
|
|
{
|
|
GstElement *element = g_value_get_object (item);
|
|
if (helper->need_sink && !element_is_sink (element)) {
|
|
return 1;
|
|
}
|
|
|
|
if (!element_has_property (element, helper->prop_name, helper->prop_type)) {
|
|
return 1;
|
|
}
|
|
|
|
GST_INFO_OBJECT (element, "found %s with %s property", helper->prop_name,
|
|
(helper->need_sink) ? "sink" : "element");
|
|
return 0; /* keep it */
|
|
}
|
|
|
|
/* FIXME: why not move these functions into core? */
|
|
/* find a sink in the hierarchy with a property named @name. This function does
|
|
* not increase the refcount of the returned object and thus remains valid as
|
|
* long as the bin is valid. */
|
|
static GstElement *
|
|
gst_play_sink_find_property_sinks (GstPlaySink * playsink, GstElement * obj,
|
|
const gchar * name, GType expected_type)
|
|
{
|
|
GstElement *result = NULL;
|
|
GstIterator *it;
|
|
|
|
if (element_has_property (obj, name, expected_type)) {
|
|
result = obj;
|
|
} else if (GST_IS_BIN (obj)) {
|
|
gboolean found;
|
|
GValue item = { 0, };
|
|
FindPropertyHelper helper = { name, expected_type, TRUE };
|
|
|
|
it = gst_bin_iterate_recurse (GST_BIN_CAST (obj));
|
|
found = gst_iterator_find_custom (it,
|
|
(GCompareFunc) find_property, &item, &helper);
|
|
gst_iterator_free (it);
|
|
if (found) {
|
|
result = g_value_get_object (&item);
|
|
/* we don't need the extra ref */
|
|
g_value_unset (&item);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* find an object in the hierarchy with a property named @name */
|
|
static GstElement *
|
|
gst_play_sink_find_property (GstPlaySink * playsink, GstElement * obj,
|
|
const gchar * name, GType expected_type)
|
|
{
|
|
GstElement *result = NULL;
|
|
GstIterator *it;
|
|
|
|
if (GST_IS_BIN (obj)) {
|
|
gboolean found;
|
|
GValue item = { 0, };
|
|
FindPropertyHelper helper = { name, expected_type, FALSE };
|
|
|
|
it = gst_bin_iterate_recurse (GST_BIN_CAST (obj));
|
|
found = gst_iterator_find_custom (it,
|
|
(GCompareFunc) find_property, &item, &helper);
|
|
gst_iterator_free (it);
|
|
if (found) {
|
|
result = g_value_dup_object (&item);
|
|
g_value_unset (&item);
|
|
}
|
|
} else {
|
|
if (element_has_property (obj, name, expected_type)) {
|
|
result = obj;
|
|
gst_object_ref (obj);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void
|
|
do_async_start (GstPlaySink * playsink)
|
|
{
|
|
GstMessage *message;
|
|
|
|
if (!playsink->need_async_start) {
|
|
GST_INFO_OBJECT (playsink, "no async_start needed");
|
|
return;
|
|
}
|
|
|
|
playsink->async_pending = TRUE;
|
|
|
|
GST_INFO_OBJECT (playsink, "Sending async_start message");
|
|
message = gst_message_new_async_start (GST_OBJECT_CAST (playsink));
|
|
GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (GST_BIN_CAST
|
|
(playsink), message);
|
|
}
|
|
|
|
static void
|
|
do_async_done (GstPlaySink * playsink)
|
|
{
|
|
GstMessage *message;
|
|
|
|
if (playsink->async_pending) {
|
|
GST_INFO_OBJECT (playsink, "Sending async_done message");
|
|
message =
|
|
gst_message_new_async_done (GST_OBJECT_CAST (playsink),
|
|
GST_CLOCK_TIME_NONE);
|
|
GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (GST_BIN_CAST
|
|
(playsink), message);
|
|
|
|
playsink->async_pending = FALSE;
|
|
}
|
|
|
|
playsink->need_async_start = FALSE;
|
|
}
|
|
|
|
/* try to change the state of an element. This function returns the element when
|
|
* the state change could be performed. When this function returns NULL an error
|
|
* occured and the element is unreffed if @unref is TRUE. */
|
|
static GstElement *
|
|
try_element (GstPlaySink * playsink, GstElement * element, gboolean unref)
|
|
{
|
|
GstStateChangeReturn ret;
|
|
|
|
if (element) {
|
|
ret = gst_element_set_state (element, GST_STATE_READY);
|
|
if (ret == GST_STATE_CHANGE_FAILURE) {
|
|
GST_DEBUG_OBJECT (playsink, "failed state change..");
|
|
gst_element_set_state (element, GST_STATE_NULL);
|
|
if (unref)
|
|
gst_object_unref (element);
|
|
element = NULL;
|
|
}
|
|
}
|
|
return element;
|
|
}
|
|
|
|
/* make the element (bin) that contains the elements needed to perform
|
|
* video display. Only used for *raw* video streams.
|
|
*
|
|
* +------------------------------------------------------------+
|
|
* | vbin |
|
|
* | +-------+ +----------+ +----------+ +---------+ |
|
|
* | | queue | |colorspace| |videoscale| |videosink| |
|
|
* | +-sink src-sink src-sink src-sink | |
|
|
* | | +-------+ +----------+ +----------+ +---------+ |
|
|
* sink-+ |
|
|
* +------------------------------------------------------------+
|
|
*
|
|
*/
|
|
static GstPlayVideoDeinterlaceChain *
|
|
gen_video_deinterlace_chain (GstPlaySink * playsink)
|
|
{
|
|
GstPlayVideoDeinterlaceChain *chain;
|
|
GstBin *bin;
|
|
GstPad *pad;
|
|
GstElement *head = NULL, *prev = NULL;
|
|
|
|
chain = g_new0 (GstPlayVideoDeinterlaceChain, 1);
|
|
chain->chain.playsink = playsink;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "making video deinterlace chain %p", chain);
|
|
|
|
/* create a bin to hold objects, as we create them we add them to this bin so
|
|
* that when something goes wrong we only need to unref the bin */
|
|
chain->chain.bin = gst_bin_new ("vdbin");
|
|
bin = GST_BIN_CAST (chain->chain.bin);
|
|
gst_object_ref_sink (bin);
|
|
|
|
GST_DEBUG_OBJECT (playsink, "creating " COLORSPACE);
|
|
chain->conv = gst_element_factory_make (COLORSPACE, "vdconv");
|
|
if (chain->conv == NULL) {
|
|
post_missing_element_message (playsink, COLORSPACE);
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
COLORSPACE), ("video rendering might fail"));
|
|
} else {
|
|
gst_bin_add (bin, chain->conv);
|
|
head = chain->conv;
|
|
prev = chain->conv;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (playsink, "creating deinterlace");
|
|
chain->deinterlace = gst_element_factory_make ("deinterlace", "deinterlace");
|
|
if (chain->deinterlace == NULL) {
|
|
post_missing_element_message (playsink, "deinterlace");
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"deinterlace"), ("deinterlacing won't work"));
|
|
} else {
|
|
gst_bin_add (bin, chain->deinterlace);
|
|
if (prev) {
|
|
if (!gst_element_link_pads_full (prev, "src", chain->deinterlace, "sink",
|
|
GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
|
|
goto link_failed;
|
|
} else {
|
|
head = chain->deinterlace;
|
|
}
|
|
prev = chain->deinterlace;
|
|
}
|
|
|
|
if (head) {
|
|
pad = gst_element_get_static_pad (head, "sink");
|
|
chain->sinkpad = gst_ghost_pad_new ("sink", pad);
|
|
gst_object_unref (pad);
|
|
} else {
|
|
chain->sinkpad = gst_ghost_pad_new_no_target ("sink", GST_PAD_SINK);
|
|
}
|
|
|
|
if (prev) {
|
|
pad = gst_element_get_static_pad (prev, "src");
|
|
chain->srcpad = gst_ghost_pad_new ("src", pad);
|
|
gst_object_unref (pad);
|
|
} else {
|
|
chain->srcpad = gst_ghost_pad_new ("src", chain->sinkpad);
|
|
}
|
|
|
|
gst_element_add_pad (chain->chain.bin, chain->sinkpad);
|
|
gst_element_add_pad (chain->chain.bin, chain->srcpad);
|
|
|
|
return chain;
|
|
|
|
link_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (playsink, CORE, PAD,
|
|
(NULL), ("Failed to configure the video deinterlace chain."));
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
is_valid_color_balance_element (GstColorBalance * bal)
|
|
{
|
|
gboolean have_brightness = FALSE;
|
|
gboolean have_contrast = FALSE;
|
|
gboolean have_hue = FALSE;
|
|
gboolean have_saturation = FALSE;
|
|
const GList *channels, *l;
|
|
|
|
channels = gst_color_balance_list_channels (bal);
|
|
for (l = channels; l; l = l->next) {
|
|
GstColorBalanceChannel *ch = l->data;
|
|
|
|
if (g_strrstr (ch->label, "BRIGHTNESS"))
|
|
have_brightness = TRUE;
|
|
else if (g_strrstr (ch->label, "CONTRAST"))
|
|
have_contrast = TRUE;
|
|
else if (g_strrstr (ch->label, "HUE"))
|
|
have_hue = TRUE;
|
|
else if (g_strrstr (ch->label, "SATURATION"))
|
|
have_saturation = TRUE;
|
|
}
|
|
|
|
return have_brightness && have_contrast && have_hue && have_saturation;
|
|
}
|
|
|
|
static void
|
|
iterate_color_balance_elements (const GValue * item, gpointer user_data)
|
|
{
|
|
gboolean valid;
|
|
GstColorBalance *cb, **cb_out = user_data;
|
|
|
|
cb = GST_COLOR_BALANCE (g_value_get_object (item));
|
|
valid = is_valid_color_balance_element (cb);
|
|
if (valid) {
|
|
if (*cb_out
|
|
&& gst_color_balance_get_balance_type (*cb_out) ==
|
|
GST_COLOR_BALANCE_SOFTWARE) {
|
|
gst_object_unref (*cb_out);
|
|
*cb_out = GST_COLOR_BALANCE (gst_object_ref (cb));
|
|
} else if (!*cb_out) {
|
|
*cb_out = GST_COLOR_BALANCE (gst_object_ref (cb));
|
|
}
|
|
}
|
|
}
|
|
|
|
static GstColorBalance *
|
|
find_color_balance_element (GstElement * element)
|
|
{
|
|
GstIterator *it;
|
|
GstColorBalance *cb = NULL;
|
|
|
|
if (GST_IS_COLOR_BALANCE (element)
|
|
&& is_valid_color_balance_element (GST_COLOR_BALANCE (element)))
|
|
return GST_COLOR_BALANCE (gst_object_ref (element));
|
|
else if (!GST_IS_BIN (element))
|
|
return FALSE;
|
|
|
|
it = gst_bin_iterate_all_by_interface (GST_BIN (element),
|
|
GST_TYPE_COLOR_BALANCE);
|
|
while (gst_iterator_foreach (it, iterate_color_balance_elements,
|
|
&cb) == GST_ITERATOR_RESYNC)
|
|
gst_iterator_resync (it);
|
|
gst_iterator_free (it);
|
|
|
|
return cb;
|
|
}
|
|
|
|
static void
|
|
colorbalance_value_changed_cb (GstColorBalance * balance,
|
|
GstColorBalanceChannel * channel, gint value, GstPlaySink * playsink)
|
|
{
|
|
GList *l;
|
|
gint i;
|
|
|
|
for (i = 0, l = playsink->colorbalance_channels; l; l = l->next, i++) {
|
|
GstColorBalanceChannel *proxy = l->data;
|
|
|
|
if (g_strrstr (channel->label, proxy->label)) {
|
|
gdouble new_val;
|
|
|
|
/* Convert to [0, 1] range */
|
|
new_val =
|
|
((gdouble) value -
|
|
(gdouble) channel->min_value) / ((gdouble) channel->max_value -
|
|
(gdouble) channel->min_value);
|
|
/* Convert to proxy range */
|
|
new_val =
|
|
proxy->min_value + new_val * ((gdouble) proxy->max_value -
|
|
(gdouble) proxy->min_value);
|
|
playsink->colorbalance_values[i] = (gint) (0.5 + new_val);
|
|
|
|
gst_color_balance_value_changed (GST_COLOR_BALANCE (playsink), proxy,
|
|
playsink->colorbalance_values[i]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
update_colorbalance (GstPlaySink * playsink)
|
|
{
|
|
GstColorBalance *balance = NULL;
|
|
GList *l;
|
|
gint i;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->colorbalance_element) {
|
|
balance =
|
|
GST_COLOR_BALANCE (gst_object_ref (playsink->colorbalance_element));
|
|
}
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
if (!balance)
|
|
return;
|
|
|
|
g_signal_handlers_block_by_func (balance,
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
|
|
for (i = 0, l = playsink->colorbalance_channels; l; l = l->next, i++) {
|
|
GstColorBalanceChannel *proxy = l->data;
|
|
GstColorBalanceChannel *channel = NULL;
|
|
const GList *channels, *k;
|
|
|
|
channels = gst_color_balance_list_channels (balance);
|
|
for (k = channels; k; k = k->next) {
|
|
GstColorBalanceChannel *tmp = k->data;
|
|
|
|
if (g_strrstr (tmp->label, proxy->label)) {
|
|
channel = tmp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_assert (channel);
|
|
|
|
gst_color_balance_set_value (balance, channel,
|
|
playsink->colorbalance_values[i]);
|
|
}
|
|
|
|
g_signal_handlers_unblock_by_func (balance,
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
|
|
gst_object_unref (balance);
|
|
}
|
|
|
|
/* make the element (bin) that contains the elements needed to perform
|
|
* video display.
|
|
*
|
|
* +------------------------------------------------------------+
|
|
* | vbin |
|
|
* | +-------+ +----------+ +----------+ +---------+ |
|
|
* | | queue | |colorspace| |videoscale| |videosink| |
|
|
* | +-sink src-sink src-sink src-sink | |
|
|
* | | +-------+ +----------+ +----------+ +---------+ |
|
|
* sink-+ |
|
|
* +------------------------------------------------------------+
|
|
*
|
|
*/
|
|
static GstPlayVideoChain *
|
|
gen_video_chain (GstPlaySink * playsink, gboolean raw, gboolean async)
|
|
{
|
|
GstPlayVideoChain *chain;
|
|
GstBin *bin;
|
|
GstPad *pad;
|
|
GstElement *head = NULL, *prev = NULL, *elem = NULL;
|
|
|
|
chain = g_new0 (GstPlayVideoChain, 1);
|
|
chain->chain.playsink = playsink;
|
|
chain->chain.raw = raw;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "making video chain %p", chain);
|
|
|
|
if (playsink->video_sink) {
|
|
GST_DEBUG_OBJECT (playsink, "trying configured videosink");
|
|
chain->sink = try_element (playsink, playsink->video_sink, FALSE);
|
|
} else {
|
|
/* only try fallback if no specific sink was chosen */
|
|
if (chain->sink == NULL) {
|
|
GST_DEBUG_OBJECT (playsink, "trying autovideosink");
|
|
elem = gst_element_factory_make ("autovideosink", "videosink");
|
|
chain->sink = try_element (playsink, elem, TRUE);
|
|
}
|
|
if (chain->sink == NULL) {
|
|
/* if default sink from config.h is different then try it too */
|
|
if (strcmp (DEFAULT_VIDEOSINK, "autovideosink")) {
|
|
GST_DEBUG_OBJECT (playsink, "trying " DEFAULT_VIDEOSINK);
|
|
elem = gst_element_factory_make (DEFAULT_VIDEOSINK, "videosink");
|
|
chain->sink = try_element (playsink, elem, TRUE);
|
|
}
|
|
}
|
|
if (chain->sink)
|
|
playsink->video_sink = gst_object_ref (chain->sink);
|
|
}
|
|
if (chain->sink == NULL)
|
|
goto no_sinks;
|
|
head = chain->sink;
|
|
|
|
/* if we can disable async behaviour of the sink, we can avoid adding a
|
|
* queue for the audio chain. */
|
|
elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "async",
|
|
G_TYPE_BOOLEAN);
|
|
if (elem) {
|
|
GST_DEBUG_OBJECT (playsink, "setting async property to %d on element %s",
|
|
async, GST_ELEMENT_NAME (elem));
|
|
g_object_set (elem, "async", async, NULL);
|
|
chain->async = async;
|
|
} else {
|
|
GST_DEBUG_OBJECT (playsink, "no async property on the sink");
|
|
chain->async = TRUE;
|
|
}
|
|
|
|
/* Make sure the aspect ratio is kept */
|
|
elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink,
|
|
"force-aspect-ratio", G_TYPE_BOOLEAN);
|
|
if (elem)
|
|
g_object_set (elem, "force-aspect-ratio", playsink->force_aspect_ratio,
|
|
NULL);
|
|
|
|
/* find ts-offset element */
|
|
gst_object_replace ((GstObject **) & chain->ts_offset, (GstObject *)
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "ts-offset",
|
|
G_TYPE_INT64));
|
|
|
|
/* create a bin to hold objects, as we create them we add them to this bin so
|
|
* that when something goes wrong we only need to unref the bin */
|
|
chain->chain.bin = gst_bin_new ("vbin");
|
|
bin = GST_BIN_CAST (chain->chain.bin);
|
|
gst_object_ref_sink (bin);
|
|
gst_bin_add (bin, chain->sink);
|
|
|
|
/* Get the VideoOverlay element */
|
|
{
|
|
GstVideoOverlay *overlay = NULL;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
gst_object_unref (playsink->overlay_element);
|
|
playsink->overlay_element =
|
|
GST_VIDEO_OVERLAY (gst_bin_get_by_interface (GST_BIN (chain->chain.bin),
|
|
GST_TYPE_VIDEO_OVERLAY));
|
|
if (playsink->overlay_element)
|
|
overlay = GST_VIDEO_OVERLAY (gst_object_ref (playsink->overlay_element));
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
if (overlay) {
|
|
if (playsink->overlay_handle_set)
|
|
gst_video_overlay_set_window_handle (overlay, playsink->overlay_handle);
|
|
if (playsink->overlay_handle_events_set)
|
|
gst_video_overlay_handle_events (overlay,
|
|
playsink->overlay_handle_events);
|
|
if (playsink->overlay_render_rectangle_set)
|
|
gst_video_overlay_set_render_rectangle (overlay,
|
|
playsink->overlay_x, playsink->overlay_y,
|
|
playsink->overlay_width, playsink->overlay_height);
|
|
gst_object_unref (overlay);
|
|
}
|
|
}
|
|
|
|
/* decouple decoder from sink, this improves playback quite a lot since the
|
|
* decoder can continue while the sink blocks for synchronisation. We don't
|
|
* need a lot of buffers as this consumes a lot of memory and we don't want
|
|
* too little because else we would be context switching too quickly. */
|
|
chain->queue = gst_element_factory_make ("queue", "vqueue");
|
|
if (chain->queue == NULL) {
|
|
post_missing_element_message (playsink, "queue");
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"queue"), ("video rendering might be suboptimal"));
|
|
head = chain->sink;
|
|
prev = NULL;
|
|
} else {
|
|
g_object_set (G_OBJECT (chain->queue), "max-size-buffers", 3,
|
|
"max-size-bytes", 0, "max-size-time", (gint64) 0, "silent", TRUE, NULL);
|
|
gst_bin_add (bin, chain->queue);
|
|
head = prev = chain->queue;
|
|
}
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->colorbalance_element) {
|
|
g_signal_handlers_disconnect_by_func (playsink->colorbalance_element,
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
gst_object_unref (playsink->colorbalance_element);
|
|
}
|
|
playsink->colorbalance_element = find_color_balance_element (chain->sink);
|
|
if (playsink->colorbalance_element) {
|
|
g_signal_connect (playsink->colorbalance_element, "value-changed",
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
}
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
if (!(playsink->flags & GST_PLAY_FLAG_NATIVE_VIDEO)
|
|
|| (!playsink->colorbalance_element
|
|
&& (playsink->flags & GST_PLAY_FLAG_SOFT_COLORBALANCE))) {
|
|
gboolean use_converters = !(playsink->flags & GST_PLAY_FLAG_NATIVE_VIDEO);
|
|
gboolean use_balance = !playsink->colorbalance_element
|
|
&& (playsink->flags & GST_PLAY_FLAG_SOFT_COLORBALANCE);
|
|
|
|
GST_DEBUG_OBJECT (playsink, "creating videoconverter");
|
|
chain->conv =
|
|
g_object_new (GST_TYPE_PLAY_SINK_VIDEO_CONVERT, "name", "vconv",
|
|
"use-converters", use_converters, "use-balance", use_balance, NULL);
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (use_balance && GST_PLAY_SINK_VIDEO_CONVERT (chain->conv)->balance)
|
|
playsink->colorbalance_element =
|
|
GST_COLOR_BALANCE (gst_object_ref (GST_PLAY_SINK_VIDEO_CONVERT
|
|
(chain->conv)->balance));
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
gst_bin_add (bin, chain->conv);
|
|
if (prev) {
|
|
if (!gst_element_link_pads_full (prev, "src", chain->conv, "sink",
|
|
GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
|
|
goto link_failed;
|
|
} else {
|
|
head = chain->conv;
|
|
}
|
|
prev = chain->conv;
|
|
}
|
|
|
|
update_colorbalance (playsink);
|
|
|
|
if (prev) {
|
|
GST_DEBUG_OBJECT (playsink, "linking to sink");
|
|
if (!gst_element_link_pads_full (prev, "src", chain->sink, NULL,
|
|
GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
|
|
goto link_failed;
|
|
}
|
|
|
|
pad = gst_element_get_static_pad (head, "sink");
|
|
chain->sinkpad = gst_ghost_pad_new ("sink", pad);
|
|
|
|
/* sending audio/video flushes break stream changes when the pipeline
|
|
* is paused and played again in 0.10 */
|
|
#if 0
|
|
gst_pad_set_event_function (chain->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_video_sink_event));
|
|
gst_pad_set_chain_function (chain->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_video_sink_chain));
|
|
#endif
|
|
|
|
gst_object_unref (pad);
|
|
gst_element_add_pad (chain->chain.bin, chain->sinkpad);
|
|
|
|
return chain;
|
|
|
|
/* ERRORS */
|
|
no_sinks:
|
|
{
|
|
if (!elem && !playsink->video_sink) {
|
|
post_missing_element_message (playsink, "autovideosink");
|
|
if (strcmp (DEFAULT_VIDEOSINK, "autovideosink")) {
|
|
post_missing_element_message (playsink, DEFAULT_VIDEOSINK);
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Both autovideosink and %s elements are missing."),
|
|
DEFAULT_VIDEOSINK), (NULL));
|
|
} else {
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("The autovideosink element is missing.")), (NULL));
|
|
}
|
|
} else {
|
|
if (playsink->video_sink) {
|
|
GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
|
|
(_("Configured videosink %s is not working."),
|
|
GST_ELEMENT_NAME (playsink->video_sink)), (NULL));
|
|
} else if (strcmp (DEFAULT_VIDEOSINK, "autovideosink")) {
|
|
GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
|
|
(_("Both autovideosink and %s elements are not working."),
|
|
DEFAULT_VIDEOSINK), (NULL));
|
|
} else {
|
|
GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
|
|
(_("The autovideosink element is not working.")), (NULL));
|
|
}
|
|
}
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
|
|
link_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (playsink, CORE, PAD,
|
|
(NULL), ("Failed to configure the video sink."));
|
|
/* checking sink made it READY */
|
|
gst_element_set_state (chain->sink, GST_STATE_NULL);
|
|
/* Remove chain from the bin to allow reuse later */
|
|
gst_bin_remove (bin, chain->sink);
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
setup_video_chain (GstPlaySink * playsink, gboolean raw, gboolean async)
|
|
{
|
|
GstElement *elem;
|
|
GstPlayVideoChain *chain;
|
|
GstStateChangeReturn ret;
|
|
|
|
chain = playsink->videochain;
|
|
|
|
chain->chain.raw = raw;
|
|
|
|
/* if the chain was active we don't do anything */
|
|
if (GST_PLAY_CHAIN (chain)->activated == TRUE)
|
|
return TRUE;
|
|
|
|
/* try to set the sink element to READY again */
|
|
ret = gst_element_set_state (chain->sink, GST_STATE_READY);
|
|
if (ret == GST_STATE_CHANGE_FAILURE)
|
|
return FALSE;
|
|
|
|
/* Get the VideoOverlay element */
|
|
{
|
|
GstVideoOverlay *overlay = NULL;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
gst_object_unref (playsink->overlay_element);
|
|
playsink->overlay_element =
|
|
GST_VIDEO_OVERLAY (gst_bin_get_by_interface (GST_BIN (chain->chain.bin),
|
|
GST_TYPE_VIDEO_OVERLAY));
|
|
if (playsink->overlay_element)
|
|
overlay = GST_VIDEO_OVERLAY (gst_object_ref (playsink->overlay_element));
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
if (overlay) {
|
|
if (playsink->overlay_handle_set)
|
|
gst_video_overlay_set_window_handle (overlay, playsink->overlay_handle);
|
|
if (playsink->overlay_handle_events_set)
|
|
gst_video_overlay_handle_events (overlay,
|
|
playsink->overlay_handle_events);
|
|
if (playsink->overlay_render_rectangle_set)
|
|
gst_video_overlay_set_render_rectangle (overlay,
|
|
playsink->overlay_x, playsink->overlay_y,
|
|
playsink->overlay_width, playsink->overlay_height);
|
|
gst_object_unref (overlay);
|
|
}
|
|
}
|
|
|
|
/* find ts-offset element */
|
|
gst_object_replace ((GstObject **) & chain->ts_offset, (GstObject *)
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "ts-offset",
|
|
G_TYPE_INT64));
|
|
|
|
/* if we can disable async behaviour of the sink, we can avoid adding a
|
|
* queue for the audio chain. */
|
|
elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "async",
|
|
G_TYPE_BOOLEAN);
|
|
if (elem) {
|
|
GST_DEBUG_OBJECT (playsink, "setting async property to %d on element %s",
|
|
async, GST_ELEMENT_NAME (elem));
|
|
g_object_set (elem, "async", async, NULL);
|
|
chain->async = async;
|
|
} else {
|
|
GST_DEBUG_OBJECT (playsink, "no async property on the sink");
|
|
chain->async = TRUE;
|
|
}
|
|
|
|
/* Make sure the aspect ratio is kept */
|
|
elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink,
|
|
"force-aspect-ratio", G_TYPE_BOOLEAN);
|
|
if (elem)
|
|
g_object_set (elem, "force-aspect-ratio", playsink->force_aspect_ratio,
|
|
NULL);
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->colorbalance_element) {
|
|
g_signal_handlers_disconnect_by_func (playsink->colorbalance_element,
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
gst_object_unref (playsink->colorbalance_element);
|
|
}
|
|
playsink->colorbalance_element = find_color_balance_element (chain->sink);
|
|
if (playsink->colorbalance_element) {
|
|
g_signal_connect (playsink->colorbalance_element, "value-changed",
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
}
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
if (chain->conv) {
|
|
gboolean use_balance = !playsink->colorbalance_element
|
|
&& (playsink->flags & GST_PLAY_FLAG_SOFT_COLORBALANCE);
|
|
|
|
g_object_set (chain->conv, "use-balance", use_balance, NULL);
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (use_balance && GST_PLAY_SINK_VIDEO_CONVERT (chain->conv)->balance)
|
|
playsink->colorbalance_element =
|
|
GST_COLOR_BALANCE (gst_object_ref (GST_PLAY_SINK_VIDEO_CONVERT
|
|
(chain->conv)->balance));
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
}
|
|
|
|
update_colorbalance (playsink);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_generate_update_newsegment_event (GstPad * pad, GstSegment * segment,
|
|
GstEvent ** event1)
|
|
{
|
|
GstEvent *event;
|
|
GstStructure *structure;
|
|
event = gst_event_new_segment (segment);
|
|
structure = gst_event_writable_structure (event);
|
|
gst_structure_id_set (structure,
|
|
_playsink_reset_segment_event_marker_id, G_TYPE_BOOLEAN, TRUE, NULL);
|
|
*event1 = event;
|
|
}
|
|
|
|
static gboolean
|
|
gst_play_sink_sink_event (GstPad * pad, GstObject * parent, GstEvent * event,
|
|
const gchar * sink_type,
|
|
gboolean * sink_ignore_wrong_state,
|
|
gboolean * sink_custom_flush_finished,
|
|
gboolean * sink_pending_flush, GstSegment * sink_segment)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK_CAST (gst_object_get_parent (parent));
|
|
gboolean ret;
|
|
const GstStructure *structure = gst_event_get_structure (event);
|
|
|
|
if (GST_EVENT_TYPE (event) == GST_EVENT_CUSTOM_DOWNSTREAM_OOB && structure) {
|
|
gchar *custom_flush;
|
|
gchar *custom_flush_finish;
|
|
|
|
custom_flush = g_strdup_printf ("playsink-custom-%s-flush", sink_type);
|
|
custom_flush_finish =
|
|
g_strdup_printf ("playsink-custom-%s-flush-finish", sink_type);
|
|
if (strcmp (gst_structure_get_name (structure), custom_flush) == 0) {
|
|
GST_DEBUG_OBJECT (pad,
|
|
"Custom %s flush event received, marking to flush %s", sink_type,
|
|
sink_type);
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
*sink_ignore_wrong_state = TRUE;
|
|
*sink_custom_flush_finished = FALSE;
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
} else if (strcmp (gst_structure_get_name (structure),
|
|
custom_flush_finish) == 0) {
|
|
GST_DEBUG_OBJECT (pad, "Custom %s flush finish event received",
|
|
sink_type);
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
*sink_pending_flush = TRUE;
|
|
*sink_custom_flush_finished = TRUE;
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
g_free (custom_flush);
|
|
g_free (custom_flush_finish);
|
|
} else if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
GST_DEBUG_OBJECT (pad, "Resetting %s segment because of flush-stop event",
|
|
sink_type);
|
|
gst_segment_init (sink_segment, GST_FORMAT_UNDEFINED);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (pad, "Forwarding event %" GST_PTR_FORMAT, event);
|
|
ret = gst_proxy_pad_event_default (pad, parent, gst_event_ref (event));
|
|
|
|
if (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) {
|
|
const GstSegment *segment;
|
|
|
|
gst_event_parse_segment (event, &segment);
|
|
GST_DEBUG_OBJECT (pad, "Segment event: %" GST_SEGMENT_FORMAT, segment);
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
if (sink_segment->format != segment->format) {
|
|
GST_DEBUG_OBJECT (pad, "%s segment format changed: %s -> %s",
|
|
sink_type,
|
|
gst_format_get_name (sink_segment->format),
|
|
gst_format_get_name (segment->format));
|
|
gst_segment_init (sink_segment, segment->format);
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (pad, "Old %s segment: %" GST_SEGMENT_FORMAT,
|
|
sink_type, sink_segment);
|
|
gst_segment_copy_into (&playsink->text_segment, sink_segment);
|
|
GST_DEBUG_OBJECT (pad, "New %s segment: %" GST_SEGMENT_FORMAT,
|
|
sink_type, sink_segment);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
gst_event_unref (event);
|
|
gst_object_unref (playsink);
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_play_sink_sink_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer,
|
|
const gchar * sink_type,
|
|
gboolean * sink_ignore_wrong_state,
|
|
gboolean * sink_custom_flush_finished,
|
|
gboolean * sink_pending_flush, GstSegment * sink_segment)
|
|
{
|
|
GstBin *tbin = GST_BIN_CAST (gst_pad_get_parent (pad));
|
|
GstPlaySink *playsink = GST_PLAY_SINK_CAST (gst_pad_get_parent (tbin));
|
|
GstFlowReturn ret;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
|
|
if (*sink_pending_flush) {
|
|
GstEvent *event;
|
|
GstStructure *structure;
|
|
|
|
*sink_pending_flush = FALSE;
|
|
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
/* make the bin drop all cached data.
|
|
* This event will be dropped on the src pad, if any. */
|
|
event = gst_event_new_flush_start ();
|
|
structure = gst_event_writable_structure (event);
|
|
gst_structure_id_set (structure,
|
|
_playsink_reset_segment_event_marker_id, G_TYPE_BOOLEAN, TRUE, NULL);
|
|
|
|
GST_DEBUG_OBJECT (pad,
|
|
"Pushing %s flush-start event with reset segment marker set: %"
|
|
GST_PTR_FORMAT, sink_type, event);
|
|
gst_pad_send_event (pad, event);
|
|
|
|
/* make queue drop all cached data.
|
|
* This event will be dropped on the src pad. */
|
|
event = gst_event_new_flush_stop (TRUE);
|
|
structure = gst_event_writable_structure (event);
|
|
gst_structure_id_set (structure,
|
|
_playsink_reset_segment_event_marker_id, G_TYPE_BOOLEAN, TRUE, NULL);
|
|
|
|
GST_DEBUG_OBJECT (pad,
|
|
"Pushing %s flush-stop event with reset segment marker set: %"
|
|
GST_PTR_FORMAT, sink_type, event);
|
|
gst_pad_send_event (pad, event);
|
|
|
|
/* Re-sync queue segment info after flush-stop.
|
|
* This event will be dropped on the src pad. */
|
|
if (sink_segment->format != GST_FORMAT_UNDEFINED) {
|
|
GstEvent *event1;
|
|
|
|
_generate_update_newsegment_event (pad, sink_segment, &event1);
|
|
GST_DEBUG_OBJECT (playsink,
|
|
"Pushing segment event with reset "
|
|
"segment marker set: %" GST_PTR_FORMAT, event1);
|
|
gst_pad_send_event (pad, event1);
|
|
}
|
|
} else {
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
ret = gst_proxy_pad_chain_default (pad, parent, buffer);
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
if (ret == GST_FLOW_FLUSHING && *sink_ignore_wrong_state) {
|
|
GST_DEBUG_OBJECT (pad, "Ignoring wrong state for %s during flush",
|
|
sink_type);
|
|
if (*sink_custom_flush_finished) {
|
|
GST_DEBUG_OBJECT (pad, "Custom flush finished, stop ignoring "
|
|
"wrong state for %s", sink_type);
|
|
*sink_ignore_wrong_state = FALSE;
|
|
}
|
|
|
|
ret = GST_FLOW_OK;
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
gst_object_unref (playsink);
|
|
gst_object_unref (tbin);
|
|
return ret;
|
|
}
|
|
|
|
/* sending audio/video flushes break stream changes when the pipeline
|
|
* is paused and played again in 0.10 */
|
|
#if 0
|
|
static gboolean
|
|
gst_play_sink_video_sink_event (GstPad * pad, GstEvent * event)
|
|
{
|
|
GstBin *tbin = GST_BIN_CAST (gst_pad_get_parent (pad));
|
|
GstPlaySink *playsink = GST_PLAY_SINK_CAST (gst_pad_get_parent (tbin));
|
|
gboolean ret;
|
|
|
|
ret = gst_play_sink_sink_event (pad, event, "video",
|
|
&playsink->video_ignore_wrong_state,
|
|
&playsink->video_custom_flush_finished,
|
|
&playsink->video_pending_flush, &playsink->video_segment);
|
|
|
|
gst_object_unref (playsink);
|
|
gst_object_unref (tbin);
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_play_sink_video_sink_chain (GstPad * pad, GstBuffer * buffer)
|
|
{
|
|
GstBin *tbin = GST_BIN_CAST (gst_pad_get_parent (pad));
|
|
GstPlaySink *playsink = GST_PLAY_SINK_CAST (gst_pad_get_parent (tbin));
|
|
gboolean ret;
|
|
|
|
ret = gst_play_sink_sink_chain (pad, buffer, "video",
|
|
&playsink->video_ignore_wrong_state,
|
|
&playsink->video_custom_flush_finished,
|
|
&playsink->video_pending_flush, &playsink->video_segment);
|
|
|
|
gst_object_unref (playsink);
|
|
gst_object_unref (tbin);
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_play_sink_audio_sink_event (GstPad * pad, GstEvent * event)
|
|
{
|
|
GstBin *tbin = GST_BIN_CAST (gst_pad_get_parent (pad));
|
|
GstPlaySink *playsink = GST_PLAY_SINK_CAST (gst_pad_get_parent (tbin));
|
|
gboolean ret;
|
|
|
|
ret = gst_play_sink_sink_event (pad, event, "audio",
|
|
&playsink->audio_ignore_wrong_state,
|
|
&playsink->audio_custom_flush_finished,
|
|
&playsink->audio_pending_flush, &playsink->audio_segment);
|
|
|
|
gst_object_unref (playsink);
|
|
gst_object_unref (tbin);
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_play_sink_audio_sink_chain (GstPad * pad, GstBuffer * buffer)
|
|
{
|
|
GstBin *tbin = GST_BIN_CAST (gst_pad_get_parent (pad));
|
|
GstPlaySink *playsink = GST_PLAY_SINK_CAST (gst_pad_get_parent (tbin));
|
|
gboolean ret;
|
|
|
|
ret = gst_play_sink_sink_chain (pad, buffer, "audio",
|
|
&playsink->audio_ignore_wrong_state,
|
|
&playsink->audio_custom_flush_finished,
|
|
&playsink->audio_pending_flush, &playsink->audio_segment);
|
|
|
|
gst_object_unref (playsink);
|
|
gst_object_unref (tbin);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static gboolean
|
|
gst_play_sink_text_sink_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK_CAST (gst_object_get_parent (parent));
|
|
gboolean ret;
|
|
|
|
ret = gst_play_sink_sink_event (pad, parent, event, "subtitle",
|
|
&playsink->text_ignore_wrong_state,
|
|
&playsink->text_custom_flush_finished,
|
|
&playsink->text_pending_flush, &playsink->text_segment);
|
|
|
|
gst_object_unref (playsink);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_play_sink_text_sink_chain (GstPad * pad, GstObject * parent,
|
|
GstBuffer * buffer)
|
|
{
|
|
gboolean ret;
|
|
GstPlaySink *playsink = GST_PLAY_SINK_CAST (gst_object_get_parent (parent));
|
|
|
|
ret = gst_play_sink_sink_chain (pad, parent, buffer, "subtitle",
|
|
&playsink->text_ignore_wrong_state,
|
|
&playsink->text_custom_flush_finished,
|
|
&playsink->text_pending_flush, &playsink->text_segment);
|
|
|
|
gst_object_unref (playsink);
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_play_sink_text_src_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event)
|
|
{
|
|
gboolean ret;
|
|
const GstStructure *structure;
|
|
|
|
GST_DEBUG_OBJECT (pad, "Got event %" GST_PTR_FORMAT, event);
|
|
|
|
structure = gst_event_get_structure (event);
|
|
|
|
if (structure &&
|
|
gst_structure_id_has_field (structure,
|
|
_playsink_reset_segment_event_marker_id)) {
|
|
/* the events marked with a reset segment marker
|
|
* are sent internally to reset the queue and
|
|
* must be dropped here */
|
|
GST_DEBUG_OBJECT (pad, "Dropping event with reset "
|
|
"segment marker set: %" GST_PTR_FORMAT, event);
|
|
ret = TRUE;
|
|
goto out;
|
|
}
|
|
|
|
ret = gst_proxy_pad_event_default (pad, parent, gst_event_ref (event));
|
|
|
|
out:
|
|
gst_event_unref (event);
|
|
return ret;
|
|
}
|
|
|
|
/* make an element for playback of video with subtitles embedded.
|
|
* Only used for *raw* video streams.
|
|
*
|
|
* +--------------------------------------------+
|
|
* | tbin |
|
|
* | +--------+ +-----------------+ |
|
|
* | | queue | | subtitleoverlay | |
|
|
* video--src sink---video_sink | |
|
|
* | +--------+ | src--src
|
|
* text------------------text_sink | |
|
|
* | +-----------------+ |
|
|
* +--------------------------------------------+
|
|
*
|
|
*/
|
|
static GstPlayTextChain *
|
|
gen_text_chain (GstPlaySink * playsink)
|
|
{
|
|
GstPlayTextChain *chain;
|
|
GstBin *bin;
|
|
GstElement *elem;
|
|
GstPad *videosinkpad, *textsinkpad, *srcpad;
|
|
|
|
chain = g_new0 (GstPlayTextChain, 1);
|
|
chain->chain.playsink = playsink;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "making text chain %p", chain);
|
|
|
|
chain->chain.bin = gst_bin_new ("tbin");
|
|
bin = GST_BIN_CAST (chain->chain.bin);
|
|
gst_object_ref_sink (bin);
|
|
|
|
videosinkpad = textsinkpad = srcpad = NULL;
|
|
|
|
/* first try to hook the text pad to the custom sink */
|
|
if (playsink->text_sink) {
|
|
GST_DEBUG_OBJECT (playsink, "trying configured textsink");
|
|
chain->sink = try_element (playsink, playsink->text_sink, FALSE);
|
|
if (chain->sink) {
|
|
elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "async",
|
|
G_TYPE_BOOLEAN);
|
|
if (elem) {
|
|
/* make sure the sparse subtitles don't participate in the preroll */
|
|
g_object_set (elem, "async", FALSE, NULL);
|
|
GST_DEBUG_OBJECT (playsink, "adding custom text sink");
|
|
gst_bin_add (bin, chain->sink);
|
|
/* NOTE streamsynchronizer needs streams decoupled */
|
|
/* make a little queue */
|
|
chain->queue = gst_element_factory_make ("queue", "subqueue");
|
|
if (chain->queue == NULL) {
|
|
post_missing_element_message (playsink, "queue");
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"queue"), ("rendering might be suboptimal"));
|
|
} else {
|
|
g_object_set (G_OBJECT (chain->queue), "max-size-buffers", 3,
|
|
"max-size-bytes", 0, "max-size-time", (gint64) GST_SECOND,
|
|
"silent", TRUE, NULL);
|
|
gst_bin_add (bin, chain->queue);
|
|
}
|
|
/* we have a custom sink, this will be our textsinkpad */
|
|
if (gst_element_link_pads_full (chain->queue, "src", chain->sink,
|
|
"sink", GST_PAD_LINK_CHECK_TEMPLATE_CAPS)) {
|
|
/* we're all fine now and we can add the sink to the chain */
|
|
GST_DEBUG_OBJECT (playsink, "using custom text sink");
|
|
textsinkpad = gst_element_get_static_pad (chain->queue, "sink");
|
|
} else {
|
|
GST_WARNING_OBJECT (playsink,
|
|
"can't find a sink pad on custom text sink");
|
|
gst_bin_remove (bin, chain->sink);
|
|
gst_bin_remove (bin, chain->queue);
|
|
chain->sink = NULL;
|
|
chain->queue = NULL;
|
|
}
|
|
/* try to set sync to true but it's no biggie when we can't */
|
|
if (chain->sink && (elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink,
|
|
"sync", G_TYPE_BOOLEAN)))
|
|
g_object_set (elem, "sync", TRUE, NULL);
|
|
|
|
if (!textsinkpad)
|
|
gst_bin_remove (bin, chain->sink);
|
|
} else {
|
|
GST_WARNING_OBJECT (playsink,
|
|
"can't find async property in custom text sink");
|
|
}
|
|
}
|
|
if (textsinkpad == NULL) {
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Custom text sink element is not usable.")),
|
|
("fallback to default subtitleoverlay"));
|
|
}
|
|
}
|
|
|
|
if (textsinkpad == NULL) {
|
|
if (!(playsink->flags & GST_PLAY_FLAG_NATIVE_VIDEO)) {
|
|
/* make a little queue */
|
|
chain->queue = gst_element_factory_make ("queue", "vqueue");
|
|
if (chain->queue == NULL) {
|
|
post_missing_element_message (playsink, "queue");
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"queue"), ("video rendering might be suboptimal"));
|
|
} else {
|
|
g_object_set (G_OBJECT (chain->queue), "max-size-buffers", 3,
|
|
"max-size-bytes", 0, "max-size-time", (gint64) 0,
|
|
"silent", TRUE, NULL);
|
|
gst_bin_add (bin, chain->queue);
|
|
videosinkpad = gst_element_get_static_pad (chain->queue, "sink");
|
|
}
|
|
|
|
chain->overlay =
|
|
gst_element_factory_make ("subtitleoverlay", "suboverlay");
|
|
if (chain->overlay == NULL) {
|
|
post_missing_element_message (playsink, "subtitleoverlay");
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"subtitleoverlay"), ("subtitle rendering disabled"));
|
|
} else {
|
|
GstElement *element;
|
|
|
|
gst_bin_add (bin, chain->overlay);
|
|
|
|
g_object_set (G_OBJECT (chain->overlay), "silent", FALSE, NULL);
|
|
if (playsink->font_desc) {
|
|
g_object_set (G_OBJECT (chain->overlay), "font-desc",
|
|
playsink->font_desc, NULL);
|
|
}
|
|
if (playsink->subtitle_encoding) {
|
|
g_object_set (G_OBJECT (chain->overlay), "subtitle-encoding",
|
|
playsink->subtitle_encoding, NULL);
|
|
}
|
|
|
|
gst_element_link_pads_full (chain->queue, "src", chain->overlay,
|
|
"video_sink", GST_PAD_LINK_CHECK_TEMPLATE_CAPS);
|
|
|
|
/* make another little queue to decouple streams */
|
|
element = gst_element_factory_make ("queue", "subqueue");
|
|
if (element == NULL) {
|
|
post_missing_element_message (playsink, "queue");
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"queue"), ("rendering might be suboptimal"));
|
|
} else {
|
|
g_object_set (G_OBJECT (element), "max-size-buffers", 3,
|
|
"max-size-bytes", 0, "max-size-time", (gint64) GST_SECOND,
|
|
"silent", TRUE, NULL);
|
|
gst_bin_add (bin, element);
|
|
if (gst_element_link_pads_full (element, "src", chain->overlay,
|
|
"subtitle_sink", GST_PAD_LINK_CHECK_TEMPLATE_CAPS)) {
|
|
textsinkpad = gst_element_get_static_pad (element, "sink");
|
|
srcpad = gst_element_get_static_pad (chain->overlay, "src");
|
|
} else {
|
|
gst_bin_remove (bin, chain->sink);
|
|
gst_bin_remove (bin, chain->overlay);
|
|
chain->sink = NULL;
|
|
chain->overlay = NULL;
|
|
gst_object_unref (videosinkpad);
|
|
videosinkpad = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (videosinkpad == NULL) {
|
|
/* if we still don't have a videosink, we don't have an overlay. the only
|
|
* thing we can do is insert an identity and ghost the src
|
|
* and sink pads. */
|
|
chain->identity = gst_element_factory_make ("identity", "tidentity");
|
|
if (chain->identity == NULL) {
|
|
post_missing_element_message (playsink, "identity");
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"identity"), (NULL));
|
|
} else {
|
|
g_object_set (chain->identity, "signal-handoffs", FALSE, NULL);
|
|
g_object_set (chain->identity, "silent", TRUE, NULL);
|
|
gst_bin_add (bin, chain->identity);
|
|
srcpad = gst_element_get_static_pad (chain->identity, "src");
|
|
videosinkpad = gst_element_get_static_pad (chain->identity, "sink");
|
|
}
|
|
}
|
|
|
|
/* expose the ghostpads */
|
|
if (videosinkpad) {
|
|
chain->videosinkpad = gst_ghost_pad_new ("sink", videosinkpad);
|
|
gst_object_unref (videosinkpad);
|
|
gst_element_add_pad (chain->chain.bin, chain->videosinkpad);
|
|
}
|
|
if (textsinkpad) {
|
|
chain->textsinkpad = gst_ghost_pad_new ("text_sink", textsinkpad);
|
|
gst_object_unref (textsinkpad);
|
|
|
|
gst_pad_set_event_function (chain->textsinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_text_sink_event));
|
|
gst_pad_set_chain_function (chain->textsinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_text_sink_chain));
|
|
|
|
gst_element_add_pad (chain->chain.bin, chain->textsinkpad);
|
|
}
|
|
if (srcpad) {
|
|
chain->srcpad = gst_ghost_pad_new ("src", srcpad);
|
|
gst_object_unref (srcpad);
|
|
|
|
gst_pad_set_event_function (chain->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_text_src_event));
|
|
|
|
gst_element_add_pad (chain->chain.bin, chain->srcpad);
|
|
}
|
|
|
|
return chain;
|
|
}
|
|
|
|
static void
|
|
notify_volume_cb (GObject * object, GParamSpec * pspec, GstPlaySink * playsink)
|
|
{
|
|
gdouble vol;
|
|
|
|
g_object_get (object, "volume", &vol, NULL);
|
|
playsink->volume = vol;
|
|
|
|
g_object_notify (G_OBJECT (playsink), "volume");
|
|
}
|
|
|
|
static void
|
|
notify_mute_cb (GObject * object, GParamSpec * pspec, GstPlaySink * playsink)
|
|
{
|
|
gboolean mute;
|
|
|
|
g_object_get (object, "mute", &mute, NULL);
|
|
playsink->mute = mute;
|
|
|
|
g_object_notify (G_OBJECT (playsink), "mute");
|
|
}
|
|
|
|
/* make the chain that contains the elements needed to perform
|
|
* audio playback.
|
|
*
|
|
* We add a tee as the first element so that we can link the visualisation chain
|
|
* to it when requested.
|
|
*
|
|
* +-------------------------------------------------------------+
|
|
* | abin |
|
|
* | +---------+ +----------+ +---------+ +---------+ |
|
|
* | |audioconv| |audioscale| | volume | |audiosink| |
|
|
* | +-srck src-sink src-sink src-sink | |
|
|
* | | +---------+ +----------+ +---------+ +---------+ |
|
|
* sink-+ |
|
|
* +-------------------------------------------------------------+
|
|
*/
|
|
static GstPlayAudioChain *
|
|
gen_audio_chain (GstPlaySink * playsink, gboolean raw)
|
|
{
|
|
GstPlayAudioChain *chain;
|
|
GstBin *bin;
|
|
gboolean have_volume;
|
|
GstPad *pad;
|
|
GstElement *head, *prev, *elem = NULL;
|
|
|
|
chain = g_new0 (GstPlayAudioChain, 1);
|
|
chain->chain.playsink = playsink;
|
|
chain->chain.raw = raw;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "making audio chain %p", chain);
|
|
|
|
if (playsink->audio_sink) {
|
|
GST_DEBUG_OBJECT (playsink, "trying configured audiosink %" GST_PTR_FORMAT,
|
|
playsink->audio_sink);
|
|
chain->sink = try_element (playsink, playsink->audio_sink, FALSE);
|
|
} else {
|
|
/* only try fallback if no specific sink was chosen */
|
|
if (chain->sink == NULL) {
|
|
GST_DEBUG_OBJECT (playsink, "trying autoaudiosink");
|
|
elem = gst_element_factory_make ("autoaudiosink", "audiosink");
|
|
chain->sink = try_element (playsink, elem, TRUE);
|
|
}
|
|
if (chain->sink == NULL) {
|
|
/* if default sink from config.h is different then try it too */
|
|
if (strcmp (DEFAULT_AUDIOSINK, "autoaudiosink")) {
|
|
GST_DEBUG_OBJECT (playsink, "trying " DEFAULT_AUDIOSINK);
|
|
elem = gst_element_factory_make (DEFAULT_AUDIOSINK, "audiosink");
|
|
chain->sink = try_element (playsink, elem, TRUE);
|
|
}
|
|
}
|
|
if (chain->sink)
|
|
playsink->audio_sink = gst_object_ref (chain->sink);
|
|
}
|
|
if (chain->sink == NULL)
|
|
goto no_sinks;
|
|
|
|
chain->chain.bin = gst_bin_new ("abin");
|
|
bin = GST_BIN_CAST (chain->chain.bin);
|
|
gst_object_ref_sink (bin);
|
|
gst_bin_add (bin, chain->sink);
|
|
|
|
/* we have to add a queue when we need to decouple for the video sink in
|
|
* visualisations and for streamsynchronizer */
|
|
GST_DEBUG_OBJECT (playsink, "adding audio queue");
|
|
chain->queue = gst_element_factory_make ("queue", "aqueue");
|
|
if (chain->queue == NULL) {
|
|
post_missing_element_message (playsink, "queue");
|
|
GST_ELEMENT_WARNING (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"queue"), ("audio playback and visualizations might not work"));
|
|
head = chain->sink;
|
|
prev = NULL;
|
|
} else {
|
|
g_object_set (chain->queue, "silent", TRUE, NULL);
|
|
gst_bin_add (bin, chain->queue);
|
|
prev = head = chain->queue;
|
|
}
|
|
|
|
/* find ts-offset element */
|
|
gst_object_replace ((GstObject **) & chain->ts_offset, (GstObject *)
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "ts-offset",
|
|
G_TYPE_INT64));
|
|
|
|
/* check if the sink, or something within the sink, has the volume property.
|
|
* If it does we don't need to add a volume element. */
|
|
elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "volume",
|
|
G_TYPE_DOUBLE);
|
|
if (elem) {
|
|
chain->volume = elem;
|
|
|
|
g_signal_connect (chain->volume, "notify::volume",
|
|
G_CALLBACK (notify_volume_cb), playsink);
|
|
|
|
GST_DEBUG_OBJECT (playsink, "the sink has a volume property");
|
|
have_volume = TRUE;
|
|
chain->sink_volume = TRUE;
|
|
/* if the sink also has a mute property we can use this as well. We'll only
|
|
* use the mute property if there is a volume property. We can simulate the
|
|
* mute with the volume otherwise. */
|
|
chain->mute =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "mute",
|
|
G_TYPE_BOOLEAN);
|
|
if (chain->mute) {
|
|
GST_DEBUG_OBJECT (playsink, "the sink has a mute property");
|
|
g_signal_connect (chain->mute, "notify::mute",
|
|
G_CALLBACK (notify_mute_cb), playsink);
|
|
}
|
|
/* use the sink to control the volume and mute */
|
|
if (playsink->volume_changed) {
|
|
g_object_set (G_OBJECT (chain->volume), "volume", playsink->volume, NULL);
|
|
playsink->volume_changed = FALSE;
|
|
}
|
|
if (playsink->mute_changed) {
|
|
if (chain->mute) {
|
|
g_object_set (chain->mute, "mute", playsink->mute, NULL);
|
|
} else {
|
|
if (playsink->mute)
|
|
g_object_set (chain->volume, "volume", (gdouble) 0.0, NULL);
|
|
}
|
|
playsink->mute_changed = FALSE;
|
|
}
|
|
} else {
|
|
/* no volume, we need to add a volume element when we can */
|
|
GST_DEBUG_OBJECT (playsink, "the sink has no volume property");
|
|
have_volume = FALSE;
|
|
chain->sink_volume = FALSE;
|
|
}
|
|
|
|
if (!(playsink->flags & GST_PLAY_FLAG_NATIVE_AUDIO) || (!have_volume
|
|
&& (playsink->flags & GST_PLAY_FLAG_SOFT_VOLUME))) {
|
|
gboolean use_converters = !(playsink->flags & GST_PLAY_FLAG_NATIVE_AUDIO);
|
|
gboolean use_volume =
|
|
!have_volume && (playsink->flags & GST_PLAY_FLAG_SOFT_VOLUME);
|
|
GST_DEBUG_OBJECT (playsink,
|
|
"creating audioconvert with use-converters %d, use-volume %d",
|
|
use_converters, use_volume);
|
|
chain->conv =
|
|
g_object_new (GST_TYPE_PLAY_SINK_AUDIO_CONVERT, "name", "aconv",
|
|
"use-converters", use_converters, "use-volume", use_volume, NULL);
|
|
gst_bin_add (bin, chain->conv);
|
|
if (prev) {
|
|
if (!gst_element_link_pads_full (prev, "src", chain->conv, "sink",
|
|
GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
|
|
goto link_failed;
|
|
} else {
|
|
head = chain->conv;
|
|
}
|
|
prev = chain->conv;
|
|
|
|
if (!have_volume && (playsink->flags & GST_PLAY_FLAG_SOFT_VOLUME)) {
|
|
GstPlaySinkAudioConvert *conv =
|
|
GST_PLAY_SINK_AUDIO_CONVERT_CAST (chain->conv);
|
|
|
|
if (conv->volume) {
|
|
chain->volume = conv->volume;
|
|
have_volume = TRUE;
|
|
|
|
g_signal_connect (chain->volume, "notify::volume",
|
|
G_CALLBACK (notify_volume_cb), playsink);
|
|
|
|
/* volume also has the mute property */
|
|
chain->mute = chain->volume;
|
|
g_signal_connect (chain->mute, "notify::mute",
|
|
G_CALLBACK (notify_mute_cb), playsink);
|
|
|
|
/* configure with the latest volume and mute */
|
|
g_object_set (G_OBJECT (chain->volume), "volume", playsink->volume,
|
|
NULL);
|
|
g_object_set (G_OBJECT (chain->mute), "mute", playsink->mute, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prev) {
|
|
/* we only have to link to the previous element if we have something in
|
|
* front of the sink */
|
|
GST_DEBUG_OBJECT (playsink, "linking to sink");
|
|
if (!gst_element_link_pads_full (prev, "src", chain->sink, NULL,
|
|
GST_PAD_LINK_CHECK_TEMPLATE_CAPS))
|
|
goto link_failed;
|
|
}
|
|
|
|
/* post a warning if we have no way to configure the volume */
|
|
if (!have_volume) {
|
|
GST_ELEMENT_WARNING (playsink, STREAM, NOT_IMPLEMENTED,
|
|
(_("No volume control found")), ("Volume/mute is not available"));
|
|
}
|
|
|
|
/* and ghost the sinkpad of the headmost element */
|
|
GST_DEBUG_OBJECT (playsink, "ghosting sink pad");
|
|
pad = gst_element_get_static_pad (head, "sink");
|
|
chain->sinkpad = gst_ghost_pad_new ("sink", pad);
|
|
|
|
/* sending audio/video flushes break stream changes when the pipeline
|
|
* is paused and played again in 0.10 */
|
|
#if 0
|
|
gst_pad_set_event_function (chain->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_audio_sink_event));
|
|
gst_pad_set_chain_function (chain->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_play_sink_audio_sink_chain));
|
|
#endif
|
|
|
|
gst_object_unref (pad);
|
|
gst_element_add_pad (chain->chain.bin, chain->sinkpad);
|
|
|
|
return chain;
|
|
|
|
/* ERRORS */
|
|
no_sinks:
|
|
{
|
|
if (!elem && !playsink->audio_sink) {
|
|
post_missing_element_message (playsink, "autoaudiosink");
|
|
if (strcmp (DEFAULT_AUDIOSINK, "autoaudiosink")) {
|
|
post_missing_element_message (playsink, DEFAULT_AUDIOSINK);
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Both autoaudiosink and %s elements are missing."),
|
|
DEFAULT_AUDIOSINK), (NULL));
|
|
} else {
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("The autoaudiosink element is missing.")), (NULL));
|
|
}
|
|
} else {
|
|
if (playsink->audio_sink) {
|
|
GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
|
|
(_("Configured audiosink %s is not working."),
|
|
GST_ELEMENT_NAME (playsink->audio_sink)), (NULL));
|
|
} else if (strcmp (DEFAULT_AUDIOSINK, "autoaudiosink")) {
|
|
GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
|
|
(_("Both autoaudiosink and %s elements are not working."),
|
|
DEFAULT_AUDIOSINK), (NULL));
|
|
} else {
|
|
GST_ELEMENT_ERROR (playsink, CORE, STATE_CHANGE,
|
|
(_("The autoaudiosink element is not working.")), (NULL));
|
|
}
|
|
}
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
link_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (playsink, CORE, PAD,
|
|
(NULL), ("Failed to configure the audio sink."));
|
|
/* checking sink made it READY */
|
|
gst_element_set_state (chain->sink, GST_STATE_NULL);
|
|
/* Remove chain from the bin to allow reuse later */
|
|
gst_bin_remove (bin, chain->sink);
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
setup_audio_chain (GstPlaySink * playsink, gboolean raw)
|
|
{
|
|
GstElement *elem;
|
|
GstPlayAudioChain *chain;
|
|
GstStateChangeReturn ret;
|
|
GstPlaySinkAudioConvert *conv;
|
|
|
|
chain = playsink->audiochain;
|
|
conv = GST_PLAY_SINK_AUDIO_CONVERT_CAST (chain->conv);
|
|
|
|
chain->chain.raw = raw;
|
|
|
|
/* if the chain was active we don't do anything */
|
|
if (GST_PLAY_CHAIN (chain)->activated == TRUE)
|
|
return TRUE;
|
|
|
|
/* try to set the sink element to READY again */
|
|
ret = gst_element_set_state (chain->sink, GST_STATE_READY);
|
|
if (ret == GST_STATE_CHANGE_FAILURE)
|
|
return FALSE;
|
|
|
|
/* find ts-offset element */
|
|
gst_object_replace ((GstObject **) & chain->ts_offset, (GstObject *)
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "ts-offset",
|
|
G_TYPE_INT64));
|
|
|
|
/* check if the sink, or something within the sink, has the volume property.
|
|
* If it does we don't need to add a volume element. */
|
|
elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "volume",
|
|
G_TYPE_DOUBLE);
|
|
if (elem) {
|
|
chain->volume = elem;
|
|
|
|
if (playsink->volume_changed) {
|
|
GST_DEBUG_OBJECT (playsink, "the sink has a volume property, setting %f",
|
|
playsink->volume);
|
|
/* use the sink to control the volume */
|
|
g_object_set (G_OBJECT (chain->volume), "volume", playsink->volume, NULL);
|
|
playsink->volume_changed = FALSE;
|
|
}
|
|
|
|
g_signal_connect (chain->volume, "notify::volume",
|
|
G_CALLBACK (notify_volume_cb), playsink);
|
|
/* if the sink also has a mute property we can use this as well. We'll only
|
|
* use the mute property if there is a volume property. We can simulate the
|
|
* mute with the volume otherwise. */
|
|
chain->mute =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink, "mute",
|
|
G_TYPE_BOOLEAN);
|
|
if (chain->mute) {
|
|
GST_DEBUG_OBJECT (playsink, "the sink has a mute property");
|
|
g_signal_connect (chain->mute, "notify::mute",
|
|
G_CALLBACK (notify_mute_cb), playsink);
|
|
}
|
|
|
|
g_object_set (chain->conv, "use-volume", FALSE, NULL);
|
|
} else if (conv) {
|
|
/* no volume, we need to add a volume element when we can */
|
|
g_object_set (chain->conv, "use-volume",
|
|
! !(playsink->flags & GST_PLAY_FLAG_SOFT_VOLUME), NULL);
|
|
GST_DEBUG_OBJECT (playsink, "the sink has no volume property");
|
|
|
|
/* Disconnect signals */
|
|
disconnect_chain (chain, playsink);
|
|
|
|
if (conv->volume && (playsink->flags & GST_PLAY_FLAG_SOFT_VOLUME)) {
|
|
chain->volume = conv->volume;
|
|
chain->mute = chain->volume;
|
|
|
|
g_signal_connect (chain->volume, "notify::volume",
|
|
G_CALLBACK (notify_volume_cb), playsink);
|
|
|
|
g_signal_connect (chain->mute, "notify::mute",
|
|
G_CALLBACK (notify_mute_cb), playsink);
|
|
|
|
/* configure with the latest volume and mute */
|
|
g_object_set (G_OBJECT (chain->volume), "volume", playsink->volume, NULL);
|
|
g_object_set (G_OBJECT (chain->mute), "mute", playsink->mute, NULL);
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (playsink, "reusing existing volume element");
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* +-------------------------------------------------------------------+
|
|
* | visbin |
|
|
* | +----------+ +------------+ +----------+ +-------+ |
|
|
* | | visqueue | | audioconv | | audiores | | vis | |
|
|
* | +-sink src-sink + samp src-sink src-sink src-+ |
|
|
* | | +----------+ +------------+ +----------+ +-------+ | |
|
|
* sink-+ +-src
|
|
* +-------------------------------------------------------------------+
|
|
*
|
|
*/
|
|
static GstPlayVisChain *
|
|
gen_vis_chain (GstPlaySink * playsink)
|
|
{
|
|
GstPlayVisChain *chain;
|
|
GstBin *bin;
|
|
gboolean res;
|
|
GstPad *pad;
|
|
GstElement *elem;
|
|
|
|
chain = g_new0 (GstPlayVisChain, 1);
|
|
chain->chain.playsink = playsink;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "making vis chain %p", chain);
|
|
|
|
chain->chain.bin = gst_bin_new ("visbin");
|
|
bin = GST_BIN_CAST (chain->chain.bin);
|
|
gst_object_ref_sink (bin);
|
|
|
|
/* we're queuing raw audio here, we can remove this queue when we can disable
|
|
* async behaviour in the video sink. */
|
|
chain->queue = gst_element_factory_make ("queue", "visqueue");
|
|
if (chain->queue == NULL)
|
|
goto no_queue;
|
|
g_object_set (chain->queue, "silent", TRUE, NULL);
|
|
gst_bin_add (bin, chain->queue);
|
|
|
|
chain->conv = gst_element_factory_make ("audioconvert", "aconv");
|
|
if (chain->conv == NULL)
|
|
goto no_audioconvert;
|
|
gst_bin_add (bin, chain->conv);
|
|
|
|
chain->resample = gst_element_factory_make ("audioresample", "aresample");
|
|
if (chain->resample == NULL)
|
|
goto no_audioresample;
|
|
gst_bin_add (bin, chain->resample);
|
|
|
|
/* this pad will be used for blocking the dataflow and switching the vis
|
|
* plugin */
|
|
chain->blockpad = gst_element_get_static_pad (chain->resample, "src");
|
|
|
|
if (playsink->visualisation) {
|
|
GST_DEBUG_OBJECT (playsink, "trying configure vis");
|
|
chain->vis = try_element (playsink, playsink->visualisation, FALSE);
|
|
}
|
|
if (chain->vis == NULL) {
|
|
GST_DEBUG_OBJECT (playsink, "trying goom");
|
|
elem = gst_element_factory_make ("goom", "vis");
|
|
chain->vis = try_element (playsink, elem, TRUE);
|
|
}
|
|
if (chain->vis == NULL)
|
|
goto no_goom;
|
|
|
|
gst_bin_add (bin, chain->vis);
|
|
|
|
res = gst_element_link_pads_full (chain->queue, "src", chain->conv, "sink",
|
|
GST_PAD_LINK_CHECK_NOTHING);
|
|
res &=
|
|
gst_element_link_pads_full (chain->conv, "src", chain->resample, "sink",
|
|
GST_PAD_LINK_CHECK_NOTHING);
|
|
res &=
|
|
gst_element_link_pads_full (chain->resample, "src", chain->vis, "sink",
|
|
GST_PAD_LINK_CHECK_NOTHING);
|
|
if (!res)
|
|
goto link_failed;
|
|
|
|
chain->vissinkpad = gst_element_get_static_pad (chain->vis, "sink");
|
|
chain->vissrcpad = gst_element_get_static_pad (chain->vis, "src");
|
|
|
|
pad = gst_element_get_static_pad (chain->queue, "sink");
|
|
chain->sinkpad = gst_ghost_pad_new ("sink", pad);
|
|
gst_object_unref (pad);
|
|
gst_element_add_pad (chain->chain.bin, chain->sinkpad);
|
|
|
|
chain->srcpad = gst_ghost_pad_new ("src", chain->vissrcpad);
|
|
gst_element_add_pad (chain->chain.bin, chain->srcpad);
|
|
|
|
return chain;
|
|
|
|
/* ERRORS */
|
|
no_queue:
|
|
{
|
|
post_missing_element_message (playsink, "queue");
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"queue"), (NULL));
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
no_audioconvert:
|
|
{
|
|
post_missing_element_message (playsink, "audioconvert");
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"audioconvert"), ("possibly a liboil version mismatch?"));
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
no_audioresample:
|
|
{
|
|
post_missing_element_message (playsink, "audioresample");
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"audioresample"), (NULL));
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
no_goom:
|
|
{
|
|
post_missing_element_message (playsink, "goom");
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"goom"), (NULL));
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
link_failed:
|
|
{
|
|
GST_ELEMENT_ERROR (playsink, CORE, PAD,
|
|
(NULL), ("Failed to configure the visualisation element."));
|
|
/* element made it to READY */
|
|
gst_element_set_state (chain->vis, GST_STATE_NULL);
|
|
free_chain ((GstPlayChain *) chain);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* this function is called when all the request pads are requested and when we
|
|
* have to construct the final pipeline. Based on the flags we construct the
|
|
* final output pipelines.
|
|
*/
|
|
static gboolean
|
|
gst_play_sink_do_reconfigure (GstPlaySink * playsink)
|
|
{
|
|
GstPlayFlags flags;
|
|
gboolean need_audio, need_video, need_deinterlace, need_vis, need_text;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "reconfiguring");
|
|
|
|
/* assume we need nothing */
|
|
need_audio = need_video = need_deinterlace = need_vis = need_text = FALSE;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
GST_OBJECT_LOCK (playsink);
|
|
/* get flags, there are protected with the object lock */
|
|
flags = playsink->flags;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
/* figure out which components we need */
|
|
if (flags & GST_PLAY_FLAG_TEXT && playsink->text_pad) {
|
|
/* we have subtitles and we are requested to show it */
|
|
need_text = TRUE;
|
|
}
|
|
|
|
if (((flags & GST_PLAY_FLAG_VIDEO)
|
|
|| (flags & GST_PLAY_FLAG_NATIVE_VIDEO)) && playsink->video_pad) {
|
|
/* we have video and we are requested to show it */
|
|
need_video = TRUE;
|
|
|
|
/* we only deinterlace if native video is not requested and
|
|
* we have raw video */
|
|
if ((flags & GST_PLAY_FLAG_DEINTERLACE)
|
|
&& !(flags & GST_PLAY_FLAG_NATIVE_VIDEO) && playsink->video_pad_raw)
|
|
need_deinterlace = TRUE;
|
|
}
|
|
|
|
if (playsink->audio_pad) {
|
|
if ((flags & GST_PLAY_FLAG_AUDIO) || (flags & GST_PLAY_FLAG_NATIVE_AUDIO)) {
|
|
need_audio = TRUE;
|
|
}
|
|
if (playsink->audio_pad_raw) {
|
|
/* only can do vis with raw uncompressed audio */
|
|
if (flags & GST_PLAY_FLAG_VIS && !need_video) {
|
|
/* also add video when we add visualisation */
|
|
need_video = TRUE;
|
|
need_vis = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* we have a text_pad and we need text rendering, in this case we need a
|
|
* video_pad to combine the video with the text or visualizations */
|
|
if (need_text && !need_video && !playsink->text_sink) {
|
|
if (playsink->video_pad) {
|
|
need_video = TRUE;
|
|
} else if (need_audio) {
|
|
GST_ELEMENT_WARNING (playsink, STREAM, FORMAT,
|
|
(_("Can't play a text file without video or visualizations.")),
|
|
("Have text pad but no video pad or visualizations"));
|
|
need_text = FALSE;
|
|
} else {
|
|
GST_ELEMENT_ERROR (playsink, STREAM, FORMAT,
|
|
(_("Can't play a text file without video or visualizations.")),
|
|
("Have text pad but no video pad or visualizations"));
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (playsink, "audio:%d, video:%d, vis:%d, text:%d", need_audio,
|
|
need_video, need_vis, need_text);
|
|
|
|
/* set up video pipeline */
|
|
if (need_video) {
|
|
gboolean raw, async;
|
|
|
|
/* we need a raw sink when we do vis or when we have a raw pad */
|
|
raw = need_vis ? TRUE : playsink->video_pad_raw;
|
|
/* we try to set the sink async=FALSE when we need vis, this way we can
|
|
* avoid a queue in the audio chain. */
|
|
async = !need_vis;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "adding video, raw %d",
|
|
playsink->video_pad_raw);
|
|
|
|
if (playsink->videochain) {
|
|
/* try to reactivate the chain */
|
|
if (!setup_video_chain (playsink, raw, async)) {
|
|
if (playsink->video_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->video_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->video_sinkpad_stream_synchronizer);
|
|
playsink->video_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->video_srcpad_stream_synchronizer);
|
|
playsink->video_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
|
|
add_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
|
|
|
|
/* Remove the sink from the bin to keep its state
|
|
* and unparent it to allow reuse */
|
|
if (playsink->videochain->sink)
|
|
gst_bin_remove (GST_BIN_CAST (playsink->videochain->chain.bin),
|
|
playsink->videochain->sink);
|
|
|
|
activate_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
|
|
free_chain ((GstPlayChain *) playsink->videochain);
|
|
playsink->videochain = NULL;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
gst_object_unref (playsink->overlay_element);
|
|
playsink->overlay_element = NULL;
|
|
|
|
if (playsink->colorbalance_element) {
|
|
g_signal_handlers_disconnect_by_func (playsink->colorbalance_element,
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
gst_object_unref (playsink->colorbalance_element);
|
|
}
|
|
playsink->colorbalance_element = NULL;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
}
|
|
}
|
|
|
|
if (!playsink->videochain)
|
|
playsink->videochain = gen_video_chain (playsink, raw, async);
|
|
if (!playsink->videochain)
|
|
goto no_chain;
|
|
|
|
if (!playsink->video_sinkpad_stream_synchronizer) {
|
|
GValue item = { 0, };
|
|
GstIterator *it;
|
|
|
|
playsink->video_sinkpad_stream_synchronizer =
|
|
gst_element_get_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer), "sink_%u");
|
|
it = gst_pad_iterate_internal_links
|
|
(playsink->video_sinkpad_stream_synchronizer);
|
|
g_assert (it);
|
|
gst_iterator_next (it, &item);
|
|
playsink->video_srcpad_stream_synchronizer = g_value_dup_object (&item);
|
|
g_value_unset (&item);
|
|
g_assert (playsink->video_srcpad_stream_synchronizer);
|
|
gst_iterator_free (it);
|
|
}
|
|
|
|
if (playsink->video_pad)
|
|
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->video_pad),
|
|
playsink->video_sinkpad_stream_synchronizer);
|
|
|
|
if (need_deinterlace) {
|
|
if (!playsink->videodeinterlacechain)
|
|
playsink->videodeinterlacechain =
|
|
gen_video_deinterlace_chain (playsink);
|
|
if (!playsink->videodeinterlacechain)
|
|
goto no_chain;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "adding video deinterlace chain");
|
|
|
|
GST_DEBUG_OBJECT (playsink, "setting up deinterlacing chain");
|
|
|
|
add_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), TRUE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), TRUE);
|
|
|
|
gst_pad_unlink (playsink->video_srcpad_stream_synchronizer,
|
|
playsink->videochain->sinkpad);
|
|
gst_pad_link_full (playsink->video_srcpad_stream_synchronizer,
|
|
playsink->videodeinterlacechain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
} else {
|
|
if (playsink->videodeinterlacechain) {
|
|
add_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), FALSE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain),
|
|
FALSE);
|
|
}
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (playsink, "adding video chain");
|
|
add_chain (GST_PLAY_CHAIN (playsink->videochain), TRUE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->videochain), TRUE);
|
|
/* if we are not part of vis or subtitles, set the ghostpad target */
|
|
if (!need_vis && !need_text && (!playsink->textchain
|
|
|| !playsink->text_pad)) {
|
|
GST_DEBUG_OBJECT (playsink, "ghosting video sinkpad");
|
|
gst_pad_unlink (playsink->video_srcpad_stream_synchronizer,
|
|
playsink->videochain->sinkpad);
|
|
if (playsink->videodeinterlacechain
|
|
&& playsink->videodeinterlacechain->srcpad)
|
|
gst_pad_unlink (playsink->videodeinterlacechain->srcpad,
|
|
playsink->videochain->sinkpad);
|
|
if (need_deinterlace)
|
|
gst_pad_link_full (playsink->videodeinterlacechain->srcpad,
|
|
playsink->videochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
else
|
|
gst_pad_link_full (playsink->video_srcpad_stream_synchronizer,
|
|
playsink->videochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
}
|
|
} else {
|
|
GST_DEBUG_OBJECT (playsink, "no video needed");
|
|
if (playsink->videochain) {
|
|
GST_DEBUG_OBJECT (playsink, "removing video chain");
|
|
if (playsink->vischain) {
|
|
GstPad *srcpad;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "unlinking vis chain");
|
|
|
|
/* also had visualisation, release the tee srcpad before we then
|
|
* unlink the video from it */
|
|
if (playsink->audio_tee_vissrc) {
|
|
gst_element_release_request_pad (playsink->audio_tee,
|
|
playsink->audio_tee_vissrc);
|
|
gst_object_unref (playsink->audio_tee_vissrc);
|
|
playsink->audio_tee_vissrc = NULL;
|
|
}
|
|
srcpad =
|
|
gst_element_get_static_pad (playsink->vischain->chain.bin, "src");
|
|
gst_pad_unlink (srcpad, playsink->videochain->sinkpad);
|
|
}
|
|
|
|
if (playsink->video_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->video_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->video_sinkpad_stream_synchronizer);
|
|
playsink->video_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->video_srcpad_stream_synchronizer);
|
|
playsink->video_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
|
|
add_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
|
|
if (playsink->videochain->ts_offset)
|
|
gst_object_unref (playsink->videochain->ts_offset);
|
|
playsink->videochain->ts_offset = NULL;
|
|
}
|
|
|
|
if (playsink->videodeinterlacechain) {
|
|
add_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), FALSE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), FALSE);
|
|
}
|
|
|
|
if (playsink->video_pad)
|
|
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->video_pad), NULL);
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
gst_object_unref (playsink->overlay_element);
|
|
playsink->overlay_element = NULL;
|
|
|
|
if (playsink->colorbalance_element) {
|
|
g_signal_handlers_disconnect_by_func (playsink->colorbalance_element,
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
gst_object_unref (playsink->colorbalance_element);
|
|
}
|
|
playsink->colorbalance_element = NULL;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
}
|
|
|
|
if (need_audio) {
|
|
gboolean raw;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "adding audio");
|
|
|
|
/* get a raw sink if we are asked for a raw pad */
|
|
raw = playsink->audio_pad_raw;
|
|
|
|
if (playsink->audiochain) {
|
|
/* try to reactivate the chain */
|
|
if (!setup_audio_chain (playsink, raw)) {
|
|
GST_DEBUG_OBJECT (playsink, "removing current audio chain");
|
|
if (playsink->audio_tee_asrc) {
|
|
gst_element_release_request_pad (playsink->audio_tee,
|
|
playsink->audio_tee_asrc);
|
|
gst_object_unref (playsink->audio_tee_asrc);
|
|
playsink->audio_tee_asrc = NULL;
|
|
}
|
|
|
|
if (playsink->audio_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->audio_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->audio_sinkpad_stream_synchronizer);
|
|
playsink->audio_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->audio_srcpad_stream_synchronizer);
|
|
playsink->audio_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
|
|
add_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
|
|
|
|
/* Remove the sink from the bin to keep its state
|
|
* and unparent it to allow reuse */
|
|
if (playsink->audiochain->sink)
|
|
gst_bin_remove (GST_BIN_CAST (playsink->audiochain->chain.bin),
|
|
playsink->audiochain->sink);
|
|
|
|
activate_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
|
|
disconnect_chain (playsink->audiochain, playsink);
|
|
playsink->audiochain->volume = NULL;
|
|
playsink->audiochain->mute = NULL;
|
|
if (playsink->audiochain->ts_offset)
|
|
gst_object_unref (playsink->audiochain->ts_offset);
|
|
playsink->audiochain->ts_offset = NULL;
|
|
free_chain ((GstPlayChain *) playsink->audiochain);
|
|
playsink->audiochain = NULL;
|
|
playsink->volume_changed = playsink->mute_changed = FALSE;
|
|
}
|
|
}
|
|
|
|
if (!playsink->audiochain) {
|
|
GST_DEBUG_OBJECT (playsink, "creating new audio chain");
|
|
playsink->audiochain = gen_audio_chain (playsink, raw);
|
|
}
|
|
|
|
if (!playsink->audio_sinkpad_stream_synchronizer) {
|
|
GValue item = { 0, };
|
|
GstIterator *it;
|
|
|
|
playsink->audio_sinkpad_stream_synchronizer =
|
|
gst_element_get_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer), "sink_%u");
|
|
it = gst_pad_iterate_internal_links
|
|
(playsink->audio_sinkpad_stream_synchronizer);
|
|
g_assert (it);
|
|
gst_iterator_next (it, &item);
|
|
playsink->audio_srcpad_stream_synchronizer = g_value_dup_object (&item);
|
|
g_value_unset (&item);
|
|
g_assert (playsink->audio_srcpad_stream_synchronizer);
|
|
gst_iterator_free (it);
|
|
}
|
|
|
|
if (playsink->audiochain) {
|
|
GST_DEBUG_OBJECT (playsink, "adding audio chain");
|
|
if (playsink->audio_tee_asrc == NULL) {
|
|
playsink->audio_tee_asrc =
|
|
gst_element_get_request_pad (playsink->audio_tee, "src_%u");
|
|
}
|
|
add_chain (GST_PLAY_CHAIN (playsink->audiochain), TRUE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->audiochain), TRUE);
|
|
gst_pad_link_full (playsink->audio_tee_asrc,
|
|
playsink->audio_sinkpad_stream_synchronizer,
|
|
GST_PAD_LINK_CHECK_NOTHING);
|
|
gst_pad_link_full (playsink->audio_srcpad_stream_synchronizer,
|
|
playsink->audiochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
}
|
|
} else {
|
|
GST_DEBUG_OBJECT (playsink, "no audio needed");
|
|
/* we have no audio or we are requested to not play audio */
|
|
if (playsink->audiochain) {
|
|
GST_DEBUG_OBJECT (playsink, "removing audio chain");
|
|
/* release the audio pad */
|
|
if (playsink->audio_tee_asrc) {
|
|
gst_element_release_request_pad (playsink->audio_tee,
|
|
playsink->audio_tee_asrc);
|
|
gst_object_unref (playsink->audio_tee_asrc);
|
|
playsink->audio_tee_asrc = NULL;
|
|
}
|
|
|
|
if (playsink->audio_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->audio_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->audio_sinkpad_stream_synchronizer);
|
|
playsink->audio_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->audio_srcpad_stream_synchronizer);
|
|
playsink->audio_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
|
|
if (playsink->audiochain->sink_volume) {
|
|
disconnect_chain (playsink->audiochain, playsink);
|
|
playsink->audiochain->volume = NULL;
|
|
playsink->audiochain->mute = NULL;
|
|
if (playsink->audiochain->ts_offset)
|
|
gst_object_unref (playsink->audiochain->ts_offset);
|
|
playsink->audiochain->ts_offset = NULL;
|
|
}
|
|
add_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
|
|
}
|
|
}
|
|
|
|
if (need_vis) {
|
|
GstPad *srcpad;
|
|
|
|
if (!playsink->vischain)
|
|
playsink->vischain = gen_vis_chain (playsink);
|
|
|
|
GST_DEBUG_OBJECT (playsink, "adding visualisation");
|
|
|
|
if (playsink->vischain) {
|
|
GST_DEBUG_OBJECT (playsink, "setting up vis chain");
|
|
srcpad =
|
|
gst_element_get_static_pad (playsink->vischain->chain.bin, "src");
|
|
add_chain (GST_PLAY_CHAIN (playsink->vischain), TRUE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->vischain), TRUE);
|
|
if (playsink->audio_tee_vissrc == NULL) {
|
|
playsink->audio_tee_vissrc =
|
|
gst_element_get_request_pad (playsink->audio_tee, "src_%u");
|
|
}
|
|
gst_pad_link_full (playsink->audio_tee_vissrc,
|
|
playsink->vischain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
gst_pad_link_full (srcpad, playsink->video_sinkpad_stream_synchronizer,
|
|
GST_PAD_LINK_CHECK_NOTHING);
|
|
gst_pad_link_full (playsink->video_srcpad_stream_synchronizer,
|
|
playsink->videochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
gst_object_unref (srcpad);
|
|
}
|
|
} else {
|
|
GST_DEBUG_OBJECT (playsink, "no vis needed");
|
|
if (playsink->vischain) {
|
|
if (playsink->audio_tee_vissrc) {
|
|
gst_element_release_request_pad (playsink->audio_tee,
|
|
playsink->audio_tee_vissrc);
|
|
gst_object_unref (playsink->audio_tee_vissrc);
|
|
playsink->audio_tee_vissrc = NULL;
|
|
}
|
|
GST_DEBUG_OBJECT (playsink, "removing vis chain");
|
|
add_chain (GST_PLAY_CHAIN (playsink->vischain), FALSE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->vischain), FALSE);
|
|
}
|
|
}
|
|
|
|
if (need_text) {
|
|
GST_DEBUG_OBJECT (playsink, "adding text");
|
|
if (!playsink->textchain) {
|
|
GST_DEBUG_OBJECT (playsink, "creating text chain");
|
|
playsink->textchain = gen_text_chain (playsink);
|
|
}
|
|
if (playsink->textchain) {
|
|
GstIterator *it;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "adding text chain");
|
|
if (playsink->textchain->overlay)
|
|
g_object_set (G_OBJECT (playsink->textchain->overlay), "silent", FALSE,
|
|
NULL);
|
|
add_chain (GST_PLAY_CHAIN (playsink->textchain), TRUE);
|
|
|
|
if (!playsink->text_sinkpad_stream_synchronizer) {
|
|
GValue item = { 0, };
|
|
|
|
playsink->text_sinkpad_stream_synchronizer =
|
|
gst_element_get_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer), "sink_%u");
|
|
it = gst_pad_iterate_internal_links
|
|
(playsink->text_sinkpad_stream_synchronizer);
|
|
g_assert (it);
|
|
gst_iterator_next (it, &item);
|
|
playsink->text_srcpad_stream_synchronizer = g_value_dup_object (&item);
|
|
g_value_unset (&item);
|
|
g_assert (playsink->text_srcpad_stream_synchronizer);
|
|
gst_iterator_free (it);
|
|
|
|
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->text_pad),
|
|
playsink->text_sinkpad_stream_synchronizer);
|
|
gst_pad_link_full (playsink->text_srcpad_stream_synchronizer,
|
|
playsink->textchain->textsinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
}
|
|
|
|
if (need_vis || need_video) {
|
|
if (need_vis) {
|
|
GstPad *srcpad;
|
|
|
|
srcpad =
|
|
gst_element_get_static_pad (playsink->vischain->chain.bin, "src");
|
|
gst_pad_unlink (srcpad, playsink->videochain->sinkpad);
|
|
gst_pad_link_full (srcpad, playsink->textchain->videosinkpad,
|
|
GST_PAD_LINK_CHECK_NOTHING);
|
|
gst_object_unref (srcpad);
|
|
} else {
|
|
if (need_deinterlace)
|
|
gst_pad_link_full (playsink->videodeinterlacechain->srcpad,
|
|
playsink->textchain->videosinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
else
|
|
gst_pad_link_full (playsink->video_srcpad_stream_synchronizer,
|
|
playsink->textchain->videosinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
}
|
|
gst_pad_link_full (playsink->textchain->srcpad,
|
|
playsink->videochain->sinkpad, GST_PAD_LINK_CHECK_NOTHING);
|
|
}
|
|
|
|
activate_chain (GST_PLAY_CHAIN (playsink->textchain), TRUE);
|
|
}
|
|
} else {
|
|
GST_DEBUG_OBJECT (playsink, "no text needed");
|
|
/* we have no subtitles/text or we are requested to not show them */
|
|
|
|
if (playsink->text_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->text_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->text_sinkpad_stream_synchronizer);
|
|
playsink->text_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->text_srcpad_stream_synchronizer);
|
|
playsink->text_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
|
|
if (playsink->textchain) {
|
|
if (playsink->text_pad == NULL) {
|
|
/* no text pad, remove the chain entirely */
|
|
GST_DEBUG_OBJECT (playsink, "removing text chain");
|
|
add_chain (GST_PLAY_CHAIN (playsink->textchain), FALSE);
|
|
activate_chain (GST_PLAY_CHAIN (playsink->textchain), FALSE);
|
|
} else {
|
|
/* we have a chain and a textpad, turn the subtitles off */
|
|
GST_DEBUG_OBJECT (playsink, "turning off the text");
|
|
if (playsink->textchain->overlay)
|
|
g_object_set (G_OBJECT (playsink->textchain->overlay), "silent", TRUE,
|
|
NULL);
|
|
}
|
|
}
|
|
if (!need_video && playsink->video_pad) {
|
|
if (playsink->video_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->video_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->video_sinkpad_stream_synchronizer);
|
|
playsink->video_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->video_srcpad_stream_synchronizer);
|
|
playsink->video_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
|
|
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->video_pad), NULL);
|
|
}
|
|
|
|
if (playsink->text_pad && !playsink->textchain)
|
|
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (playsink->text_pad), NULL);
|
|
}
|
|
update_av_offset (playsink);
|
|
do_async_done (playsink);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return TRUE;
|
|
|
|
/* ERRORS */
|
|
no_chain:
|
|
{
|
|
/* gen_ chain already posted error */
|
|
GST_DEBUG_OBJECT (playsink, "failed to setup chain");
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_play_sink_set_flags:
|
|
* @playsink: a #GstPlaySink
|
|
* @flags: #GstPlayFlags
|
|
*
|
|
* Configure @flags on @playsink. The flags control the behaviour of @playsink
|
|
* when constructing the sink pipelins.
|
|
*
|
|
* Returns: TRUE if the flags could be configured.
|
|
*/
|
|
gboolean
|
|
gst_play_sink_set_flags (GstPlaySink * playsink, GstPlayFlags flags)
|
|
{
|
|
g_return_val_if_fail (GST_IS_PLAY_SINK (playsink), FALSE);
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
playsink->flags = flags;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_play_sink_get_flags:
|
|
* @playsink: a #GstPlaySink
|
|
*
|
|
* Get the flags of @playsink. That flags control the behaviour of the sink when
|
|
* it constructs the sink pipelines.
|
|
*
|
|
* Returns: the currently configured #GstPlayFlags.
|
|
*/
|
|
GstPlayFlags
|
|
gst_play_sink_get_flags (GstPlaySink * playsink)
|
|
{
|
|
GstPlayFlags res;
|
|
|
|
g_return_val_if_fail (GST_IS_PLAY_SINK (playsink), 0);
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
res = playsink->flags;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
return res;
|
|
}
|
|
|
|
void
|
|
gst_play_sink_set_font_desc (GstPlaySink * playsink, const gchar * desc)
|
|
{
|
|
GstPlayTextChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
chain = (GstPlayTextChain *) playsink->textchain;
|
|
g_free (playsink->font_desc);
|
|
playsink->font_desc = g_strdup (desc);
|
|
if (chain && chain->overlay) {
|
|
g_object_set (chain->overlay, "font-desc", desc, NULL);
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
gchar *
|
|
gst_play_sink_get_font_desc (GstPlaySink * playsink)
|
|
{
|
|
gchar *result = NULL;
|
|
GstPlayTextChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
chain = (GstPlayTextChain *) playsink->textchain;
|
|
if (chain && chain->overlay) {
|
|
g_object_get (chain->overlay, "font-desc", &result, NULL);
|
|
playsink->font_desc = g_strdup (result);
|
|
} else {
|
|
result = g_strdup (playsink->font_desc);
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
gst_play_sink_set_subtitle_encoding (GstPlaySink * playsink,
|
|
const gchar * encoding)
|
|
{
|
|
GstPlayTextChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
chain = (GstPlayTextChain *) playsink->textchain;
|
|
g_free (playsink->subtitle_encoding);
|
|
playsink->subtitle_encoding = g_strdup (encoding);
|
|
if (chain && chain->overlay) {
|
|
g_object_set (chain->overlay, "subtitle-encoding", encoding, NULL);
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
gchar *
|
|
gst_play_sink_get_subtitle_encoding (GstPlaySink * playsink)
|
|
{
|
|
gchar *result = NULL;
|
|
GstPlayTextChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
chain = (GstPlayTextChain *) playsink->textchain;
|
|
if (chain && chain->overlay) {
|
|
g_object_get (chain->overlay, "subtitle-encoding", &result, NULL);
|
|
playsink->subtitle_encoding = g_strdup (result);
|
|
} else {
|
|
result = g_strdup (playsink->subtitle_encoding);
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return result;
|
|
}
|
|
|
|
static void
|
|
update_av_offset (GstPlaySink * playsink)
|
|
{
|
|
gint64 av_offset;
|
|
GstPlayAudioChain *achain;
|
|
GstPlayVideoChain *vchain;
|
|
|
|
av_offset = playsink->av_offset;
|
|
achain = (GstPlayAudioChain *) playsink->audiochain;
|
|
vchain = (GstPlayVideoChain *) playsink->videochain;
|
|
|
|
if (achain && vchain && achain->ts_offset && vchain->ts_offset) {
|
|
g_object_set (achain->ts_offset,
|
|
"ts-offset", MAX (G_GINT64_CONSTANT (0), -av_offset), NULL);
|
|
g_object_set (vchain->ts_offset,
|
|
"ts-offset", MAX (G_GINT64_CONSTANT (0), av_offset), NULL);
|
|
} else {
|
|
GST_LOG_OBJECT (playsink, "no ts_offset elements");
|
|
}
|
|
}
|
|
|
|
void
|
|
gst_play_sink_set_av_offset (GstPlaySink * playsink, gint64 av_offset)
|
|
{
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
playsink->av_offset = av_offset;
|
|
update_av_offset (playsink);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
}
|
|
|
|
gint64
|
|
gst_play_sink_get_av_offset (GstPlaySink * playsink)
|
|
{
|
|
gint64 result;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
result = playsink->av_offset;
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_play_sink_get_last_sample:
|
|
* @playsink: a #GstPlaySink
|
|
*
|
|
* Get the last displayed sample from @playsink. This sample is in the native
|
|
* format of the sink element, the caps in the result sample contain the format
|
|
* of the frame data.
|
|
*
|
|
* Returns: a #GstSample with the frame data or %NULL when no video frame is
|
|
* available.
|
|
*/
|
|
GstSample *
|
|
gst_play_sink_get_last_sample (GstPlaySink * playsink)
|
|
{
|
|
GstSample *result = NULL;
|
|
GstPlayVideoChain *chain;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
GST_DEBUG_OBJECT (playsink, "taking last sample");
|
|
/* get the video chain if we can */
|
|
if ((chain = (GstPlayVideoChain *) playsink->videochain)) {
|
|
GST_DEBUG_OBJECT (playsink, "found video chain");
|
|
/* see if the chain is active */
|
|
if (chain->chain.activated && chain->sink) {
|
|
GstElement *elem;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "video chain active and has a sink");
|
|
|
|
/* find and get the last-buffer property now */
|
|
if ((elem =
|
|
gst_play_sink_find_property (playsink, chain->sink,
|
|
"last-sample", GST_TYPE_SAMPLE))) {
|
|
GST_DEBUG_OBJECT (playsink, "getting last-sample property");
|
|
g_object_get (elem, "last-sample", &result, NULL);
|
|
gst_object_unref (elem);
|
|
}
|
|
}
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_play_sink_convert_sample:
|
|
* @playsink: a #GstPlaySink
|
|
* @caps: a #GstCaps
|
|
*
|
|
* Get the last displayed frame from @playsink. If caps is %NULL, the video will
|
|
* be in the native format of the sink element and the caps on the buffer
|
|
* describe the format of the frame. If @caps is not %NULL, the video
|
|
* frame will be converted to the format of the caps.
|
|
*
|
|
* Returns: a #GstBuffer with the frame data or %NULL when no video frame is
|
|
* available or when the conversion failed.
|
|
*/
|
|
GstSample *
|
|
gst_play_sink_convert_sample (GstPlaySink * playsink, GstCaps * caps)
|
|
{
|
|
GstSample *result;
|
|
GError *err = NULL;
|
|
|
|
result = gst_play_sink_get_last_sample (playsink);
|
|
if (result != NULL && caps != NULL) {
|
|
GstSample *temp;
|
|
|
|
temp = gst_video_convert_sample (result, caps, 25 * GST_SECOND, &err);
|
|
if (temp == NULL && err)
|
|
goto error;
|
|
|
|
gst_sample_unref (result);
|
|
result = temp;
|
|
}
|
|
return result;
|
|
|
|
/* ERRORS */
|
|
error:
|
|
{
|
|
/* I'm really uncertain whether we should make playsink post an error
|
|
* on the bus or not. It's not like it's a critical issue regarding
|
|
* playsink behaviour. */
|
|
GST_ERROR ("Error converting frame: %s", err->message);
|
|
gst_sample_unref (result);
|
|
g_error_free (err);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
is_raw_structure (GstStructure * s)
|
|
{
|
|
const gchar *name;
|
|
|
|
name = gst_structure_get_name (s);
|
|
|
|
if (g_str_equal (name, "video/x-raw") || g_str_equal (name, "audio/x-raw"))
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
is_raw_pad (GstPad * pad)
|
|
{
|
|
GstPad *peer = gst_pad_get_peer (pad);
|
|
GstCaps *caps;
|
|
gboolean raw = TRUE;
|
|
|
|
if (!peer)
|
|
return raw;
|
|
|
|
caps = gst_pad_get_current_caps (peer);
|
|
if (!caps) {
|
|
guint i, n;
|
|
|
|
caps = gst_pad_query_caps (peer, NULL);
|
|
|
|
n = gst_caps_get_size (caps);
|
|
for (i = 0; i < n; i++) {
|
|
gboolean r = is_raw_structure (gst_caps_get_structure (caps, i));
|
|
|
|
if (i == 0) {
|
|
raw = r;
|
|
} else if (raw != r) {
|
|
GST_ERROR_OBJECT (pad,
|
|
"Caps contains raw and non-raw structures: %" GST_PTR_FORMAT, caps);
|
|
raw = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
raw = is_raw_structure (gst_caps_get_structure (caps, 0));
|
|
}
|
|
gst_caps_unref (caps);
|
|
gst_object_unref (peer);
|
|
|
|
return raw;
|
|
}
|
|
|
|
static GstPadProbeReturn
|
|
sinkpad_blocked_cb (GstPad * blockedpad, GstPadProbeInfo * info,
|
|
gpointer user_data);
|
|
|
|
static void
|
|
video_set_blocked (GstPlaySink * playsink, gboolean blocked)
|
|
{
|
|
if (playsink->video_pad) {
|
|
GstPad *opad =
|
|
GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD
|
|
(playsink->video_pad)));
|
|
if (blocked && playsink->video_block_id == 0) {
|
|
playsink->video_block_id =
|
|
gst_pad_add_probe (opad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
|
|
sinkpad_blocked_cb, playsink, NULL);
|
|
} else if (!blocked && playsink->video_block_id) {
|
|
gst_pad_remove_probe (opad, playsink->video_block_id);
|
|
PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_VIDEO_RAW);
|
|
PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_VIDEO);
|
|
playsink->video_block_id = 0;
|
|
playsink->video_pad_blocked = FALSE;
|
|
}
|
|
gst_object_unref (opad);
|
|
}
|
|
}
|
|
|
|
static void
|
|
audio_set_blocked (GstPlaySink * playsink, gboolean blocked)
|
|
{
|
|
if (playsink->audio_pad) {
|
|
GstPad *opad =
|
|
GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD
|
|
(playsink->audio_pad)));
|
|
if (blocked && playsink->audio_block_id == 0) {
|
|
playsink->audio_block_id =
|
|
gst_pad_add_probe (opad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
|
|
sinkpad_blocked_cb, playsink, NULL);
|
|
} else if (!blocked && playsink->audio_block_id) {
|
|
gst_pad_remove_probe (opad, playsink->audio_block_id);
|
|
PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_AUDIO_RAW);
|
|
PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_AUDIO);
|
|
playsink->audio_block_id = 0;
|
|
playsink->audio_pad_blocked = FALSE;
|
|
}
|
|
gst_object_unref (opad);
|
|
}
|
|
}
|
|
|
|
static void
|
|
text_set_blocked (GstPlaySink * playsink, gboolean blocked)
|
|
{
|
|
if (playsink->text_pad) {
|
|
GstPad *opad =
|
|
GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD
|
|
(playsink->text_pad)));
|
|
if (blocked && playsink->text_block_id == 0) {
|
|
playsink->text_block_id =
|
|
gst_pad_add_probe (opad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
|
|
sinkpad_blocked_cb, playsink, NULL);
|
|
} else if (!blocked && playsink->text_block_id) {
|
|
gst_pad_remove_probe (opad, playsink->text_block_id);
|
|
PENDING_FLAG_UNSET (playsink, GST_PLAY_SINK_TYPE_TEXT);
|
|
playsink->text_block_id = 0;
|
|
playsink->text_pad_blocked = FALSE;
|
|
}
|
|
gst_object_unref (opad);
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
gst_play_sink_reconfigure (GstPlaySink * playsink)
|
|
{
|
|
GST_LOG_OBJECT (playsink, "Triggering reconfiguration");
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
video_set_blocked (playsink, TRUE);
|
|
audio_set_blocked (playsink, TRUE);
|
|
text_set_blocked (playsink, TRUE);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static GstPadProbeReturn
|
|
sinkpad_blocked_cb (GstPad * blockedpad, GstPadProbeInfo * info,
|
|
gpointer user_data)
|
|
{
|
|
GstPlaySink *playsink = (GstPlaySink *) user_data;
|
|
GstPad *pad;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
|
|
pad = GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD (blockedpad)));
|
|
if (pad == playsink->video_pad) {
|
|
playsink->video_pad_blocked = TRUE;
|
|
GST_DEBUG_OBJECT (pad, "Video pad blocked");
|
|
} else if (pad == playsink->audio_pad) {
|
|
playsink->audio_pad_blocked = TRUE;
|
|
GST_DEBUG_OBJECT (pad, "Audio pad blocked");
|
|
} else if (pad == playsink->text_pad) {
|
|
playsink->text_pad_blocked = TRUE;
|
|
GST_DEBUG_OBJECT (pad, "Text pad blocked");
|
|
}
|
|
|
|
/* We reconfigure when for ALL streams:
|
|
* * there isn't a pad
|
|
* * OR the pad is blocked
|
|
* * OR there are no pending blocks on that pad
|
|
*/
|
|
|
|
if ((!playsink->video_pad || playsink->video_pad_blocked
|
|
|| !PENDING_VIDEO_BLOCK (playsink)) && (!playsink->audio_pad
|
|
|| playsink->audio_pad_blocked || !PENDING_AUDIO_BLOCK (playsink))
|
|
&& (!playsink->text_pad || playsink->text_pad_blocked
|
|
|| !PENDING_TEXT_BLOCK (playsink))) {
|
|
GST_DEBUG_OBJECT (playsink, "All pads blocked -- reconfiguring");
|
|
|
|
if (playsink->video_pad) {
|
|
playsink->video_pad_raw = is_raw_pad (playsink->video_pad);
|
|
GST_DEBUG_OBJECT (playsink, "Video pad is raw: %d",
|
|
playsink->video_pad_raw);
|
|
}
|
|
|
|
if (playsink->audio_pad) {
|
|
playsink->audio_pad_raw = is_raw_pad (playsink->audio_pad);
|
|
GST_DEBUG_OBJECT (playsink, "Audio pad is raw: %d",
|
|
playsink->audio_pad_raw);
|
|
}
|
|
|
|
gst_play_sink_do_reconfigure (playsink);
|
|
|
|
video_set_blocked (playsink, FALSE);
|
|
audio_set_blocked (playsink, FALSE);
|
|
text_set_blocked (playsink, FALSE);
|
|
}
|
|
|
|
gst_object_unref (pad);
|
|
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return GST_PAD_PROBE_OK;
|
|
}
|
|
|
|
static void
|
|
caps_notify_cb (GstPad * pad, GParamSpec * unused, GstPlaySink * playsink)
|
|
{
|
|
gboolean reconfigure = FALSE;
|
|
GstCaps *caps;
|
|
gboolean raw;
|
|
|
|
g_object_get (pad, "caps", &caps, NULL);
|
|
if (!caps)
|
|
return;
|
|
|
|
if (pad == playsink->audio_pad) {
|
|
raw = is_raw_pad (pad);
|
|
reconfigure = (! !playsink->audio_pad_raw != ! !raw)
|
|
&& playsink->audiochain;
|
|
GST_DEBUG_OBJECT (pad,
|
|
"Audio caps changed: raw %d reconfigure %d caps %" GST_PTR_FORMAT, raw,
|
|
reconfigure, caps);
|
|
} else if (pad == playsink->video_pad) {
|
|
raw = is_raw_pad (pad);
|
|
reconfigure = (! !playsink->video_pad_raw != ! !raw)
|
|
&& playsink->videochain;
|
|
GST_DEBUG_OBJECT (pad,
|
|
"Video caps changed: raw %d reconfigure %d caps %" GST_PTR_FORMAT, raw,
|
|
reconfigure, caps);
|
|
}
|
|
|
|
gst_caps_unref (caps);
|
|
|
|
if (reconfigure)
|
|
gst_play_sink_reconfigure (playsink);
|
|
}
|
|
|
|
void
|
|
gst_play_sink_refresh_pad (GstPlaySink * playsink, GstPad * pad,
|
|
GstPlaySinkType type)
|
|
{
|
|
gulong *block_id = NULL;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "refresh pad %" GST_PTR_FORMAT, pad);
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
if (pad == playsink->video_pad) {
|
|
if (type != GST_PLAY_SINK_TYPE_VIDEO_RAW &&
|
|
type != GST_PLAY_SINK_TYPE_VIDEO)
|
|
goto wrong_type;
|
|
block_id = &playsink->video_block_id;
|
|
} else if (pad == playsink->audio_pad) {
|
|
if (type != GST_PLAY_SINK_TYPE_AUDIO_RAW &&
|
|
type != GST_PLAY_SINK_TYPE_AUDIO)
|
|
goto wrong_type;
|
|
block_id = &playsink->audio_block_id;
|
|
} else if (pad == playsink->text_pad) {
|
|
if (type != GST_PLAY_SINK_TYPE_TEXT)
|
|
goto wrong_type;
|
|
block_id = &playsink->text_block_id;
|
|
}
|
|
|
|
if (type != GST_PLAY_SINK_TYPE_FLUSHING && (block_id && *block_id == 0)) {
|
|
GstPad *blockpad =
|
|
GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD (pad)));
|
|
|
|
*block_id =
|
|
gst_pad_add_probe (blockpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
|
|
sinkpad_blocked_cb, playsink, NULL);
|
|
PENDING_FLAG_SET (playsink, type);
|
|
gst_object_unref (blockpad);
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
return;
|
|
|
|
/* ERRORS */
|
|
wrong_type:
|
|
{
|
|
GST_WARNING_OBJECT (playsink, "wrong type %u for pad %" GST_PTR_FORMAT,
|
|
type, pad);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_play_sink_request_pad
|
|
* @playsink: a #GstPlaySink
|
|
* @type: a #GstPlaySinkType
|
|
*
|
|
* Create or return a pad of @type.
|
|
*
|
|
* Returns: a #GstPad of @type or %NULL when the pad could not be created.
|
|
*/
|
|
GstPad *
|
|
gst_play_sink_request_pad (GstPlaySink * playsink, GstPlaySinkType type)
|
|
{
|
|
GstPad *res = NULL;
|
|
gboolean created = FALSE;
|
|
gboolean activate = TRUE;
|
|
const gchar *pad_name = NULL;
|
|
gulong *block_id = NULL;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "request pad type %d", type);
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
switch (type) {
|
|
case GST_PLAY_SINK_TYPE_AUDIO_RAW:
|
|
case GST_PLAY_SINK_TYPE_AUDIO:
|
|
pad_name = "audio_sink";
|
|
if (!playsink->audio_tee) {
|
|
GST_LOG_OBJECT (playsink, "creating tee");
|
|
/* create tee when needed. This element will feed the audio sink chain
|
|
* and the vis chain. */
|
|
playsink->audio_tee = gst_element_factory_make ("tee", "audiotee");
|
|
if (playsink->audio_tee == NULL) {
|
|
post_missing_element_message (playsink, "tee");
|
|
GST_ELEMENT_ERROR (playsink, CORE, MISSING_PLUGIN,
|
|
(_("Missing element '%s' - check your GStreamer installation."),
|
|
"tee"), (NULL));
|
|
res = NULL;
|
|
break;
|
|
} else {
|
|
playsink->audio_tee_sink =
|
|
gst_element_get_static_pad (playsink->audio_tee, "sink");
|
|
gst_bin_add (GST_BIN_CAST (playsink), playsink->audio_tee);
|
|
gst_element_set_state (playsink->audio_tee, GST_STATE_PAUSED);
|
|
}
|
|
} else {
|
|
gst_element_set_state (playsink->audio_tee, GST_STATE_PAUSED);
|
|
}
|
|
if (!playsink->audio_pad) {
|
|
GST_LOG_OBJECT (playsink, "ghosting tee sinkpad");
|
|
playsink->audio_pad =
|
|
gst_ghost_pad_new (pad_name, playsink->audio_tee_sink);
|
|
g_signal_connect (G_OBJECT (playsink->audio_pad), "notify::caps",
|
|
G_CALLBACK (caps_notify_cb), playsink);
|
|
created = TRUE;
|
|
}
|
|
playsink->audio_pad_raw = FALSE;
|
|
res = playsink->audio_pad;
|
|
block_id = &playsink->audio_block_id;
|
|
break;
|
|
case GST_PLAY_SINK_TYPE_VIDEO_RAW:
|
|
case GST_PLAY_SINK_TYPE_VIDEO:
|
|
pad_name = "video_sink";
|
|
if (!playsink->video_pad) {
|
|
GST_LOG_OBJECT (playsink, "ghosting videosink");
|
|
playsink->video_pad =
|
|
gst_ghost_pad_new_no_target (pad_name, GST_PAD_SINK);
|
|
g_signal_connect (G_OBJECT (playsink->video_pad), "notify::caps",
|
|
G_CALLBACK (caps_notify_cb), playsink);
|
|
created = TRUE;
|
|
}
|
|
playsink->video_pad_raw = FALSE;
|
|
res = playsink->video_pad;
|
|
block_id = &playsink->video_block_id;
|
|
break;
|
|
case GST_PLAY_SINK_TYPE_TEXT:
|
|
GST_LOG_OBJECT (playsink, "ghosting text");
|
|
if (!playsink->text_pad) {
|
|
playsink->text_pad =
|
|
gst_ghost_pad_new_no_target ("text_sink", GST_PAD_SINK);
|
|
created = TRUE;
|
|
}
|
|
res = playsink->text_pad;
|
|
block_id = &playsink->text_block_id;
|
|
break;
|
|
case GST_PLAY_SINK_TYPE_FLUSHING:
|
|
{
|
|
gchar *padname;
|
|
|
|
/* we need a unique padname for the flushing pad. */
|
|
padname = g_strdup_printf ("flushing_%u", playsink->count);
|
|
res = gst_ghost_pad_new_no_target (padname, GST_PAD_SINK);
|
|
g_free (padname);
|
|
playsink->count++;
|
|
activate = FALSE;
|
|
created = TRUE;
|
|
break;
|
|
}
|
|
default:
|
|
res = NULL;
|
|
break;
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
if (created && res) {
|
|
/* we have to add the pad when it's active or we get an error when the
|
|
* element is 'running' */
|
|
gst_pad_set_active (res, TRUE);
|
|
gst_element_add_pad (GST_ELEMENT_CAST (playsink), res);
|
|
if (block_id && *block_id == 0) {
|
|
GstPad *blockpad =
|
|
GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD (res)));
|
|
|
|
*block_id =
|
|
gst_pad_add_probe (blockpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
|
|
sinkpad_blocked_cb, playsink, NULL);
|
|
PENDING_FLAG_SET (playsink, type);
|
|
gst_object_unref (blockpad);
|
|
}
|
|
if (!activate)
|
|
gst_pad_set_active (res, activate);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
static GstPad *
|
|
gst_play_sink_request_new_pad (GstElement * element, GstPadTemplate * templ,
|
|
const gchar * name, const GstCaps * caps)
|
|
{
|
|
GstPlaySink *psink;
|
|
GstPad *pad;
|
|
GstPlaySinkType type;
|
|
const gchar *tplname;
|
|
|
|
g_return_val_if_fail (templ != NULL, NULL);
|
|
|
|
GST_DEBUG_OBJECT (element, "name:%s", name);
|
|
|
|
psink = GST_PLAY_SINK (element);
|
|
tplname = GST_PAD_TEMPLATE_NAME_TEMPLATE (templ);
|
|
|
|
/* Figure out the GstPlaySinkType based on the template */
|
|
if (!strcmp (tplname, "audio_sink"))
|
|
type = GST_PLAY_SINK_TYPE_AUDIO;
|
|
else if (!strcmp (tplname, "audio_raw_sink"))
|
|
type = GST_PLAY_SINK_TYPE_AUDIO_RAW;
|
|
else if (!strcmp (tplname, "video_sink"))
|
|
type = GST_PLAY_SINK_TYPE_VIDEO;
|
|
else if (!strcmp (tplname, "video_raw_sink"))
|
|
type = GST_PLAY_SINK_TYPE_VIDEO_RAW;
|
|
else if (!strcmp (tplname, "text_sink"))
|
|
type = GST_PLAY_SINK_TYPE_TEXT;
|
|
else
|
|
goto unknown_template;
|
|
|
|
pad = gst_play_sink_request_pad (psink, type);
|
|
return pad;
|
|
|
|
unknown_template:
|
|
GST_WARNING_OBJECT (element, "Unknown pad template");
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
gst_play_sink_release_pad (GstPlaySink * playsink, GstPad * pad)
|
|
{
|
|
GstPad **res = NULL;
|
|
gboolean untarget = TRUE;
|
|
|
|
GST_DEBUG_OBJECT (playsink, "release pad %" GST_PTR_FORMAT, pad);
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
if (pad == playsink->video_pad) {
|
|
res = &playsink->video_pad;
|
|
g_signal_handlers_disconnect_by_func (playsink->video_pad, caps_notify_cb,
|
|
playsink);
|
|
} else if (pad == playsink->audio_pad) {
|
|
res = &playsink->audio_pad;
|
|
g_signal_handlers_disconnect_by_func (playsink->audio_pad, caps_notify_cb,
|
|
playsink);
|
|
} else if (pad == playsink->text_pad) {
|
|
res = &playsink->text_pad;
|
|
} else {
|
|
/* try to release the given pad anyway, these could be the FLUSHING pads. */
|
|
res = &pad;
|
|
untarget = FALSE;
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
if (*res) {
|
|
GST_DEBUG_OBJECT (playsink, "deactivate pad %" GST_PTR_FORMAT, *res);
|
|
gst_pad_set_active (*res, FALSE);
|
|
if (untarget) {
|
|
GST_DEBUG_OBJECT (playsink, "untargeting pad %" GST_PTR_FORMAT, *res);
|
|
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (*res), NULL);
|
|
}
|
|
GST_DEBUG_OBJECT (playsink, "remove pad %" GST_PTR_FORMAT, *res);
|
|
gst_element_remove_pad (GST_ELEMENT_CAST (playsink), *res);
|
|
*res = NULL;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_release_request_pad (GstElement * element, GstPad * pad)
|
|
{
|
|
GstPlaySink *psink = GST_PLAY_SINK (element);
|
|
|
|
gst_play_sink_release_pad (psink, pad);
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_handle_message (GstBin * bin, GstMessage * message)
|
|
{
|
|
GstPlaySink *playsink;
|
|
|
|
playsink = GST_PLAY_SINK_CAST (bin);
|
|
|
|
switch (GST_MESSAGE_TYPE (message)) {
|
|
case GST_MESSAGE_STEP_DONE:
|
|
{
|
|
GstFormat format;
|
|
guint64 amount;
|
|
gdouble rate;
|
|
gboolean flush, intermediate, eos;
|
|
guint64 duration;
|
|
|
|
GST_INFO_OBJECT (playsink, "Handling step-done message");
|
|
gst_message_parse_step_done (message, &format, &amount, &rate, &flush,
|
|
&intermediate, &duration, &eos);
|
|
|
|
if (format == GST_FORMAT_BUFFERS) {
|
|
/* for the buffer format, we align the other streams */
|
|
if (playsink->audiochain) {
|
|
GstEvent *event;
|
|
|
|
event =
|
|
gst_event_new_step (GST_FORMAT_TIME, duration, rate, flush,
|
|
intermediate);
|
|
|
|
if (!gst_element_send_event (playsink->audiochain->chain.bin, event)) {
|
|
GST_DEBUG_OBJECT (playsink, "Event failed when sent to audio sink");
|
|
}
|
|
}
|
|
}
|
|
GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (bin, message);
|
|
break;
|
|
}
|
|
case GST_MESSAGE_ELEMENT:{
|
|
if (gst_is_video_overlay_prepare_window_handle_message (message)) {
|
|
GstVideoOverlay *overlay;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element
|
|
&& GST_OBJECT_CAST (playsink->overlay_element) !=
|
|
GST_MESSAGE_SRC (message)) {
|
|
gst_object_unref (playsink->overlay_element);
|
|
playsink->overlay_element = NULL;
|
|
}
|
|
|
|
if (!playsink->overlay_element)
|
|
playsink->overlay_element =
|
|
GST_VIDEO_OVERLAY (gst_object_ref (GST_MESSAGE_SRC (message)));
|
|
overlay =
|
|
GST_VIDEO_OVERLAY (gst_object_ref (playsink->overlay_element));
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
GST_DEBUG_OBJECT (playsink, "Got prepare-xwindow-id message");
|
|
|
|
if (playsink->overlay_handle_set)
|
|
gst_video_overlay_set_window_handle (playsink->overlay_element,
|
|
playsink->overlay_handle);
|
|
if (playsink->overlay_handle_events_set)
|
|
gst_video_overlay_handle_events (playsink->overlay_element,
|
|
playsink->overlay_handle_events);
|
|
if (playsink->overlay_render_rectangle_set)
|
|
gst_video_overlay_set_render_rectangle (playsink->overlay_element,
|
|
playsink->overlay_x, playsink->overlay_y,
|
|
playsink->overlay_width, playsink->overlay_height);
|
|
|
|
gst_object_unref (overlay);
|
|
gst_message_unref (message);
|
|
gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (playsink));
|
|
} else {
|
|
GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (bin,
|
|
message);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
GST_BIN_CLASS (gst_play_sink_parent_class)->handle_message (bin, message);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Send an event to our sinks until one of them works; don't then send to the
|
|
* remaining sinks (unlike GstBin)
|
|
* Special case: If a text sink is set we need to send the event
|
|
* to them in case it's source is different from the a/v stream's source.
|
|
*/
|
|
static gboolean
|
|
gst_play_sink_send_event_to_sink (GstPlaySink * playsink, GstEvent * event)
|
|
{
|
|
gboolean res = TRUE;
|
|
if (playsink->send_event_mode == MODE_FIRST) {
|
|
if (playsink->textchain && playsink->textchain->sink) {
|
|
gst_event_ref (event);
|
|
if ((res =
|
|
gst_element_send_event (playsink->textchain->chain.bin, event))) {
|
|
GST_DEBUG_OBJECT (playsink, "Sent event successfully to text sink");
|
|
} else {
|
|
GST_DEBUG_OBJECT (playsink, "Event failed when sent to text sink");
|
|
}
|
|
}
|
|
|
|
if (playsink->videochain) {
|
|
gst_event_ref (event);
|
|
if ((res =
|
|
gst_element_send_event (playsink->videochain->chain.bin,
|
|
event))) {
|
|
GST_DEBUG_OBJECT (playsink, "Sent event successfully to video sink");
|
|
goto done;
|
|
}
|
|
GST_DEBUG_OBJECT (playsink, "Event failed when sent to video sink");
|
|
}
|
|
if (playsink->audiochain) {
|
|
gst_event_ref (event);
|
|
if ((res =
|
|
gst_element_send_event (playsink->audiochain->chain.bin,
|
|
event))) {
|
|
GST_DEBUG_OBJECT (playsink, "Sent event successfully to audio sink");
|
|
goto done;
|
|
}
|
|
GST_DEBUG_OBJECT (playsink, "Event failed when sent to audio sink");
|
|
}
|
|
} else {
|
|
return
|
|
GST_ELEMENT_CLASS (gst_play_sink_parent_class)->send_event
|
|
(GST_ELEMENT_CAST (playsink), event);
|
|
}
|
|
|
|
done:
|
|
gst_event_unref (event);
|
|
return res;
|
|
}
|
|
|
|
/* We only want to send the event to a single sink (overriding GstBin's
|
|
* behaviour), but we want to keep GstPipeline's behaviour - wrapping seek
|
|
* events appropriately. So, this is a messy duplication of code. */
|
|
static gboolean
|
|
gst_play_sink_send_event (GstElement * element, GstEvent * event)
|
|
{
|
|
gboolean res = FALSE;
|
|
GstEventType event_type = GST_EVENT_TYPE (event);
|
|
GstPlaySink *playsink;
|
|
playsink = GST_PLAY_SINK_CAST (element);
|
|
switch (event_type) {
|
|
case GST_EVENT_SEEK:
|
|
GST_DEBUG_OBJECT (element, "Sending event to a sink");
|
|
res = gst_play_sink_send_event_to_sink (playsink, event);
|
|
break;
|
|
case GST_EVENT_STEP:
|
|
{
|
|
GstFormat format;
|
|
guint64 amount;
|
|
gdouble rate;
|
|
gboolean flush, intermediate;
|
|
gst_event_parse_step (event, &format, &amount, &rate, &flush,
|
|
&intermediate);
|
|
if (format == GST_FORMAT_BUFFERS) {
|
|
/* for buffers, we will try to step video frames, for other formats we
|
|
* send the step to all sinks */
|
|
res = gst_play_sink_send_event_to_sink (playsink, event);
|
|
} else {
|
|
res =
|
|
GST_ELEMENT_CLASS (gst_play_sink_parent_class)->send_event (element,
|
|
event);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
res =
|
|
GST_ELEMENT_CLASS (gst_play_sink_parent_class)->send_event (element,
|
|
event);
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static GstStateChangeReturn
|
|
gst_play_sink_change_state (GstElement * element, GstStateChange transition)
|
|
{
|
|
GstStateChangeReturn ret;
|
|
GstStateChangeReturn bret;
|
|
GstPlaySink *playsink;
|
|
playsink = GST_PLAY_SINK (element);
|
|
switch (transition) {
|
|
case GST_STATE_CHANGE_READY_TO_PAUSED:
|
|
gst_segment_init (&playsink->text_segment, GST_FORMAT_UNDEFINED);
|
|
|
|
playsink->need_async_start = TRUE;
|
|
/* we want to go async to PAUSED until we managed to configure and add the
|
|
* sinks */
|
|
do_async_start (playsink);
|
|
ret = GST_STATE_CHANGE_ASYNC;
|
|
|
|
/* block all pads here */
|
|
if (!gst_play_sink_reconfigure (playsink))
|
|
ret = GST_STATE_CHANGE_FAILURE;
|
|
break;
|
|
case GST_STATE_CHANGE_PAUSED_TO_READY:
|
|
/* unblock all pads here */
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
video_set_blocked (playsink, FALSE);
|
|
audio_set_blocked (playsink, FALSE);
|
|
text_set_blocked (playsink, FALSE);
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
/* fall through */
|
|
case GST_STATE_CHANGE_READY_TO_NULL:
|
|
if (playsink->audiochain && playsink->audiochain->sink_volume) {
|
|
/* remove our links to the mute and volume elements when they were
|
|
* provided by a sink */
|
|
disconnect_chain (playsink->audiochain, playsink);
|
|
playsink->audiochain->volume = NULL;
|
|
playsink->audiochain->mute = NULL;
|
|
}
|
|
|
|
if (playsink->audiochain && playsink->audiochain->ts_offset) {
|
|
gst_object_unref (playsink->audiochain->ts_offset);
|
|
playsink->audiochain->ts_offset = NULL;
|
|
}
|
|
|
|
if (playsink->videochain && playsink->videochain->ts_offset) {
|
|
gst_object_unref (playsink->videochain->ts_offset);
|
|
playsink->videochain->ts_offset = NULL;
|
|
}
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
gst_object_unref (playsink->overlay_element);
|
|
playsink->overlay_element = NULL;
|
|
|
|
if (playsink->colorbalance_element) {
|
|
g_signal_handlers_disconnect_by_func (playsink->colorbalance_element,
|
|
G_CALLBACK (colorbalance_value_changed_cb), playsink);
|
|
gst_object_unref (playsink->colorbalance_element);
|
|
}
|
|
playsink->colorbalance_element = NULL;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
ret = GST_STATE_CHANGE_SUCCESS;
|
|
break;
|
|
default:
|
|
/* all other state changes return SUCCESS by default, this value can be
|
|
* overridden by the result of the children */
|
|
ret = GST_STATE_CHANGE_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
/* do the state change of the children */
|
|
bret =
|
|
GST_ELEMENT_CLASS (gst_play_sink_parent_class)->change_state (element,
|
|
transition);
|
|
/* now look at the result of our children and adjust the return value */
|
|
switch (bret) {
|
|
case GST_STATE_CHANGE_FAILURE:
|
|
/* failure, we stop */
|
|
goto activate_failed;
|
|
case GST_STATE_CHANGE_NO_PREROLL:
|
|
/* some child returned NO_PREROLL. This is strange but we never know. We
|
|
* commit our async state change (if any) and return the NO_PREROLL */
|
|
do_async_done (playsink);
|
|
ret = bret;
|
|
break;
|
|
case GST_STATE_CHANGE_ASYNC:
|
|
/* some child was async, return this */
|
|
ret = bret;
|
|
break;
|
|
default:
|
|
/* return our previously configured return value */
|
|
break;
|
|
}
|
|
|
|
switch (transition) {
|
|
case GST_STATE_CHANGE_READY_TO_PAUSED:
|
|
break;
|
|
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
|
|
/* FIXME Release audio device when we implement that */
|
|
playsink->need_async_start = TRUE;
|
|
break;
|
|
case GST_STATE_CHANGE_PAUSED_TO_READY:{
|
|
if (playsink->video_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->video_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->video_sinkpad_stream_synchronizer);
|
|
playsink->video_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->video_srcpad_stream_synchronizer);
|
|
playsink->video_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
if (playsink->audio_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->audio_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->audio_sinkpad_stream_synchronizer);
|
|
playsink->audio_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->audio_srcpad_stream_synchronizer);
|
|
playsink->audio_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
if (playsink->text_sinkpad_stream_synchronizer) {
|
|
gst_element_release_request_pad (GST_ELEMENT_CAST
|
|
(playsink->stream_synchronizer),
|
|
playsink->text_sinkpad_stream_synchronizer);
|
|
gst_object_unref (playsink->text_sinkpad_stream_synchronizer);
|
|
playsink->text_sinkpad_stream_synchronizer = NULL;
|
|
gst_object_unref (playsink->text_srcpad_stream_synchronizer);
|
|
playsink->text_srcpad_stream_synchronizer = NULL;
|
|
}
|
|
}
|
|
/* fall through */
|
|
case GST_STATE_CHANGE_READY_TO_NULL:
|
|
/* remove sinks we added */
|
|
if (playsink->videodeinterlacechain) {
|
|
activate_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain),
|
|
FALSE);
|
|
add_chain (GST_PLAY_CHAIN (playsink->videodeinterlacechain), FALSE);
|
|
}
|
|
if (playsink->videochain) {
|
|
activate_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
|
|
add_chain (GST_PLAY_CHAIN (playsink->videochain), FALSE);
|
|
}
|
|
if (playsink->audiochain) {
|
|
activate_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
|
|
add_chain (GST_PLAY_CHAIN (playsink->audiochain), FALSE);
|
|
}
|
|
if (playsink->vischain) {
|
|
activate_chain (GST_PLAY_CHAIN (playsink->vischain), FALSE);
|
|
add_chain (GST_PLAY_CHAIN (playsink->vischain), FALSE);
|
|
}
|
|
if (playsink->textchain) {
|
|
activate_chain (GST_PLAY_CHAIN (playsink->textchain), FALSE);
|
|
add_chain (GST_PLAY_CHAIN (playsink->textchain), FALSE);
|
|
}
|
|
do_async_done (playsink);
|
|
/* when going to READY, keep elements around as long as possible,
|
|
* so they may be re-used faster next time/url around.
|
|
* when really going to NULL, clean up everything completely. */
|
|
if (transition == GST_STATE_CHANGE_READY_TO_NULL) {
|
|
|
|
/* Unparent the sinks to allow reuse */
|
|
if (playsink->videochain && playsink->videochain->sink)
|
|
gst_bin_remove (GST_BIN_CAST (playsink->videochain->chain.bin),
|
|
playsink->videochain->sink);
|
|
if (playsink->audiochain && playsink->audiochain->sink)
|
|
gst_bin_remove (GST_BIN_CAST (playsink->audiochain->chain.bin),
|
|
playsink->audiochain->sink);
|
|
if (playsink->textchain && playsink->textchain->sink)
|
|
gst_bin_remove (GST_BIN_CAST (playsink->textchain->chain.bin),
|
|
playsink->textchain->sink);
|
|
if (playsink->audio_sink != NULL)
|
|
gst_element_set_state (playsink->audio_sink, GST_STATE_NULL);
|
|
if (playsink->video_sink != NULL)
|
|
gst_element_set_state (playsink->video_sink, GST_STATE_NULL);
|
|
if (playsink->visualisation != NULL)
|
|
gst_element_set_state (playsink->visualisation, GST_STATE_NULL);
|
|
if (playsink->text_sink != NULL)
|
|
gst_element_set_state (playsink->text_sink, GST_STATE_NULL);
|
|
free_chain ((GstPlayChain *) playsink->videodeinterlacechain);
|
|
playsink->videodeinterlacechain = NULL;
|
|
free_chain ((GstPlayChain *) playsink->videochain);
|
|
playsink->videochain = NULL;
|
|
free_chain ((GstPlayChain *) playsink->audiochain);
|
|
playsink->audiochain = NULL;
|
|
free_chain ((GstPlayChain *) playsink->vischain);
|
|
playsink->vischain = NULL;
|
|
free_chain ((GstPlayChain *) playsink->textchain);
|
|
playsink->textchain = NULL;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return ret;
|
|
/* ERRORS */
|
|
activate_failed:
|
|
{
|
|
GST_DEBUG_OBJECT (element,
|
|
"element failed to change states -- activation problem?");
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * spec)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (object);
|
|
switch (prop_id) {
|
|
case PROP_FLAGS:
|
|
gst_play_sink_set_flags (playsink, g_value_get_flags (value));
|
|
break;
|
|
case PROP_VOLUME:
|
|
gst_play_sink_set_volume (playsink, g_value_get_double (value));
|
|
break;
|
|
case PROP_MUTE:
|
|
gst_play_sink_set_mute (playsink, g_value_get_boolean (value));
|
|
break;
|
|
case PROP_FONT_DESC:
|
|
gst_play_sink_set_font_desc (playsink, g_value_get_string (value));
|
|
break;
|
|
case PROP_SUBTITLE_ENCODING:
|
|
gst_play_sink_set_subtitle_encoding (playsink,
|
|
g_value_get_string (value));
|
|
break;
|
|
case PROP_VIS_PLUGIN:
|
|
gst_play_sink_set_vis_plugin (playsink, g_value_get_object (value));
|
|
break;
|
|
case PROP_AV_OFFSET:
|
|
gst_play_sink_set_av_offset (playsink, g_value_get_int64 (value));
|
|
break;
|
|
case PROP_VIDEO_SINK:
|
|
gst_play_sink_set_sink (playsink, GST_PLAY_SINK_TYPE_VIDEO,
|
|
g_value_get_object (value));
|
|
break;
|
|
case PROP_AUDIO_SINK:
|
|
gst_play_sink_set_sink (playsink, GST_PLAY_SINK_TYPE_AUDIO,
|
|
g_value_get_object (value));
|
|
break;
|
|
case PROP_TEXT_SINK:
|
|
gst_play_sink_set_sink (playsink, GST_PLAY_SINK_TYPE_TEXT,
|
|
g_value_get_object (value));
|
|
break;
|
|
case PROP_SEND_EVENT_MODE:
|
|
playsink->send_event_mode = g_value_get_enum (value);
|
|
break;
|
|
case PROP_FORCE_ASPECT_RATIO:{
|
|
GstPlayVideoChain *chain;
|
|
GstElement *elem;
|
|
|
|
playsink->force_aspect_ratio = g_value_get_boolean (value);
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
if (playsink->videochain) {
|
|
chain = (GstPlayVideoChain *) playsink->videochain;
|
|
|
|
if (chain->sink) {
|
|
elem =
|
|
gst_play_sink_find_property_sinks (playsink, chain->sink,
|
|
"force-aspect-ratio", G_TYPE_BOOLEAN);
|
|
|
|
if (elem)
|
|
g_object_set (elem, "force-aspect-ratio",
|
|
playsink->force_aspect_ratio, NULL);
|
|
}
|
|
}
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
break;
|
|
}
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * spec)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (object);
|
|
switch (prop_id) {
|
|
case PROP_FLAGS:
|
|
g_value_set_flags (value, gst_play_sink_get_flags (playsink));
|
|
break;
|
|
case PROP_VOLUME:
|
|
g_value_set_double (value, gst_play_sink_get_volume (playsink));
|
|
break;
|
|
case PROP_MUTE:
|
|
g_value_set_boolean (value, gst_play_sink_get_mute (playsink));
|
|
break;
|
|
case PROP_FONT_DESC:
|
|
g_value_take_string (value, gst_play_sink_get_font_desc (playsink));
|
|
break;
|
|
case PROP_SUBTITLE_ENCODING:
|
|
g_value_take_string (value,
|
|
gst_play_sink_get_subtitle_encoding (playsink));
|
|
break;
|
|
case PROP_VIS_PLUGIN:
|
|
g_value_take_object (value, gst_play_sink_get_vis_plugin (playsink));
|
|
break;
|
|
case PROP_SAMPLE:
|
|
gst_value_take_sample (value, gst_play_sink_get_last_sample (playsink));
|
|
break;
|
|
case PROP_AV_OFFSET:
|
|
g_value_set_int64 (value, gst_play_sink_get_av_offset (playsink));
|
|
break;
|
|
case PROP_VIDEO_SINK:
|
|
g_value_take_object (value, gst_play_sink_get_sink (playsink,
|
|
GST_PLAY_SINK_TYPE_VIDEO));
|
|
break;
|
|
case PROP_AUDIO_SINK:
|
|
g_value_take_object (value, gst_play_sink_get_sink (playsink,
|
|
GST_PLAY_SINK_TYPE_AUDIO));
|
|
break;
|
|
case PROP_TEXT_SINK:
|
|
g_value_take_object (value, gst_play_sink_get_sink (playsink,
|
|
GST_PLAY_SINK_TYPE_TEXT));
|
|
break;
|
|
case PROP_SEND_EVENT_MODE:
|
|
g_value_set_enum (value, playsink->send_event_mode);
|
|
break;
|
|
case PROP_FORCE_ASPECT_RATIO:
|
|
g_value_set_boolean (value, playsink->force_aspect_ratio);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_overlay_expose (GstVideoOverlay * overlay)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (overlay);
|
|
GstVideoOverlay *overlay_element;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
overlay_element =
|
|
GST_VIDEO_OVERLAY (gst_object_ref (playsink->overlay_element));
|
|
else
|
|
overlay_element = NULL;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
if (overlay_element) {
|
|
gst_video_overlay_expose (overlay_element);
|
|
gst_object_unref (overlay_element);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_overlay_handle_events (GstVideoOverlay * overlay,
|
|
gboolean handle_events)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (overlay);
|
|
GstVideoOverlay *overlay_element;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
overlay_element =
|
|
GST_VIDEO_OVERLAY (gst_object_ref (playsink->overlay_element));
|
|
else
|
|
overlay_element = NULL;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
playsink->overlay_handle_events_set = TRUE;
|
|
playsink->overlay_handle_events = handle_events;
|
|
|
|
if (overlay_element) {
|
|
gst_video_overlay_handle_events (overlay_element, handle_events);
|
|
gst_object_unref (overlay_element);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_overlay_set_render_rectangle (GstVideoOverlay * overlay, gint x,
|
|
gint y, gint width, gint height)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (overlay);
|
|
GstVideoOverlay *overlay_element;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
overlay_element =
|
|
GST_VIDEO_OVERLAY (gst_object_ref (playsink->overlay_element));
|
|
else
|
|
overlay_element = NULL;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
playsink->overlay_render_rectangle_set = TRUE;
|
|
playsink->overlay_x = x;
|
|
playsink->overlay_y = y;
|
|
playsink->overlay_width = width;
|
|
playsink->overlay_height = height;
|
|
|
|
if (overlay_element) {
|
|
gst_video_overlay_set_render_rectangle (overlay_element, x, y, width,
|
|
height);
|
|
gst_object_unref (overlay_element);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_overlay_set_window_handle (GstVideoOverlay * overlay,
|
|
guintptr handle)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (overlay);
|
|
GstVideoOverlay *overlay_element;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->overlay_element)
|
|
overlay_element =
|
|
GST_VIDEO_OVERLAY (gst_object_ref (playsink->overlay_element));
|
|
else
|
|
overlay_element = NULL;
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
playsink->overlay_handle_set = TRUE;
|
|
playsink->overlay_handle = handle;
|
|
|
|
if (overlay_element) {
|
|
gst_video_overlay_set_window_handle (overlay_element, handle);
|
|
gst_object_unref (overlay_element);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_overlay_init (gpointer g_iface, gpointer g_iface_data)
|
|
{
|
|
GstVideoOverlayInterface *iface = (GstVideoOverlayInterface *) g_iface;
|
|
iface->expose = gst_play_sink_overlay_expose;
|
|
iface->handle_events = gst_play_sink_overlay_handle_events;
|
|
iface->set_render_rectangle = gst_play_sink_overlay_set_render_rectangle;
|
|
iface->set_window_handle = gst_play_sink_overlay_set_window_handle;
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_navigation_send_event (GstNavigation * navigation,
|
|
GstStructure * structure)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (navigation);
|
|
GstBin *bin = NULL;
|
|
|
|
GST_PLAY_SINK_LOCK (playsink);
|
|
if (playsink->videochain && playsink->videochain->chain.bin)
|
|
bin = GST_BIN (gst_object_ref (playsink->videochain->chain.bin));
|
|
GST_PLAY_SINK_UNLOCK (playsink);
|
|
|
|
if (bin) {
|
|
GstElement *nav = gst_bin_get_by_interface (bin, GST_TYPE_NAVIGATION);
|
|
|
|
if (nav) {
|
|
gst_navigation_send_event (GST_NAVIGATION (nav), structure);
|
|
structure = NULL;
|
|
gst_object_unref (nav);
|
|
} else {
|
|
GstEvent *event = gst_event_new_navigation (structure);
|
|
structure = NULL;
|
|
gst_element_send_event (GST_ELEMENT (bin), event);
|
|
}
|
|
|
|
gst_object_unref (bin);
|
|
}
|
|
|
|
if (structure)
|
|
gst_structure_free (structure);
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_navigation_init (gpointer g_iface, gpointer g_iface_data)
|
|
{
|
|
GstNavigationInterface *iface = (GstNavigationInterface *) g_iface;
|
|
|
|
iface->send_event = gst_play_sink_navigation_send_event;
|
|
}
|
|
|
|
static const GList *
|
|
gst_play_sink_colorbalance_list_channels (GstColorBalance * balance)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (balance);
|
|
|
|
return playsink->colorbalance_channels;
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_colorbalance_set_value (GstColorBalance * balance,
|
|
GstColorBalanceChannel * proxy, gint value)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (balance);
|
|
GList *l;
|
|
gint i;
|
|
GstColorBalance *balance_element = NULL;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->colorbalance_element)
|
|
balance_element =
|
|
GST_COLOR_BALANCE (gst_object_ref (playsink->colorbalance_element));
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
for (i = 0, l = playsink->colorbalance_channels; l; l = l->next, i++) {
|
|
GstColorBalanceChannel *proxy_tmp = l->data;
|
|
gdouble new_val;
|
|
|
|
if (proxy_tmp != proxy)
|
|
continue;
|
|
|
|
playsink->colorbalance_values[i] = value;
|
|
|
|
if (balance_element) {
|
|
GstColorBalanceChannel *channel = NULL;
|
|
const GList *channels, *k;
|
|
|
|
channels = gst_color_balance_list_channels (balance_element);
|
|
for (k = channels; k; k = k->next) {
|
|
GstColorBalanceChannel *tmp = l->data;
|
|
|
|
if (g_strrstr (tmp->label, proxy->label)) {
|
|
channel = tmp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_assert (channel);
|
|
|
|
/* Convert to [0, 1] range */
|
|
new_val =
|
|
((gdouble) value -
|
|
(gdouble) proxy->min_value) / ((gdouble) proxy->max_value -
|
|
(gdouble) proxy->min_value);
|
|
/* Convert to channel range */
|
|
new_val =
|
|
channel->min_value + new_val * ((gdouble) channel->max_value -
|
|
(gdouble) channel->min_value);
|
|
|
|
gst_color_balance_set_value (balance_element, channel,
|
|
(gint) (new_val + 0.5));
|
|
|
|
gst_object_unref (balance_element);
|
|
}
|
|
|
|
gst_color_balance_value_changed (balance, proxy, value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static gint
|
|
gst_play_sink_colorbalance_get_value (GstColorBalance * balance,
|
|
GstColorBalanceChannel * proxy)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (balance);
|
|
GList *l;
|
|
gint i;
|
|
|
|
for (i = 0, l = playsink->colorbalance_channels; l; l = l->next, i++) {
|
|
GstColorBalanceChannel *proxy_tmp = l->data;
|
|
|
|
if (proxy_tmp != proxy)
|
|
continue;
|
|
|
|
return playsink->colorbalance_values[i];
|
|
}
|
|
|
|
g_return_val_if_reached (0);
|
|
}
|
|
|
|
static GstColorBalanceType
|
|
gst_play_sink_colorbalance_get_balance_type (GstColorBalance * balance)
|
|
{
|
|
GstPlaySink *playsink = GST_PLAY_SINK (balance);
|
|
GstColorBalance *balance_element = NULL;
|
|
GstColorBalanceType t = GST_COLOR_BALANCE_SOFTWARE;
|
|
|
|
GST_OBJECT_LOCK (playsink);
|
|
if (playsink->colorbalance_element)
|
|
balance_element =
|
|
GST_COLOR_BALANCE (gst_object_ref (playsink->colorbalance_element));
|
|
GST_OBJECT_UNLOCK (playsink);
|
|
|
|
if (balance_element) {
|
|
t = gst_color_balance_get_balance_type (balance_element);
|
|
gst_object_unref (balance_element);
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
static void
|
|
gst_play_sink_colorbalance_init (gpointer g_iface, gpointer g_iface_data)
|
|
{
|
|
GstColorBalanceInterface *iface = (GstColorBalanceInterface *) g_iface;
|
|
|
|
iface->list_channels = gst_play_sink_colorbalance_list_channels;
|
|
iface->set_value = gst_play_sink_colorbalance_set_value;
|
|
iface->get_value = gst_play_sink_colorbalance_get_value;
|
|
iface->get_balance_type = gst_play_sink_colorbalance_get_balance_type;
|
|
}
|
|
|
|
gboolean
|
|
gst_play_sink_plugin_init (GstPlugin * plugin)
|
|
{
|
|
GST_DEBUG_CATEGORY_INIT (gst_play_sink_debug, "playsink", 0, "play bin");
|
|
return gst_element_register (plugin, "playsink", GST_RANK_NONE,
|
|
GST_TYPE_PLAY_SINK);
|
|
}
|