static void
gst_win_inet_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstWinInetSrc *self = GST_WIN_INET_SRC (object);
switch (prop_id) {
case PROP_LOCATION:
if (GST_STATE (self) == GST_STATE_PLAYING ||
GST_STATE (self) == GST_STATE_PAUSED) {
GST_WARNING_OBJECT (self, "element must be in stopped or paused state "
"in order to change location");
break;
}
g_free (self->location);
self->location = g_value_dup_string (value);
break;
case PROP_POLL_MODE:
self->poll_mode = g_value_get_boolean (value);
break;
case PROP_IRADIO_MODE:
self->iradio_mode = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_audio_echo_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstAudioEcho *self = GST_AUDIO_ECHO (object);
switch (prop_id) {
case PROP_DELAY:{
guint64 max_delay, delay;
GST_BASE_TRANSFORM_LOCK (self);
delay = g_value_get_uint64 (value);
max_delay = self->max_delay;
if (delay > max_delay && GST_STATE (self) > GST_STATE_READY) {
GST_WARNING_OBJECT (self, "New delay (%" GST_TIME_FORMAT ") "
"is larger than maximum delay (%" GST_TIME_FORMAT ")",
GST_TIME_ARGS (delay), GST_TIME_ARGS (max_delay));
self->delay = max_delay;
} else {
self->delay = delay;
self->max_delay = MAX (delay, max_delay);
}
GST_BASE_TRANSFORM_UNLOCK (self);
}
break;
case PROP_MAX_DELAY:{
guint64 max_delay, delay;
GST_BASE_TRANSFORM_LOCK (self);
max_delay = g_value_get_uint64 (value);
delay = self->delay;
if (GST_STATE (self) > GST_STATE_READY) {
GST_ERROR_OBJECT (self, "Can't change maximum delay in"
" PLAYING or PAUSED state");
} else {
self->delay = delay;
self->max_delay = max_delay;
}
GST_BASE_TRANSFORM_UNLOCK (self);
}
break;
case PROP_INTENSITY:{
GST_BASE_TRANSFORM_LOCK (self);
self->intensity = g_value_get_float (value);
GST_BASE_TRANSFORM_UNLOCK (self);
}
break;
case PROP_FEEDBACK:{
GST_BASE_TRANSFORM_LOCK (self);
self->feedback = g_value_get_float (value);
GST_BASE_TRANSFORM_UNLOCK (self);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
G_MODULE_EXPORT gboolean
preview_draw_cb(
GtkWidget *widget,
cairo_t *cr,
signal_user_data_t *ud)
{
#if defined(_ENABLE_GST)
#if GST_CHECK_VERSION(1, 0, 0)
if (ud->preview->live_enabled && ud->preview->state == PREVIEW_STATE_LIVE)
{
if (GST_STATE(ud->preview->play) >= GST_STATE_PAUSED)
{
GstElement *vsink;
GstVideoOverlay *vover;
g_object_get(ud->preview->play, "video-sink", &vsink, NULL);
if (GST_IS_BIN(vsink))
vover = GST_VIDEO_OVERLAY(gst_bin_get_by_interface(
GST_BIN(vsink), GST_TYPE_VIDEO_OVERLAY));
else
vover = GST_VIDEO_OVERLAY(vsink);
gst_video_overlay_expose(vover);
// For some reason, the exposed region doesn't always get
// cleaned up here. But a delayed gst_x_overlay_expose()
// takes care of it.
g_idle_add((GSourceFunc)delayed_expose_cb, ud);
}
return FALSE;
}
#else
if (ud->preview->live_enabled && ud->preview->state == PREVIEW_STATE_LIVE)
{
if (GST_STATE(ud->preview->play) >= GST_STATE_PAUSED)
{
GstElement *vsink;
GstXOverlay *xover;
g_object_get(ud->preview->play, "video-sink", &vsink, NULL);
if (GST_IS_BIN(vsink))
xover = GST_X_OVERLAY(gst_bin_get_by_interface(
GST_BIN(vsink), GST_TYPE_X_OVERLAY));
else
xover = GST_X_OVERLAY(vsink);
gst_x_overlay_expose(xover);
// For some reason, the exposed region doesn't always get
// cleaned up here. But a delayed gst_x_overlay_expose()
// takes care of it.
g_idle_add((GSourceFunc)delayed_expose_cb, ud);
}
return FALSE;
}
#endif
#endif
if (ud->preview->pix != NULL)
{
_draw_pixbuf(cr, ud->preview->pix);
}
return FALSE;
}
void
gst_gio_base_src_set_stream (GstGioBaseSrc * src, GInputStream * stream)
{
gboolean success;
GError *err = NULL;
g_return_if_fail (G_IS_INPUT_STREAM (stream));
g_return_if_fail ((GST_STATE (src) != GST_STATE_PLAYING &&
GST_STATE (src) != GST_STATE_PAUSED));
if (G_IS_INPUT_STREAM (src->stream)) {
GST_DEBUG_OBJECT (src, "closing old stream");
/* FIXME: can block but unfortunately we can't use async operations
* here because they require a running main loop */
success = g_input_stream_close (src->stream, src->cancel, &err);
if (!success && !gst_gio_error (src, "g_input_stream_close", &err, NULL)) {
GST_ELEMENT_WARNING (src, RESOURCE, CLOSE, (NULL),
("g_input_stream_close failed: %s", err->message));
g_clear_error (&err);
} else if (!success) {
GST_ELEMENT_WARNING (src, RESOURCE, CLOSE, (NULL),
("g_input_stream_close failed"));
} else {
GST_DEBUG_OBJECT (src, "g_input_stream_close succeeded");
}
g_object_unref (src->stream);
src->stream = NULL;
}
src->stream = stream;
}
static void
gst_jack_audio_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstJackAudioSrc *src = GST_JACK_AUDIO_SRC (object);
switch (prop_id) {
case PROP_CLIENT_NAME:
g_free (src->client_name);
src->client_name = g_value_dup_string (value);
break;
case PROP_CONNECT:
src->connect = g_value_get_enum (value);
break;
case PROP_SERVER:
g_free (src->server);
src->server = g_value_dup_string (value);
break;
case PROP_CLIENT:
if (GST_STATE (src) == GST_STATE_NULL ||
GST_STATE (src) == GST_STATE_READY) {
src->jclient = g_value_get_boxed (value);
}
break;
case PROP_TRANSPORT:
src->transport = g_value_get_flags (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_gio_stream_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstGioStreamSink *sink = GST_GIO_STREAM_SINK (object);
switch (prop_id) {
case PROP_STREAM:{
GObject *stream;
if (GST_STATE (sink) == GST_STATE_PLAYING ||
GST_STATE (sink) == GST_STATE_PAUSED) {
GST_WARNING
("Setting a new stream not supported in PLAYING or PAUSED state");
break;
}
stream = g_value_dup_object (value);
if (sink->stream)
g_object_unref (sink->stream);
sink->stream = G_OUTPUT_STREAM (stream);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean gst_imx_v4l2src_set_focus_mode(GstPhotography *photo,
GstPhotographyFocusMode focus_mode)
{
GstImxV4l2VideoSrc *v4l2src = GST_IMX_V4L2SRC(photo);
GST_LOG_OBJECT(v4l2src, "setting focus mode to %d", focus_mode);
switch (focus_mode) {
case GST_PHOTOGRAPHY_FOCUS_MODE_AUTO:
case GST_PHOTOGRAPHY_FOCUS_MODE_MACRO:
case GST_PHOTOGRAPHY_FOCUS_MODE_PORTRAIT:
case GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY:
break;
case GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL:
case GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_EXTENDED:
focus_mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL;
break;
default:
GST_WARNING_OBJECT(v4l2src, "focus mode %d is not supported", focus_mode);
return FALSE;
}
g_mutex_lock(&v4l2src->af_mutex);
if (v4l2src->focus_mode != focus_mode) {
v4l2src->focus_mode = focus_mode;
if (GST_STATE(v4l2src) == GST_STATE_PAUSED || GST_STATE(v4l2src) == GST_STATE_PLAYING)
gst_imx_v4l2src_apply_focus_settings(v4l2src, TRUE);
}
g_mutex_unlock(&v4l2src->af_mutex);
return TRUE;
}
static gboolean
do_toggle_element (GstGConfVideoSrc * src)
{
GstPad *targetpad;
gchar *new_gconf_str;
GstState cur, next;
new_gconf_str = gst_gconf_get_string (GST_GCONF_AUDIOSRC_KEY);
if (new_gconf_str != NULL && src->gconf_str != NULL &&
(strlen (new_gconf_str) == 0 ||
strcmp (src->gconf_str, new_gconf_str) == 0)) {
g_free (new_gconf_str);
GST_DEBUG_OBJECT (src, "GConf key was updated, but it didn't change");
return TRUE;
}
GST_OBJECT_LOCK (src);
cur = GST_STATE (src);
next = GST_STATE_PENDING (src);
GST_OBJECT_UNLOCK (src);
if (cur >= GST_STATE_READY || next == GST_STATE_PAUSED) {
GST_DEBUG_OBJECT (src, "already running, ignoring GConf change");
g_free (new_gconf_str);
return TRUE;
}
g_free (src->gconf_str);
src->gconf_str = new_gconf_str;
/* kill old element */
if (src->kid) {
GST_DEBUG_OBJECT (src, "Removing old kid");
gst_element_set_state (src->kid, GST_STATE_NULL);
gst_bin_remove (GST_BIN (src), src->kid);
src->kid = NULL;
}
GST_DEBUG_OBJECT (src, "Creating new kid");
if (!(src->kid = gst_gconf_get_default_video_src ())) {
GST_ELEMENT_ERROR (src, LIBRARY, SETTINGS, (NULL),
("Failed to render video source from GConf"));
g_free (src->gconf_str);
src->gconf_str = NULL;
return FALSE;
}
gst_element_set_state (src->kid, GST_STATE (src));
gst_bin_add (GST_BIN (src), src->kid);
/* re-attach ghostpad */
GST_DEBUG_OBJECT (src, "Creating new ghostpad");
targetpad = gst_element_get_static_pad (src->kid, "src");
gst_ghost_pad_set_target (GST_GHOST_PAD (src->pad), targetpad);
gst_object_unref (targetpad);
GST_DEBUG_OBJECT (src, "done changing gconf video source");
return TRUE;
}
static void
gst_gio_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstGioSrc *src = GST_GIO_SRC (object);
switch (prop_id) {
case PROP_LOCATION:{
const gchar *uri = NULL;
if (GST_STATE (src) == GST_STATE_PLAYING ||
GST_STATE (src) == GST_STATE_PAUSED) {
GST_WARNING
("Setting a new location or GFile not supported in PLAYING or PAUSED state");
break;
}
GST_OBJECT_LOCK (GST_OBJECT (src));
if (src->file)
g_object_unref (src->file);
uri = g_value_get_string (value);
if (uri) {
src->file = g_file_new_for_uri (uri);
if (!src->file) {
GST_ERROR ("Could not create GFile for URI '%s'", uri);
}
} else {
src->file = NULL;
}
GST_OBJECT_UNLOCK (GST_OBJECT (src));
break;
}
case PROP_FILE:
if (GST_STATE (src) == GST_STATE_PLAYING ||
GST_STATE (src) == GST_STATE_PAUSED) {
GST_WARNING
("Setting a new location or GFile not supported in PLAYING or PAUSED state");
break;
}
GST_OBJECT_LOCK (GST_OBJECT (src));
if (src->file)
g_object_unref (src->file);
src->file = g_value_dup_object (value);
GST_OBJECT_UNLOCK (GST_OBJECT (src));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_gnome_vfs_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstGnomeVFSSrc *src;
src = GST_GNOME_VFS_SRC (object);
switch (prop_id) {
case ARG_LOCATION:{
const gchar *new_location;
/* the element must be stopped or paused in order to do this */
if (GST_STATE (src) == GST_STATE_PLAYING ||
GST_STATE (src) == GST_STATE_PAUSED)
break;
if (src->uri) {
gnome_vfs_uri_unref (src->uri);
src->uri = NULL;
}
if (src->uri_name) {
g_free (src->uri_name);
src->uri_name = NULL;
}
new_location = g_value_get_string (value);
if (new_location) {
src->uri_name = gst_gnome_vfs_location_to_uri_string (new_location);
src->uri = gnome_vfs_uri_new (src->uri_name);
}
break;
}
case ARG_HANDLE:
if (GST_STATE (src) == GST_STATE_NULL ||
GST_STATE (src) == GST_STATE_READY) {
if (src->uri) {
gnome_vfs_uri_unref (src->uri);
src->uri = NULL;
}
if (src->uri_name) {
g_free (src->uri_name);
src->uri_name = NULL;
}
src->handle = g_value_get_boxed (value);
}
break;
case ARG_IRADIO_MODE:
src->iradio_mode = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_gnome_vfs_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
{
GstGnomeVFSSrc *src = GST_GNOME_VFS_SRC (handler);
if (GST_STATE (src) == GST_STATE_PLAYING ||
GST_STATE (src) == GST_STATE_PAUSED)
return FALSE;
g_object_set (G_OBJECT (src), "location", uri, NULL);
return TRUE;
}
static gboolean
rb_daap_src_uri_set_uri (GstURIHandler *handler,
const gchar *uri)
{
RBDAAPSrc *src = RB_DAAP_SRC (handler);
if (GST_STATE (src) == GST_STATE_PLAYING || GST_STATE (src) == GST_STATE_PAUSED) {
return FALSE;
}
g_object_set (G_OBJECT (src), "location", uri, NULL);
return TRUE;
}
static gboolean
gst_auto_audio_sink_detect (GstAutoAudioSink * sink)
{
GstElement *esink;
GstPad *targetpad;
gst_auto_audio_sink_clear_kid (sink);
/* find element */
GST_DEBUG_OBJECT (sink, "Creating new kid");
if (!(esink = gst_auto_audio_sink_find_best (sink)))
goto no_sink;
g_object_set (G_OBJECT (esink), "ts-offset", sink->ts_offset, NULL);
sink->kid = esink;
/* Ensure the child is brought up to the right state to match the parent
* although it's currently always in READY and
* we're always doing NULL->READY. */
if (GST_STATE (sink->kid) < GST_STATE (sink))
gst_element_set_state (sink->kid, GST_STATE (sink));
gst_bin_add (GST_BIN (sink), esink);
/* attach ghost pad */
GST_DEBUG_OBJECT (sink, "Re-assigning ghostpad");
targetpad = gst_element_get_static_pad (sink->kid, "sink");
if (!gst_ghost_pad_set_target (GST_GHOST_PAD (sink->pad), targetpad))
goto target_failed;
gst_object_unref (targetpad);
GST_DEBUG_OBJECT (sink, "done changing auto audio sink");
return TRUE;
/* ERRORS */
no_sink:
{
GST_ELEMENT_ERROR (sink, LIBRARY, INIT, (NULL),
("Failed to find a supported audio sink"));
return FALSE;
}
target_failed:
{
GST_ELEMENT_ERROR (sink, LIBRARY, INIT, (NULL),
("Failed to set target pad"));
gst_object_unref (targetpad);
return FALSE;
}
}
static gboolean
rbspotifysrc_uri_set_uri (GstURIHandler *handler,
const gchar *uri)
{
RBSpotifySrc *src = RBSPOTIFYSRC (handler);
if (GST_STATE (src) == GST_STATE_PLAYING || GST_STATE (src) == GST_STATE_PAUSED) {
return FALSE;
}
g_object_set (G_OBJECT (src), "uri", uri, NULL);
return TRUE;
}
static gboolean
rb_mtp_src_uri_set_uri (GstURIHandler *handler, const gchar *uri)
{
RBMTPSrc *src = RB_MTP_SRC (handler);
if (GST_STATE (src) == GST_STATE_PLAYING || GST_STATE (src) == GST_STATE_PAUSED) {
return FALSE;
}
if (g_str_has_prefix (uri, "xrbmtp://") == FALSE) {
return FALSE;
}
return rb_mtp_src_set_uri (src, uri);
}
static void
kms_audio_mixer_remove_sometimes_src_pad (KmsAudioMixer * self,
GstElement * adder)
{
GstProxyPad *internal;
GstPad *srcpad, *peer;
srcpad = gst_element_get_static_pad (adder, "src");
peer = gst_pad_get_peer (srcpad);
if (peer == NULL)
goto end_phase_1;
internal = gst_proxy_pad_get_internal ((GstProxyPad *) peer);
if (internal == NULL)
goto end_phase_2;
gst_ghost_pad_set_target (GST_GHOST_PAD (internal), NULL);
if (GST_STATE (self) < GST_STATE_PAUSED
|| GST_STATE_PENDING (self) < GST_STATE_PAUSED
|| GST_STATE_TARGET (self) < GST_STATE_PAUSED) {
gst_pad_set_active (GST_PAD (internal), FALSE);
}
GST_DEBUG ("Removing source pad %" GST_PTR_FORMAT, internal);
gst_element_remove_pad (GST_ELEMENT (self), GST_PAD (internal));
gst_object_unref (internal);
end_phase_2:
gst_object_unref (peer);
end_phase_1:
gst_object_unref (srcpad);
}
static gboolean
gst_rtmp_sink_uri_set_uri (GstURIHandler * handler, const gchar * uri)
{
GstRTMPSink *sink = GST_RTMP_SINK (handler);
if (GST_STATE (sink) >= GST_STATE_PAUSED)
return FALSE;
g_free (sink->uri);
sink->uri = NULL;
if (uri != NULL) {
int protocol;
AVal host;
unsigned int port;
AVal playpath, app;
if (!RTMP_ParseURL (uri, &protocol, &host, &port, &playpath, &app) ||
!host.av_len || !playpath.av_len) {
GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE,
("Failed to parse URI %s", uri), (NULL));
return FALSE;
}
sink->uri = g_strdup (uri);
}
GST_DEBUG_OBJECT (sink, "Changed URI to %s", GST_STR_NULL (uri));
return TRUE;
}
static gboolean
do_toggle_element (GstHalAudioSink * sink)
{
GstPad *targetpad;
/* kill old element */
if (sink->kid) {
GST_DEBUG_OBJECT (sink, "Removing old kid");
gst_element_set_state (sink->kid, GST_STATE_NULL);
gst_bin_remove (GST_BIN (sink), sink->kid);
sink->kid = NULL;
}
GST_DEBUG_OBJECT (sink, "Creating new kid");
if (!sink->udi)
GST_INFO_OBJECT (sink, "No UDI set for device, using default one");
if (!(sink->kid = gst_hal_get_audio_sink (sink->udi))) {
GST_ELEMENT_ERROR (sink, LIBRARY, SETTINGS, (NULL),
("Failed to render audio sink from Hal"));
return FALSE;
}
gst_element_set_state (sink->kid, GST_STATE (sink));
gst_bin_add (GST_BIN (sink), sink->kid);
/* re-attach ghostpad */
GST_DEBUG_OBJECT (sink, "Creating new ghostpad");
targetpad = gst_element_get_static_pad (sink->kid, "sink");
gst_ghost_pad_set_target (GST_GHOST_PAD (sink->pad), targetpad);
gst_object_unref (targetpad);
GST_DEBUG_OBJECT (sink, "done changing hal audio sink");
return TRUE;
}
static GstPad *
kms_hub_port_generate_sink_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name, const GstCaps * caps,
GstElement * output)
{
GstPad *output_pad, *pad;
output_pad = gst_element_get_static_pad (output, "sink");
pad = gst_ghost_pad_new_from_template (name, output_pad, templ);
g_object_unref (output_pad);
if (GST_STATE (element) >= GST_STATE_PAUSED
|| GST_STATE_PENDING (element) >= GST_STATE_PAUSED
|| GST_STATE_TARGET (element) >= GST_STATE_PAUSED) {
gst_pad_set_active (pad, TRUE);
}
if (gst_element_add_pad (element, pad))
return pad;
GST_ERROR_OBJECT (element, "Cannot add pad %" GST_PTR_FORMAT, pad);
g_object_unref (pad);
return NULL;
}
//FIXME this should be part of the library
void
shmdata_base_reader_clean_element (GstElement *element)
{
if (element != NULL && GST_IS_ELEMENT(element)
&& GST_STATE_CHANGE_FAILURE != GST_STATE_RETURN(element)) {
{ // unlinking pads
GstIterator *pad_iter = gst_element_iterate_pads(element);
gst_iterator_foreach(pad_iter, (GFunc) shmdata_base_reader_unlink_pad, NULL);
gst_iterator_free(pad_iter);
}
{ // releasing request pads
GstIterator *pad_iter = gst_element_iterate_pads(element);
gst_iterator_foreach(pad_iter,
(GFunc) shmdata_base_reader_release_request_pad,
element);
gst_iterator_free(pad_iter);
}
GstState state = GST_STATE_TARGET(element);
if (state != GST_STATE_NULL) {
if (GST_STATE_CHANGE_ASYNC ==
gst_element_set_state(element, GST_STATE_NULL)) {
while (GST_STATE(element) != GST_STATE_NULL) {
// warning this may be blocking
gst_element_get_state(element, NULL, NULL,
GST_CLOCK_TIME_NONE);
}
}
}
if (GST_IS_BIN(gst_element_get_parent(element)))
gst_bin_remove(GST_BIN(gst_element_get_parent(element)), element);
else
gst_object_unref(element);
}
}
static gboolean
kms_base_hub_create_and_link_ghost_pad (KmsBaseHub * mixer,
GstPad * src_pad, const gchar * gp_name, const gchar * gp_template_name,
GstPad * target)
{
GstPadTemplate *templ;
GstPad *gp;
gboolean ret;
templ =
gst_element_class_get_pad_template (GST_ELEMENT_CLASS
(G_OBJECT_GET_CLASS (mixer)), gp_template_name);
gp = gst_ghost_pad_new_from_template (gp_name, target, templ);
if (GST_STATE (mixer) >= GST_STATE_PAUSED
|| GST_STATE_PENDING (mixer) >= GST_STATE_PAUSED
|| GST_STATE_TARGET (mixer) >= GST_STATE_PAUSED) {
gst_pad_set_active (gp, TRUE);
}
ret = gst_element_add_pad (GST_ELEMENT (mixer), gp);
if (ret) {
gst_pad_link (src_pad, gp);
} else {
g_object_unref (gp);
}
return ret;
}
static void
gst_msdkdec_mpeg2_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstMsdkMPEG2Dec *thiz = GST_MSDKMPEG2DEC (object);
GstState state;
GST_OBJECT_LOCK (thiz);
state = GST_STATE (thiz);
if (!gst_msdkdec_prop_check_state (state, pspec)) {
GST_WARNING_OBJECT (thiz, "setting property in wrong state");
GST_OBJECT_UNLOCK (thiz);
return;
}
switch (prop_id) {
case GST_MSDKDEC_PROP_OUTPUT_ORDER:
thiz->output_order = g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
GST_OBJECT_UNLOCK (thiz);
return;
}
static void
set_property(GObject *obj,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GstDspVEnc *self = GST_DSP_VENC(obj);
switch (prop_id) {
case ARG_QUALITY: {
if (GST_STATE(self) == GST_STATE_NULL) {
guint quality;
quality = g_value_get_uint(value);
g_atomic_int_set(&self->quality, quality);
} else {
GST_WARNING_OBJECT(self,
"encoding quality property can be set only in NULL state");
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, pspec);
break;
}
}
static void
gst_fd_src_set_property (GObject * object, guint prop_id, const GValue * value,
GParamSpec * pspec)
{
GstFdSrc *src = GST_FD_SRC (object);
switch (prop_id) {
case PROP_FD:
src->new_fd = g_value_get_int (value);
/* If state is ready or below, update the current fd immediately
* so it is reflected in get_properties and uri */
GST_OBJECT_LOCK (object);
if (GST_STATE (GST_ELEMENT (src)) <= GST_STATE_READY) {
GST_DEBUG_OBJECT (src, "state ready or lower, updating to use new fd");
gst_fd_src_update_fd (src);
} else {
GST_DEBUG_OBJECT (src, "state above ready, not updating to new fd yet");
}
GST_OBJECT_UNLOCK (object);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_rtmp_src_uri_set_uri (GstURIHandler * handler, const gchar * uri,
GError ** error)
{
GstRTMPSrc *src = GST_RTMP_SRC (handler);
if (GST_STATE (src) >= GST_STATE_PAUSED) {
g_set_error (error, GST_URI_ERROR, GST_URI_ERROR_BAD_STATE,
"Changing the URI on rtmpsrc when it is running is not supported");
return FALSE;
}
g_free (src->uri);
src->uri = NULL;
if (uri != NULL) {
int protocol;
AVal host;
unsigned int port;
AVal playpath, app;
if (!RTMP_ParseURL (uri, &protocol, &host, &port, &playpath, &app) ||
!host.av_len || !playpath.av_len) {
GST_ERROR_OBJECT (src, "Failed to parse URI %s", uri);
g_set_error (error, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,
"Could not parse RTMP URI");
return FALSE;
}
src->uri = g_strdup (uri);
}
GST_DEBUG_OBJECT (src, "Changed URI to %s", GST_STR_NULL (uri));
return TRUE;
}
static gboolean
_send_event (GstElement * element, GstEvent * event)
{
GstAggregator *self = GST_AGGREGATOR (element);
GST_STATE_LOCK (element);
if (GST_EVENT_TYPE (event) == GST_EVENT_SEEK &&
GST_STATE (element) < GST_STATE_PAUSED) {
gdouble rate;
GstFormat fmt;
GstSeekFlags flags;
GstSeekType start_type, stop_type;
gint64 start, stop;
gst_event_parse_seek (event, &rate, &fmt, &flags, &start_type,
&start, &stop_type, &stop);
gst_segment_do_seek (&self->segment, rate, fmt, flags, start_type, start,
stop_type, stop, NULL);
self->priv->seqnum = gst_event_get_seqnum (event);
GST_DEBUG_OBJECT (element, "Storing segment %" GST_PTR_FORMAT, event);
}
GST_STATE_UNLOCK (element);
return GST_ELEMENT_CLASS (aggregator_parent_class)->send_event (element,
event);
}
void MediaPlayer::pause()
{
GstState state = GST_STATE(m_gst_pipeline);
if ( state != GST_STATE_PAUSED )
setPipelineState( GST_STATE_PAUSED );
}
static gboolean
gst_rtmp_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
{
GstRTMPSrc *src = GST_RTMP_SRC (handler);
if (GST_STATE (src) >= GST_STATE_PAUSED)
return FALSE;
g_free (src->uri);
src->uri = NULL;
if (uri != NULL) {
int protocol;
AVal host;
unsigned int port;
AVal playpath, app;
if (!RTMP_ParseURL (uri, &protocol, &host, &port, &playpath, &app) ||
!host.av_len || !playpath.av_len) {
GST_ERROR_OBJECT (src, "Failed to parse URI %s", uri);
return FALSE;
}
src->uri = g_strdup (uri);
}
GST_DEBUG_OBJECT (src, "Changed URI to %s", GST_STR_NULL (uri));
return TRUE;
}
static gboolean
gst_fd_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
{
gchar *protocol;
GstFdSrc *src = GST_FD_SRC (handler);
gint fd;
protocol = gst_uri_get_protocol (uri);
if (strcmp (protocol, "fd") != 0) {
g_free (protocol);
return FALSE;
}
g_free (protocol);
if (sscanf (uri, "fd://%d", &fd) != 1 || fd < 0)
return FALSE;
src->new_fd = fd;
GST_OBJECT_LOCK (src);
if (GST_STATE (GST_ELEMENT (src)) <= GST_STATE_READY) {
gst_fd_src_update_fd (src);
}
GST_OBJECT_UNLOCK (src);
return TRUE;
}
static void
pragha_backend_set_target_state (PraghaBackend *backend, GstState target_state)
{
GstStateChangeReturn ret;
PraghaBackendPrivate *priv = backend->priv;
GstState old_state = priv->target_state;
priv->target_state = target_state;
ret = gst_element_set_state(priv->pipeline, target_state);
switch (ret) {
case GST_STATE_CHANGE_SUCCESS:
if (target_state == GST_STATE_READY)
pragha_backend_evaluate_state(old_state,
GST_STATE (priv->pipeline),
GST_STATE_PENDING (priv->pipeline),
backend);
break;
case GST_STATE_CHANGE_NO_PREROLL:
if (target_state == GST_STATE_PLAYING)
priv->is_live = TRUE;
break;
default:
break;
}
g_object_notify_by_pspec (G_OBJECT (backend), properties[PROP_TARGET_STATE]);
}
