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]); }