static void gst_app_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAppSink *appsink = GST_APP_SINK_CAST (object); switch (prop_id) { case PROP_CAPS: gst_app_sink_set_caps (appsink, gst_value_get_caps (value)); break; case PROP_EMIT_SIGNALS: gst_app_sink_set_emit_signals (appsink, g_value_get_boolean (value)); break; case PROP_MAX_BUFFERS: gst_app_sink_set_max_buffers (appsink, g_value_get_uint (value)); break; case PROP_DROP: gst_app_sink_set_drop (appsink, g_value_get_boolean (value)); break; case PROP_WAIT_ON_EOS: gst_app_sink_set_wait_on_eos (appsink, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_auto_video_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAutoVideoSink *sink = GST_AUTO_VIDEO_SINK (object); switch (prop_id) { case PROP_CAPS: if (sink->filter_caps) gst_caps_unref (sink->filter_caps); sink->filter_caps = gst_caps_copy (gst_value_get_caps (value)); break; case PROP_TS_OFFSET: sink->ts_offset = g_value_get_int64 (value); if (sink->kid) g_object_set_property (G_OBJECT (sink->kid), pspec->name, value); break; case PROP_SYNC: sink->sync = g_value_get_boolean (value); if (sink->kid) g_object_set_property (G_OBJECT (sink->kid), pspec->name, value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_audiomixer_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAudioMixer *audiomixer = GST_AUDIO_MIXER (object); switch (prop_id) { case PROP_FILTER_CAPS:{ GstCaps *new_caps = NULL; GstCaps *old_caps; const GstCaps *new_caps_val = gst_value_get_caps (value); if (new_caps_val != NULL) { new_caps = (GstCaps *) new_caps_val; gst_caps_ref (new_caps); } GST_OBJECT_LOCK (audiomixer); old_caps = audiomixer->filter_caps; audiomixer->filter_caps = new_caps; GST_OBJECT_UNLOCK (audiomixer); if (old_caps) gst_caps_unref (old_caps); GST_DEBUG_OBJECT (audiomixer, "set new caps %" GST_PTR_FORMAT, new_caps); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_multi_file_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMultiFileSrc *src = GST_MULTI_FILE_SRC (object); switch (prop_id) { case ARG_LOCATION: gst_multi_file_src_set_location (src, g_value_get_string (value)); break; case ARG_INDEX: src->index = g_value_get_int (value); break; case ARG_CAPS: { const GstCaps *caps = gst_value_get_caps (value); GstCaps *new_caps; if (caps == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (caps); } gst_caps_replace (&src->caps, new_caps); gst_pad_set_caps (GST_BASE_SRC_PAD (src), new_caps); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_app_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAppSrc *appsrc = GST_APP_SRC (object); switch (prop_id) { case PROP_CAPS: gst_app_src_set_caps (appsrc, gst_value_get_caps (value)); break; case PROP_SIZE: gst_app_src_set_size (appsrc, g_value_get_int64 (value)); break; case PROP_STREAM_TYPE: gst_app_src_set_stream_type (appsrc, g_value_get_enum (value)); break; case PROP_MAX_BYTES: gst_app_src_set_max_bytes (appsrc, g_value_get_uint64 (value)); break; case PROP_FORMAT: appsrc->format = g_value_get_enum (value); break; case PROP_BLOCK: appsrc->block = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static gboolean missing_structure_get_caps_detail (const GstStructure * s, GstCaps ** p_caps) { const GstCaps *caps; const GValue *val; GType detail_type; *p_caps = NULL; detail_type = gst_structure_get_field_type (s, "detail"); if (!g_type_is_a (detail_type, GST_TYPE_CAPS)) { GST_WARNING ("expected 'detail' field to be of GST_TYPE_CAPS"); return FALSE; } val = gst_structure_get_value (s, "detail"); caps = gst_value_get_caps (val); if (gst_caps_is_empty (caps) || gst_caps_is_any (caps)) { GST_WARNING ("EMPTY or ANY caps not allowed"); return FALSE; } *p_caps = gst_caps_copy (caps); return TRUE; }
static void gst_capsfilter_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstCapsFilter *capsfilter = GST_CAPSFILTER (object); switch (prop_id) { case PROP_FILTER_CAPS:{ GstCaps *new_caps; GstCaps *old_caps; const GstCaps *new_caps_val = gst_value_get_caps (value); if (new_caps_val == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = (GstCaps *) new_caps_val; gst_caps_ref (new_caps); } old_caps = capsfilter->filter_caps; capsfilter->filter_caps = new_caps; gst_caps_unref (old_caps); GST_DEBUG_OBJECT (capsfilter, "set new caps %" GST_PTR_FORMAT, new_caps); /* FIXME: Need to activate these caps on the pads * http://bugzilla.gnome.org/show_bug.cgi?id=361718 */ break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_multi_file_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMultiFileSrc *src = GST_MULTI_FILE_SRC (object); switch (prop_id) { case PROP_LOCATION: gst_multi_file_src_set_location (src, g_value_get_string (value)); break; case PROP_INDEX: GST_OBJECT_LOCK (src); /* index was really meant to be read-only, but for backwards-compatibility * we set start_index to make it work as it used to */ if (!GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_FLAG_STARTED)) src->start_index = g_value_get_int (value); else src->index = g_value_get_int (value); GST_OBJECT_UNLOCK (src); break; case PROP_START_INDEX: src->start_index = g_value_get_int (value); break; case PROP_STOP_INDEX: src->stop_index = g_value_get_int (value); break; case PROP_CAPS: { GstStructure *st = NULL; const GstCaps *caps = gst_value_get_caps (value); GstCaps *new_caps; if (caps == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (caps); } gst_caps_replace (&src->caps, new_caps); gst_pad_set_caps (GST_BASE_SRC_PAD (src), new_caps); if (new_caps && gst_caps_get_size (new_caps) == 1 && (st = gst_caps_get_structure (new_caps, 0)) && gst_structure_get_fraction (st, "framerate", &src->fps_n, &src->fps_d)) { GST_INFO_OBJECT (src, "Seting framerate to %d/%d", src->fps_n, src->fps_d); } else { src->fps_n = -1; src->fps_d = -1; } } break; case PROP_LOOP: src->loop = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_caps_setter_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstCapsSetter *filter; g_return_if_fail (GST_IS_CAPS_SETTER (object)); filter = GST_CAPS_SETTER (object); switch (prop_id) { case PROP_CAPS:{ GstCaps *new_caps; const GstCaps *new_caps_val = gst_value_get_caps (value); gint i; if (new_caps_val == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (new_caps_val); } for (i = 0; new_caps && (i < gst_caps_get_size (new_caps)); ++i) { GstStructure *s; s = gst_caps_get_structure (new_caps, i); if (!gst_structure_foreach (s, gst_caps_is_fixed_foreach, NULL)) { GST_ERROR_OBJECT (filter, "rejected unfixed caps: %" GST_PTR_FORMAT, new_caps); gst_caps_unref (new_caps); new_caps = NULL; break; } } if (new_caps) { GST_OBJECT_LOCK (filter); gst_caps_replace (&filter->caps, new_caps); /* drop extra ref */ gst_caps_unref (new_caps); GST_OBJECT_UNLOCK (filter); GST_DEBUG_OBJECT (filter, "set new caps %" GST_PTR_FORMAT, new_caps); } /* try to activate these new caps next time around */ gst_base_transform_reconfigure (GST_BASE_TRANSFORM (filter)); break; } case PROP_JOIN: filter->join = g_value_get_boolean (value); break; case PROP_REPLACE: filter->replace = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GstCaps * gst_rtp_mux_getcaps (GstPad * pad, GstRTPMux * mux, GstCaps * filter) { GstCaps *caps = NULL; GstIterator *iter = NULL; GValue v = { 0 }; GstIteratorResult res; GstCaps *peercaps; GstCaps *othercaps; GstCaps *tcaps; GstCaps *other_filtered; peercaps = gst_pad_peer_query_caps (mux->srcpad, filter); if (peercaps) { tcaps = gst_pad_get_pad_template_caps (pad); othercaps = gst_caps_intersect_full (peercaps, tcaps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (peercaps); } else { tcaps = gst_pad_get_pad_template_caps (mux->srcpad); if (filter) othercaps = gst_caps_intersect_full (filter, tcaps, GST_CAPS_INTERSECT_FIRST); else othercaps = gst_caps_copy (tcaps); } gst_caps_unref (tcaps); clear_caps (othercaps, FALSE); other_filtered = gst_caps_copy (othercaps); clear_caps (other_filtered, TRUE); g_value_init (&v, GST_TYPE_CAPS); iter = gst_element_iterate_sink_pads (GST_ELEMENT (mux)); do { gst_value_set_caps (&v, other_filtered); res = gst_iterator_fold (iter, same_clock_rate_fold, &v, pad); gst_iterator_resync (iter); } while (res == GST_ITERATOR_RESYNC); gst_iterator_free (iter); gst_caps_unref (other_filtered); caps = gst_caps_intersect ((GstCaps *) gst_value_get_caps (&v), othercaps); g_value_unset (&v); gst_caps_unref (othercaps); if (res == GST_ITERATOR_ERROR) { gst_caps_unref (caps); caps = gst_caps_new_empty (); } return caps; }
static void gst_base_camera_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstBaseCameraSrc *self = GST_BASE_CAMERA_SRC (object); switch (prop_id) { case PROP_MODE: gst_base_camera_src_set_mode (GST_BASE_CAMERA_SRC (self), g_value_get_enum (value)); break; case PROP_ZOOM:{ self->zoom = g_value_get_float (value); /* limit to max-zoom */ if (self->zoom > self->max_zoom) { GST_DEBUG_OBJECT (self, "Clipping zoom %f to max-zoom %f", self->zoom, self->max_zoom); self->zoom = self->max_zoom; } /* does not set it if in NULL, the src is not created yet */ if (GST_STATE (self) != GST_STATE_NULL) gst_base_camera_src_setup_zoom (self); break; } case PROP_POST_PREVIEW: self->post_preview = g_value_get_boolean (value); break; case PROP_PREVIEW_CAPS:{ GstCaps *new_caps = NULL; new_caps = (GstCaps *) gst_value_get_caps (value); if (!gst_caps_is_equal (self->preview_caps, new_caps)) { gst_caps_replace (&self->preview_caps, new_caps); gst_base_camera_src_setup_preview (self, new_caps); } else { GST_DEBUG_OBJECT (self, "New preview caps equal current preview caps"); } } break; case PROP_PREVIEW_FILTER: if (self->preview_filter) gst_object_unref (self->preview_filter); self->preview_filter = g_value_dup_object (value); if (!gst_camerabin_preview_set_filter (self->preview_pipeline, self->preview_filter)) { GST_WARNING_OBJECT (self, "Cannot change preview filter, is element in NULL state?"); } break; case PROP_AUTO_START: self->auto_start = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (self, prop_id, pspec); break; } }
static void kms_element_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { KmsElement *self = KMS_ELEMENT (object); switch (property_id) { case PROP_ACCEPT_EOS: KMS_ELEMENT_LOCK (self); self->priv->accept_eos = g_value_get_boolean (value); KMS_ELEMENT_UNLOCK (self); break; case PROP_AUDIO_CAPS: kms_element_endpoint_set_caps (self, gst_value_get_caps (value), &self->priv->audio_caps); break; case PROP_VIDEO_CAPS: kms_element_endpoint_set_caps (self, gst_value_get_caps (value), &self->priv->video_caps); break; case PROP_TARGET_BITRATE: KMS_ELEMENT_LOCK (self); self->priv->target_bitrate = g_value_get_int (value); g_object_set (G_OBJECT (kms_element_get_video_agnosticbin (self)), DEFAULT_BITRATE_, self->priv->target_bitrate, NULL); KMS_ELEMENT_UNLOCK (self); break; case PROP_MEDIA_STATS:{ gboolean enable = g_value_get_boolean (value); KMS_ELEMENT_LOCK (self); if (enable != self->priv->stats_enabled) { self->priv->stats_enabled = enable; KMS_ELEMENT_GET_CLASS (self)->collect_media_stats (self, enable); } KMS_ELEMENT_UNLOCK (self); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
/* * Set the value of a property for the client src. */ static void gst_dccp_client_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstDCCPClientSrc *src = GST_DCCP_CLIENT_SRC (object); switch (prop_id) { case PROP_PORT: src->port = g_value_get_int (value); break; case PROP_HOST: if (!g_value_get_string (value)) { g_warning ("host property cannot be NULL"); break; } g_free (src->host); src->host = g_strdup (g_value_get_string (value)); break; case PROP_SOCK_FD: src->sock_fd = g_value_get_int (value); break; case PROP_CLOSED: src->closed = g_value_get_boolean (value); break; case PROP_CCID: src->ccid = g_value_get_int (value); break; case PROP_CAPS: { const GstCaps *new_caps_val = gst_value_get_caps (value); GstCaps *new_caps; GstCaps *old_caps; if (new_caps_val == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (new_caps_val); } old_caps = src->caps; src->caps = new_caps; if (old_caps) gst_caps_unref (old_caps); gst_pad_set_caps (GST_BASE_SRC (src)->srcpad, new_caps); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_app_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAppSrc *appsrc = GST_APP_SRC_CAST (object); GstAppSrcPrivate *priv = appsrc->priv; switch (prop_id) { case PROP_CAPS: gst_app_src_set_caps (appsrc, gst_value_get_caps (value)); break; case PROP_SIZE: gst_app_src_set_size (appsrc, g_value_get_int64 (value)); break; case PROP_STREAM_TYPE: gst_app_src_set_stream_type (appsrc, g_value_get_enum (value)); break; case PROP_MAX_BYTES: gst_app_src_set_max_bytes (appsrc, g_value_get_uint64 (value)); break; case PROP_FORMAT: priv->format = g_value_get_enum (value); break; case PROP_BLOCK: priv->block = g_value_get_boolean (value); break; case PROP_IS_LIVE: gst_base_src_set_live (GST_BASE_SRC (appsrc), g_value_get_boolean (value)); break; case PROP_MIN_LATENCY: gst_app_src_set_latencies (appsrc, TRUE, g_value_get_int64 (value), FALSE, -1); break; case PROP_MAX_LATENCY: gst_app_src_set_latencies (appsrc, FALSE, -1, TRUE, g_value_get_int64 (value)); break; case PROP_EMIT_SIGNALS: gst_app_src_set_emit_signals (appsrc, g_value_get_boolean (value)); break; case PROP_MIN_PERCENT: priv->min_percent = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void _encoding_profile_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstEncodingProfile *prof = (GstEncodingProfile *) object; switch (prop_id) { case PROP_RESTRICTION_CAPS: gst_encoding_profile_set_restriction (prof, gst_caps_copy (gst_value_get_caps (value))); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_auto_audio_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAutoAudioSink *sink = GST_AUTO_AUDIO_SINK (object); switch (prop_id) { case PROP_CAPS: if (sink->filter_caps) gst_caps_unref (sink->filter_caps); sink->filter_caps = gst_caps_copy (gst_value_get_caps (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_app_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAppSink *appsink = GST_APP_SINK (object); //printf("appsinksetproperty\n"); switch (prop_id) { case PROP_CAPS: gst_app_sink_set_caps (appsink, gst_value_get_caps (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void ges_track_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { GESTrack *track = GES_TRACK (object); switch (property_id) { case ARG_CAPS: ges_track_set_caps (track, gst_value_get_caps (value)); break; case ARG_TYPE: track->type = g_value_get_flags (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static void g_cclosure_user_marshal_VOID__OBJECT_GST_CAPS (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) { typedef void (*GMarshalFunc_VOID__OBJECT_GST_CAPS) (gpointer data1, gpointer arg_1, gpointer arg_2, gpointer data2); register GMarshalFunc_VOID__OBJECT_GST_CAPS callback; register GCClosure * cc; register gpointer data1, data2; cc = (GCClosure *) closure; g_return_if_fail (n_param_values == 3); if (G_CCLOSURE_SWAP_DATA (closure)) { data1 = closure->data; data2 = param_values->data[0].v_pointer; } else { data1 = param_values->data[0].v_pointer; data2 = closure->data; } callback = (GMarshalFunc_VOID__OBJECT_GST_CAPS) (marshal_data ? marshal_data : cc->callback); callback (data1, g_value_get_object (param_values + 1), gst_value_get_caps (param_values + 2), data2); }
static void gst_auto_video_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAutoVideoSrc *src = GST_AUTO_VIDEO_SRC (object); switch (prop_id) { case PROP_CAPS: if (src->filter_caps) gst_caps_unref (src->filter_caps); src->filter_caps = gst_caps_copy (gst_value_get_caps (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void shell_recorder_src_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { ShellRecorderSrc *src = SHELL_RECORDER_SRC (object); switch (prop_id) { case PROP_CAPS: shell_recorder_src_set_caps (src, gst_value_get_caps (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gnl_object_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GnlObject *gnlobject = (GnlObject *) object; g_return_if_fail (GNL_IS_OBJECT (object)); switch (prop_id) { case PROP_START: gnlobject->start = g_value_get_uint64 (value); update_values (gnlobject); break; case PROP_DURATION: gnlobject->duration = g_value_get_int64 (value); update_values (gnlobject); break; case PROP_MEDIA_START: gnlobject->media_start = g_value_get_uint64 (value); break; case PROP_MEDIA_DURATION: gnlobject->media_duration = g_value_get_int64 (value); update_values (gnlobject); break; case PROP_PRIORITY: gnlobject->priority = g_value_get_uint (value); break; case PROP_ACTIVE: gnlobject->active = g_value_get_boolean (value); break; case PROP_CAPS: gnl_object_set_caps (gnlobject, gst_value_get_caps (value)); break; case PROP_EXPANDABLE: if (g_value_get_boolean (value)) GST_OBJECT_FLAG_SET (gnlobject, GNL_OBJECT_EXPANDABLE); else GST_OBJECT_FLAG_UNSET (gnlobject, GNL_OBJECT_EXPANDABLE); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void nle_object_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { NleObject *nleobject = (NleObject *) object; g_return_if_fail (NLE_IS_OBJECT (object)); GST_OBJECT_LOCK (object); switch (prop_id) { case PROP_START: SET_PENDING_VALUE (start, "start", uint64, G_GUINT64_FORMAT); break; case PROP_DURATION: SET_PENDING_VALUE (duration, "duration", int64, G_GINT64_FORMAT); break; case PROP_INPOINT: SET_PENDING_VALUE (inpoint, "inpoint", uint64, G_GUINT64_FORMAT); break; case PROP_PRIORITY: SET_PENDING_VALUE (priority, "priority", uint, G_GUINT32_FORMAT); break; case PROP_ACTIVE: SET_PENDING_VALUE (active, "active", boolean, G_GUINT32_FORMAT); break; case PROP_IS_LIVE: nleobject->is_live = g_value_get_boolean (value); break; case PROP_CAPS: nle_object_set_caps (nleobject, gst_value_get_caps (value)); break; case PROP_EXPANDABLE: if (g_value_get_boolean (value)) GST_OBJECT_FLAG_SET (nleobject, NLE_OBJECT_EXPANDABLE); else GST_OBJECT_FLAG_UNSET (nleobject, NLE_OBJECT_EXPANDABLE); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } GST_OBJECT_UNLOCK (object); }
RBGstMediaType rb_gst_get_missing_plugin_type (const GstStructure *structure) { const char *media_type; const char *missing_type; const GstCaps *caps; const GValue *val; int i; if (structure == NULL) { rb_debug ("no missing plugin details"); return MEDIA_TYPE_NONE; } missing_type = gst_structure_get_string (structure, "type"); if (missing_type == NULL || strcmp (missing_type, "decoder") != 0) { rb_debug ("missing plugin is not a decoder"); return MEDIA_TYPE_NONE; } val = gst_structure_get_value (structure, "detail"); caps = gst_value_get_caps (val); media_type = gst_structure_get_name (gst_caps_get_structure (caps, 0)); for (i = 0; i < G_N_ELEMENTS (container_formats); i++) { if (strcmp (media_type, container_formats[i]) == 0) { rb_debug ("missing plugin is a container demuxer"); return MEDIA_TYPE_CONTAINER; } } if (g_str_has_prefix (media_type, "audio/")) { rb_debug ("missing plugin is an audio decoder"); return MEDIA_TYPE_AUDIO; } else if (g_str_has_prefix (media_type, "video/")) { rb_debug ("missing plugin is (probably) a video decoder"); return MEDIA_TYPE_VIDEO; } else { rb_debug ("missing plugin is neither a video nor audio decoder"); return MEDIA_TYPE_OTHER; } }
void _owr_deep_notify(GObject *object, GstObject *orig, GParamSpec *pspec, gpointer user_data) { GValue value = G_VALUE_INIT; gchar *str = NULL; GstObject *it; gchar *prevpath, *path; OWR_UNUSED(user_data); OWR_UNUSED(object); path = g_strdup(""); for (it = orig; GST_IS_OBJECT(it); it = GST_OBJECT_PARENT(it)) { prevpath = path; path = g_strjoin("/", GST_OBJECT_NAME(it), prevpath, NULL); g_free(prevpath); } if (pspec->flags & G_PARAM_READABLE) { g_value_init(&value, pspec->value_type); g_object_get_property(G_OBJECT(orig), pspec->name, &value); if (G_VALUE_TYPE(&value) == GST_TYPE_CAPS) str = gst_caps_to_string(gst_value_get_caps(&value)); else if (G_VALUE_HOLDS_STRING(&value)) str = g_value_dup_string(&value); else str = gst_value_serialize(&value); GST_INFO_OBJECT(object, "%s%s = %s\n", path, pspec->name, str); g_free(str); g_value_unset(&value); } else GST_INFO_OBJECT(object, "Parameter %s not readable in %s.", pspec->name, path); g_free(path); }
static void gst_capsfilter_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstCapsFilter *capsfilter = GST_CAPSFILTER (object); switch (prop_id) { case PROP_FILTER_CAPS:{ GstCaps *new_caps; GstCaps *old_caps; const GstCaps *new_caps_val = gst_value_get_caps (value); if (new_caps_val == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = (GstCaps *) new_caps_val; gst_caps_ref (new_caps); } GST_OBJECT_LOCK (capsfilter); old_caps = capsfilter->filter_caps; capsfilter->filter_caps = new_caps; GST_OBJECT_UNLOCK (capsfilter); gst_caps_unref (old_caps); GST_DEBUG_OBJECT (capsfilter, "set new caps %" GST_PTR_FORMAT, new_caps); gst_base_transform_reconfigure_sink (GST_BASE_TRANSFORM (object)); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
// make json formated description void Property::make_description() { if (nullptr == property_) { g_warning("%s: cannot make description from a nullptr property", __PRETTY_FUNCTION__); return; } GValue value = G_VALUE_INIT; g_value_init(&value, property_->value_type); g_object_get_property(object_, property_->name, &value); json_description_->reset(); json_description_->begin_object(); // long name json_description_->add_string_member("name", long_name_.c_str()); // name json_description_->add_string_member("id", name_.c_str()); // nickname // json_description_->add_string_member ("nickname", g_param_spec_get_nick (property_)); // short description json_description_->add_string_member("description", g_param_spec_get_blurb(property_)); json_description_->add_string_member("parent", get_category().c_str()); json_description_->add_int_member("order", get_position_weight()); // name // json_description_->add_string_member ("internal name", g_param_spec_get_name (property_)); if (property_->flags &G_PARAM_WRITABLE) json_description_->add_string_member("writable", "true"); else json_description_->add_string_member("writable", "false"); switch (G_VALUE_TYPE(&value)) { case G_TYPE_STRING: { const char *string_val = g_value_get_string(&value); json_description_->add_string_member("type", "string"); if (string_val == nullptr) json_description_->add_string_member("default value", ""); else json_description_->add_string_member("default value", string_val); break; } case G_TYPE_BOOLEAN: { gboolean bool_val = g_value_get_boolean(&value); json_description_->add_string_member("type", "boolean"); if (bool_val) json_description_->add_string_member("default value", "true"); else json_description_->add_string_member("default value", "false"); break; } case G_TYPE_ULONG: { GParamSpecULong *pulong = G_PARAM_SPEC_ULONG(property_); json_description_->add_string_member("type", "ulong"); gchar *min = g_strdup_printf("%lu", pulong->minimum); gchar *max = g_strdup_printf("%lu", pulong->maximum); gchar *default_value = g_strdup_printf("%lu", g_value_get_ulong(&value)); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_LONG: { GParamSpecLong *plong = G_PARAM_SPEC_LONG(property_); gchar *min = g_strdup_printf("%ld", plong->minimum); gchar *max = g_strdup_printf("%ld", plong->maximum); gchar *default_value = g_strdup_printf("%ld", g_value_get_ulong(&value)); json_description_->add_string_member("type", "long"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_UINT: { GParamSpecUInt *puint = G_PARAM_SPEC_UINT(property_); gchar *min = g_strdup_printf("%u", puint->minimum); gchar *max = g_strdup_printf("%u", puint->maximum); gchar *default_value = g_strdup_printf("%u", g_value_get_uint(&value)); json_description_->add_string_member("type", "uint"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_INT: { GParamSpecInt *pint = G_PARAM_SPEC_INT(property_); gchar *min = g_strdup_printf("%d", pint->minimum); gchar *max = g_strdup_printf("%d", pint->maximum); gchar *default_value = g_strdup_printf("%d", g_value_get_int(&value)); json_description_->add_string_member("type", "int"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_UINT64: { GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64(property_); gchar *min = g_strdup_printf("%" G_GUINT64_FORMAT, puint64->minimum); gchar *max = g_strdup_printf("%" G_GUINT64_FORMAT, puint64->maximum); gchar *default_value = g_strdup_printf("%" G_GUINT64_FORMAT, g_value_get_uint64(&value)); json_description_->add_string_member("type", "uint64"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_INT64: { GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64(property_); gchar *min = g_strdup_printf("%" G_GINT64_FORMAT, pint64->minimum); gchar *max = g_strdup_printf("%" G_GINT64_FORMAT, pint64->maximum); gchar *default_value = g_strdup_printf("%" G_GINT64_FORMAT, g_value_get_int64(&value)); json_description_->add_string_member("type", "int64"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_FLOAT: { GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT(property_); gchar *min = g_strdup_printf("%.7g", pfloat->minimum); gchar *max = g_strdup_printf("%.7g", pfloat->maximum); gchar *default_value = g_strdup_printf("%.7g", g_value_get_float(&value)); json_description_->add_string_member("type", "float"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } case G_TYPE_DOUBLE: { GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE(property_); gchar *min = g_strdup_printf("%.7g", pdouble->minimum); gchar *max = g_strdup_printf("%.7g", pdouble->maximum); gchar *default_value = g_strdup_printf("%.7g", g_value_get_double(&value)); json_description_->add_string_member("type", "double"); json_description_->add_string_member("minimum", min); json_description_->add_string_member("maximum", max); json_description_->add_string_member("default value", default_value); g_free(min); g_free(max); g_free(default_value); break; } default: if (property_->value_type == GST_TYPE_CAPS) { const GstCaps *caps = gst_value_get_caps(&value); json_description_->add_string_member("type", "caps"); if (!caps) json_description_->add_string_member("default value", ""); else json_description_->add_string_member("default value", gst_caps_to_string(caps)); } else if (G_IS_PARAM_SPEC_ENUM(property_)) { GEnumValue *values; guint j = 0; gint enum_value; const gchar *value_nick = ""; const gchar *value_name = ""; json_description_->add_string_member("type", "enum"); values = G_ENUM_CLASS(g_type_class_ref(property_->value_type))->values; enum_value = g_value_get_enum(&value); while (values[j].value_name) { if (values[j].value == enum_value) { value_nick = values[j].value_nick; value_name = values[j].value_name; } j++; } json_description_->set_member_name("default value"); json_description_->begin_object(); gchar *value = g_strdup_printf("%d", enum_value); json_description_->add_string_member("value", value); g_free(value); json_description_->add_string_member("nick", value_nick); json_description_->add_string_member("name", value_name); json_description_->end_object(); // g_debug ("Enum \"%s\" Default: %d, \"%s\" \"%s\"", // g_type_name (G_VALUE_TYPE (&value)), // enum_value, // value_nick, // value_name); j = 0; json_description_->set_member_name("values"); json_description_->begin_array(); while (values[j].value_name) { json_description_->begin_object(); json_description_->add_string_member("name", values[j].value_name); json_description_->add_string_member("nick", values[j].value_nick); gchar *values_value = g_strdup_printf("%d", values[j].value); json_description_->add_string_member("value", values_value); g_free(values_value); json_description_->end_object(); j++; } json_description_->end_array(); /* g_type_class_unref (ec); */ } else if (G_IS_PARAM_SPEC_FLAGS(property_)) { g_debug("warning: param spec flags not handled"); // GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (property_); // GFlagsValue *vals; // gchar *cur; // vals = pflags->flags_class->values; // cur = flags_to_string (vals, g_value_get_flags (&value)); // g_debug ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "", // g_type_name (G_VALUE_TYPE (&value)), // g_value_get_flags (&value), cur); // while (vals[0].value_name) { // g_debug (""); // if (_name) // g_debug ("%s", _name); // g_debug ("%-23.23s (0x%08x): %-16s - %s", "", // vals[0].value, vals[0].value_nick, vals[0].value_name); // ++vals; // } // g_free (cur); } else if (G_IS_PARAM_SPEC_OBJECT(property_)) { g_debug("warning: param spec object not handled"); // g_debug ("%-23.23s Object of type \"%s\"", "", // g_type_name (property_->value_type)); } else if (G_IS_PARAM_SPEC_BOXED(property_)) { g_debug("warning: param spec boxed not handled"); // g_debug ("%-23.23s Boxed pointer of type \"%s\"", "", // g_type_name (property_->value_type)); } else if (G_IS_PARAM_SPEC_POINTER(property_)) { g_debug("warning: param spec pointer not handled"); // if (property_->value_type != G_TYPE_POINTER) { // g_debug ("%-23.23s Pointer of type \"%s\".", "", // g_type_name (property_->value_type)); // } else if (property_->value_type == G_TYPE_VALUE_ARRAY) { // GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (property_); // g_debug ("warning: array not handled"); // if (pvarray->element_spec) { // g_debug ("%-23.23s Array of GValues of type \"%s\"", "", // g_type_name (pvarray->element_spec->value_type)); // } else { // g_debug ("%-23.23s Array of GValues", ""); // } } else if (GST_IS_PARAM_SPEC_FRACTION(property_)) { GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION(property_); json_description_->add_string_member("type", "fraction"); gchar *minnum = g_strdup_printf("%d", pfraction->min_num); gchar *minden = g_strdup_printf("%d", pfraction->min_den); gchar *maxnum = g_strdup_printf("%d", pfraction->max_num); gchar *maxden = g_strdup_printf("%d", pfraction->max_den); gchar *defaultnum = g_strdup_printf("%d", gst_value_get_fraction_numerator (&value)); gchar *defaultden = g_strdup_printf("%d", gst_value_get_fraction_denominator (&value)); json_description_->add_string_member("minimum numerator", minnum); json_description_->add_string_member("maximum numerator", minden); json_description_->add_string_member("minimum denominator", maxnum); json_description_->add_string_member("maximum denominator", maxden); json_description_->add_string_member("default numerator", defaultnum); json_description_->add_string_member("default denominator", defaultden); g_free(minnum); g_free(minden); g_free(maxnum); g_free(maxden); g_free(defaultnum); g_free(defaultden); // g_debug ("Range: %d/%d - %d/%d Default: %d/%d ", // pfraction->min_num, pfraction->min_den, // pfraction->max_num, pfraction->max_den, // gst_value_get_fraction_numerator (&value), // gst_value_get_fraction_denominator (&value)); } else { g_warning("warning: unknown type"); // g_debug ("%-23.23s Unknown type %ld \"%s\"", "", property_->value_type, // g_type_name (property_->value_type)); } break; } g_value_reset(&value); json_description_->end_object(); }
static void gst_capsfilter_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstCapsFilter *capsfilter = GST_CAPSFILTER (object); switch (prop_id) { case PROP_FILTER_CAPS:{ GstCaps *new_caps; GstCaps *old_caps, *suggest, *nego; const GstCaps *new_caps_val = gst_value_get_caps (value); if (new_caps_val == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = (GstCaps *) new_caps_val; gst_caps_ref (new_caps); } GST_OBJECT_LOCK (capsfilter); old_caps = capsfilter->filter_caps; capsfilter->filter_caps = new_caps; GST_OBJECT_UNLOCK (capsfilter); gst_caps_unref (old_caps); GST_DEBUG_OBJECT (capsfilter, "set new caps %" GST_PTR_FORMAT, new_caps); /* filter the currently negotiated format against the new caps */ GST_OBJECT_LOCK (GST_BASE_TRANSFORM_SINK_PAD (object)); nego = GST_PAD_CAPS (GST_BASE_TRANSFORM_SINK_PAD (object)); if (nego) { GST_DEBUG_OBJECT (capsfilter, "we had negotiated caps %" GST_PTR_FORMAT, nego); if (G_UNLIKELY (gst_caps_is_any (new_caps))) { GST_DEBUG_OBJECT (capsfilter, "not settings any suggestion"); suggest = NULL; } else { GstStructure *s1, *s2; /* first check if the name is the same */ s1 = gst_caps_get_structure (nego, 0); s2 = gst_caps_get_structure (new_caps, 0); if (gst_structure_get_name_id (s1) == gst_structure_get_name_id (s2)) { /* same name, copy all fields from the new caps into the previously * negotiated caps */ suggest = gst_caps_copy (nego); s1 = gst_caps_get_structure (suggest, 0); gst_structure_foreach (s2, (GstStructureForeachFunc) copy_func, s1); GST_DEBUG_OBJECT (capsfilter, "copied structure fields"); } else { GST_DEBUG_OBJECT (capsfilter, "different structure names"); /* different names, we can only suggest the complete caps */ suggest = gst_caps_copy (new_caps); } } } else { GST_DEBUG_OBJECT (capsfilter, "no negotiated caps"); /* no previous caps, the getcaps function will be used to find suitable * caps */ suggest = NULL; } GST_OBJECT_UNLOCK (GST_BASE_TRANSFORM_SINK_PAD (object)); GST_DEBUG_OBJECT (capsfilter, "suggesting new caps %" GST_PTR_FORMAT, suggest); gst_base_transform_suggest (GST_BASE_TRANSFORM (object), suggest, 0); if (suggest) gst_caps_unref (suggest); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void print_element_properties_info (GstElement * element) { GParamSpec **property_specs; guint num_properties, i; gboolean readable; gboolean first_flag; property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (element), &num_properties); n_print ("\n"); n_print ("Element Properties:\n"); for (i = 0; i < num_properties; i++) { GValue value = { 0, }; GParamSpec *param = property_specs[i]; readable = FALSE; g_value_init (&value, param->value_type); n_print (" %-20s: %s\n", g_param_spec_get_name (param), g_param_spec_get_blurb (param)); first_flag = TRUE; n_print ("%-23.23s flags: ", ""); if (param->flags & G_PARAM_READABLE) { g_object_get_property (G_OBJECT (element), param->name, &value); readable = TRUE; g_print ("%s%s", (first_flag) ? "" : ", ", _("readable")); first_flag = FALSE; } else { /* if we can't read the property value, assume it's set to the default * (which might not be entirely true for sub-classes, but that's an * unlikely corner-case anyway) */ g_param_value_set_default (param, &value); } if (param->flags & G_PARAM_WRITABLE) { g_print ("%s%s", (first_flag) ? "" : ", ", _("writable")); first_flag = FALSE; } if (param->flags & G_PARAM_DEPRECATED) { g_print ("%s%s", (first_flag) ? "" : ", ", _("deprecated")); first_flag = FALSE; } if (param->flags & GST_PARAM_CONTROLLABLE) { g_print (", %s", _("controllable")); first_flag = FALSE; } if (param->flags & GST_PARAM_MUTABLE_PLAYING) { g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state")); } else if (param->flags & GST_PARAM_MUTABLE_PAUSED) { g_print (", %s", _("changeable only in NULL, READY or PAUSED state")); } else if (param->flags & GST_PARAM_MUTABLE_READY) { g_print (", %s", _("changeable only in NULL or READY state")); } if (param->flags & ~KNOWN_PARAM_FLAGS) { g_print ("%s0x%0x", (first_flag) ? "" : ", ", param->flags & ~KNOWN_PARAM_FLAGS); } n_print ("\n"); switch (G_VALUE_TYPE (&value)) { case G_TYPE_STRING: { const char *string_val = g_value_get_string (&value); n_print ("%-23.23s String. ", ""); if (string_val == NULL) g_print ("Default: null"); else g_print ("Default: \"%s\"", string_val); break; } case G_TYPE_BOOLEAN: { gboolean bool_val = g_value_get_boolean (&value); n_print ("%-23.23s Boolean. ", ""); g_print ("Default: %s", bool_val ? "true" : "false"); break; } case G_TYPE_ULONG: { GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param); n_print ("%-23.23s Unsigned Long. ", ""); g_print ("Range: %lu - %lu Default: %lu ", pulong->minimum, pulong->maximum, g_value_get_ulong (&value)); GST_ERROR ("%s: property '%s' of type ulong: consider changing to " "uint/uint64", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); break; } case G_TYPE_LONG: { GParamSpecLong *plong = G_PARAM_SPEC_LONG (param); n_print ("%-23.23s Long. ", ""); g_print ("Range: %ld - %ld Default: %ld ", plong->minimum, plong->maximum, g_value_get_long (&value)); GST_ERROR ("%s: property '%s' of type long: consider changing to " "int/int64", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); break; } case G_TYPE_UINT: { GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param); n_print ("%-23.23s Unsigned Integer. ", ""); g_print ("Range: %u - %u Default: %u ", puint->minimum, puint->maximum, g_value_get_uint (&value)); break; } case G_TYPE_INT: { GParamSpecInt *pint = G_PARAM_SPEC_INT (param); n_print ("%-23.23s Integer. ", ""); g_print ("Range: %d - %d Default: %d ", pint->minimum, pint->maximum, g_value_get_int (&value)); break; } case G_TYPE_UINT64: { GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param); n_print ("%-23.23s Unsigned Integer64. ", ""); g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT " Default: %" G_GUINT64_FORMAT " ", puint64->minimum, puint64->maximum, g_value_get_uint64 (&value)); break; } case G_TYPE_INT64: { GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param); n_print ("%-23.23s Integer64. ", ""); g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT " Default: %" G_GINT64_FORMAT " ", pint64->minimum, pint64->maximum, g_value_get_int64 (&value)); break; } case G_TYPE_FLOAT: { GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param); n_print ("%-23.23s Float. ", ""); g_print ("Range: %15.7g - %15.7g Default: %15.7g ", pfloat->minimum, pfloat->maximum, g_value_get_float (&value)); break; } case G_TYPE_DOUBLE: { GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param); n_print ("%-23.23s Double. ", ""); g_print ("Range: %15.7g - %15.7g Default: %15.7g ", pdouble->minimum, pdouble->maximum, g_value_get_double (&value)); break; } case G_TYPE_CHAR: case G_TYPE_UCHAR: GST_ERROR ("%s: property '%s' of type char: consider changing to " "int/string", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); /* fall through */ default: if (param->value_type == GST_TYPE_CAPS) { const GstCaps *caps = gst_value_get_caps (&value); if (!caps) n_print ("%-23.23s Caps (NULL)", ""); else { print_caps (caps, " "); } } else if (G_IS_PARAM_SPEC_ENUM (param)) { GEnumValue *values; guint j = 0; gint enum_value; const gchar *value_nick = ""; values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values; enum_value = g_value_get_enum (&value); while (values[j].value_name) { if (values[j].value == enum_value) value_nick = values[j].value_nick; j++; } n_print ("%-23.23s Enum \"%s\" Default: %d, \"%s\"", "", g_type_name (G_VALUE_TYPE (&value)), enum_value, value_nick); j = 0; while (values[j].value_name) { g_print ("\n"); if (_name) g_print ("%s", _name); g_print ("%-23.23s (%d): %-16s - %s", "", values[j].value, values[j].value_nick, values[j].value_name); j++; } /* g_type_class_unref (ec); */ } else if (G_IS_PARAM_SPEC_FLAGS (param)) { GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param); GFlagsValue *vals; gchar *cur; vals = pflags->flags_class->values; cur = flags_to_string (vals, g_value_get_flags (&value)); n_print ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "", g_type_name (G_VALUE_TYPE (&value)), g_value_get_flags (&value), cur); while (vals[0].value_name) { g_print ("\n"); if (_name) g_print ("%s", _name); g_print ("%-23.23s (0x%08x): %-16s - %s", "", vals[0].value, vals[0].value_nick, vals[0].value_name); ++vals; } g_free (cur); } else if (G_IS_PARAM_SPEC_OBJECT (param)) { n_print ("%-23.23s Object of type \"%s\"", "", g_type_name (param->value_type)); } else if (G_IS_PARAM_SPEC_BOXED (param)) { n_print ("%-23.23s Boxed pointer of type \"%s\"", "", g_type_name (param->value_type)); if (param->value_type == GST_TYPE_STRUCTURE) { const GstStructure *s = gst_value_get_structure (&value); if (s) gst_structure_foreach (s, print_field, (gpointer) " "); } } else if (G_IS_PARAM_SPEC_POINTER (param)) { if (param->value_type != G_TYPE_POINTER) { n_print ("%-23.23s Pointer of type \"%s\".", "", g_type_name (param->value_type)); } else { n_print ("%-23.23s Pointer.", ""); } } else if (param->value_type == G_TYPE_VALUE_ARRAY) { GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param); if (pvarray->element_spec) { n_print ("%-23.23s Array of GValues of type \"%s\"", "", g_type_name (pvarray->element_spec->value_type)); } else { n_print ("%-23.23s Array of GValues", ""); } } else if (GST_IS_PARAM_SPEC_FRACTION (param)) { GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param); n_print ("%-23.23s Fraction. ", ""); g_print ("Range: %d/%d - %d/%d Default: %d/%d ", pfraction->min_num, pfraction->min_den, pfraction->max_num, pfraction->max_den, gst_value_get_fraction_numerator (&value), gst_value_get_fraction_denominator (&value)); } else { n_print ("%-23.23s Unknown type %ld \"%s\"", "", (glong) param->value_type, g_type_name (param->value_type)); } break; } if (!readable) g_print (" Write only\n"); else g_print ("\n"); g_value_reset (&value); } if (num_properties == 0) n_print (" none\n"); g_free (property_specs); }
static void gst_udpsrc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstUDPSrc *udpsrc = GST_UDPSRC (object); switch (prop_id) { case PROP_BUFFER_SIZE: udpsrc->buffer_size = g_value_get_int (value); break; case PROP_PORT: udpsrc->port = g_value_get_int (value); g_free (udpsrc->uri); udpsrc->uri = g_strdup_printf ("udp://%s:%u", udpsrc->host, udpsrc->port); break; case PROP_MULTICAST_GROUP: { const gchar *group; g_free (udpsrc->host); if ((group = g_value_get_string (value))) udpsrc->host = g_strdup (group); else udpsrc->host = g_strdup (UDP_DEFAULT_MULTICAST_GROUP); g_free (udpsrc->uri); udpsrc->uri = g_strdup_printf ("udp://%s:%u", udpsrc->host, udpsrc->port); break; } case PROP_MULTICAST_IFACE: g_free (udpsrc->multi_iface); if (g_value_get_string (value) == NULL) udpsrc->multi_iface = g_strdup (UDP_DEFAULT_MULTICAST_IFACE); else udpsrc->multi_iface = g_value_dup_string (value); break; case PROP_URI: gst_udpsrc_set_uri (udpsrc, g_value_get_string (value)); break; case PROP_CAPS: { const GstCaps *new_caps_val = gst_value_get_caps (value); GstCaps *new_caps; GstCaps *old_caps; if (new_caps_val == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (new_caps_val); } old_caps = udpsrc->caps; udpsrc->caps = new_caps; if (old_caps) gst_caps_unref (old_caps); gst_pad_set_caps (GST_BASE_SRC (udpsrc)->srcpad, new_caps); break; } case PROP_SOCKET: if (udpsrc->socket != NULL && udpsrc->socket != udpsrc->used_socket && udpsrc->close_socket) { GError *err = NULL; if (!g_socket_close (udpsrc->socket, &err)) { GST_ERROR ("failed to close socket %p: %s", udpsrc->socket, err->message); g_clear_error (&err); } } if (udpsrc->socket) g_object_unref (udpsrc->socket); udpsrc->socket = g_value_dup_object (value); GST_DEBUG ("setting socket to %p", udpsrc->socket); break; case PROP_TIMEOUT: udpsrc->timeout = g_value_get_uint64 (value); break; case PROP_SKIP_FIRST_BYTES: udpsrc->skip_first_bytes = g_value_get_int (value); break; case PROP_CLOSE_SOCKET: udpsrc->close_socket = g_value_get_boolean (value); break; case PROP_AUTO_MULTICAST: udpsrc->auto_multicast = g_value_get_boolean (value); break; case PROP_REUSE: udpsrc->reuse = g_value_get_boolean (value); break; default: break; } }