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; } }
static void gvir_config_domain_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GVirConfigDomain *domain = GVIR_CONFIG_DOMAIN(object); switch (prop_id) { case PROP_NAME: gvir_config_domain_set_name(domain, g_value_get_string(value)); break; case PROP_TITLE: gvir_config_domain_set_title(domain, g_value_get_string(value)); break; case PROP_DESCRIPTION: gvir_config_domain_set_description(domain, g_value_get_string(value)); break; case PROP_MEMORY: gvir_config_domain_set_memory(domain, g_value_get_uint64(value)); break; case PROP_VCPU: gvir_config_domain_set_vcpus(domain, g_value_get_uint64(value)); break; case PROP_FEATURES: gvir_config_domain_set_features(domain, g_value_get_boxed(value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); } }
static void gst_level_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstLevel *filter = GST_LEVEL (object); switch (prop_id) { case PROP_POST_MESSAGES: /* fall-through */ case PROP_MESSAGE: filter->post_messages = g_value_get_boolean (value); break; case PROP_INTERVAL: filter->interval = g_value_get_uint64 (value); /* Not exactly thread-safe, but property does not advertise that it * can be changed at runtime anyway */ if (GST_AUDIO_INFO_RATE (&filter->info)) { gst_level_recalc_interval_frames (filter); } break; case PROP_PEAK_TTL: filter->decay_peak_ttl = gst_guint64_to_gdouble (g_value_get_uint64 (value)); break; case PROP_PEAK_FALLOFF: filter->decay_peak_falloff = g_value_get_double (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_level_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstLevel *filter = GST_LEVEL (object); switch (prop_id) { case PROP_POST_MESSAGES: /* fall-through */ case PROP_MESSAGE: filter->post_messages = g_value_get_boolean (value); break; case PROP_INTERVAL: filter->interval = g_value_get_uint64 (value); if (GST_AUDIO_INFO_RATE (&filter->info)) { filter->interval_frames = GST_CLOCK_TIME_TO_FRAMES (filter->interval, GST_AUDIO_INFO_RATE (&filter->info)); } break; case PROP_PEAK_TTL: filter->decay_peak_ttl = gst_guint64_to_gdouble (g_value_get_uint64 (value)); break; case PROP_PEAK_FALLOFF: filter->decay_peak_falloff = g_value_get_double (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void gst_decklink_audio_sink_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { GstDecklinkAudioSink *self = GST_DECKLINK_AUDIO_SINK_CAST (object); switch (property_id) { case PROP_DEVICE_NUMBER: self->device_number = g_value_get_int (value); break; case PROP_ALIGNMENT_THRESHOLD: GST_OBJECT_LOCK (self); gst_audio_stream_align_set_alignment_threshold (self->stream_align, g_value_get_uint64 (value)); GST_OBJECT_UNLOCK (self); break; case PROP_DISCONT_WAIT: GST_OBJECT_LOCK (self); gst_audio_stream_align_set_discont_wait (self->stream_align, g_value_get_uint64 (value)); GST_OBJECT_UNLOCK (self); break; case PROP_BUFFER_TIME: GST_OBJECT_LOCK (self); self->buffer_time = g_value_get_uint64 (value) * 1000; GST_OBJECT_UNLOCK (self); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
void gst_decklink_audio_src_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { GstDecklinkAudioSrc *self = GST_DECKLINK_AUDIO_SRC_CAST (object); switch (property_id) { case PROP_CONNECTION: self->connection = (GstDecklinkAudioConnectionEnum) g_value_get_enum (value); break; case PROP_DEVICE_NUMBER: self->device_number = g_value_get_int (value); break; case PROP_ALIGNMENT_THRESHOLD: self->alignment_threshold = g_value_get_uint64 (value); break; case PROP_DISCONT_WAIT: self->discont_wait = g_value_get_uint64 (value); break; case PROP_BUFFER_SIZE: self->buffer_size = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void _set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { GESTimelineElement *self = GES_TIMELINE_ELEMENT (object); switch (property_id) { case PROP_PARENT: ges_timeline_element_set_parent (self, g_value_get_object (value)); break; case PROP_TIMELINE: ges_timeline_element_set_timeline (self, g_value_get_object (value)); break; case PROP_START: ges_timeline_element_set_start (self, g_value_get_uint64 (value)); break; case PROP_INPOINT: ges_timeline_element_set_inpoint (self, g_value_get_uint64 (value)); break; case PROP_DURATION: ges_timeline_element_set_duration (self, g_value_get_uint64 (value)); break; case PROP_PRIORITY: ges_timeline_element_set_priority (self, g_value_get_uint (value)); break; case PROP_MAX_DURATION: ges_timeline_element_set_max_duration (self, g_value_get_uint64 (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec); } }
static void ges_track_object_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { GESTrackObject *tobj = GES_TRACK_OBJECT (object); switch (property_id) { case PROP_START: ges_track_object_set_start_internal (tobj, g_value_get_uint64 (value)); break; case PROP_INPOINT: ges_track_object_set_inpoint_internal (tobj, g_value_get_uint64 (value)); break; case PROP_DURATION: ges_track_object_set_duration_internal (tobj, g_value_get_uint64 (value)); break; case PROP_PRIORITY: ges_track_object_set_priority_internal (tobj, g_value_get_uint (value)); break; case PROP_ACTIVE: ges_track_object_set_active (tobj, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
void gst_inter_audio_src_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { GstInterAudioSrc *interaudiosrc = GST_INTER_AUDIO_SRC (object); switch (property_id) { case PROP_CHANNEL: g_free (interaudiosrc->channel); interaudiosrc->channel = g_value_dup_string (value); break; case PROP_BUFFER_TIME: interaudiosrc->buffer_time = g_value_get_uint64 (value); break; case PROP_LATENCY_TIME: interaudiosrc->latency_time = g_value_get_uint64 (value); break; case PROP_PERIOD_TIME: interaudiosrc->period_time = g_value_get_uint64 (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static gboolean gst_base_rtp_depayload_setcaps (GstPad * pad, GstCaps * caps) { GstBaseRTPDepayload *filter; GstBaseRTPDepayloadClass *bclass; GstBaseRTPDepayloadPrivate *priv; gboolean res; GstStructure *caps_struct; const GValue *value; filter = GST_BASE_RTP_DEPAYLOAD (gst_pad_get_parent (pad)); priv = filter->priv; bclass = GST_BASE_RTP_DEPAYLOAD_GET_CLASS (filter); GST_DEBUG_OBJECT (filter, "Set caps"); caps_struct = gst_caps_get_structure (caps, 0); /* get other values for newsegment */ value = gst_structure_get_value (caps_struct, "npt-start"); if (value && G_VALUE_HOLDS_UINT64 (value)) priv->npt_start = g_value_get_uint64 (value); else priv->npt_start = 0; GST_DEBUG_OBJECT (filter, "NPT start %" G_GUINT64_FORMAT, priv->npt_start); value = gst_structure_get_value (caps_struct, "npt-stop"); if (value && G_VALUE_HOLDS_UINT64 (value)) priv->npt_stop = g_value_get_uint64 (value); else priv->npt_stop = -1; GST_DEBUG_OBJECT (filter, "NPT stop %" G_GUINT64_FORMAT, priv->npt_stop); value = gst_structure_get_value (caps_struct, "play-speed"); if (value && G_VALUE_HOLDS_DOUBLE (value)) priv->play_speed = g_value_get_double (value); else priv->play_speed = 1.0; value = gst_structure_get_value (caps_struct, "play-scale"); if (value && G_VALUE_HOLDS_DOUBLE (value)) priv->play_scale = g_value_get_double (value); else priv->play_scale = 1.0; if (bclass->set_caps) res = bclass->set_caps (filter, caps); else res = TRUE; priv->negotiated = res; gst_object_unref (filter); return res; }
static void gst_cmml_tag_clip_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { GstCmmlTagClip *clip = GST_CMML_TAG_CLIP (object); switch (property_id) { case GST_CMML_TAG_CLIP_EMPTY: clip->empty = g_value_get_boolean (value); break; case GST_CMML_TAG_CLIP_ID: g_free (clip->id); clip->id = (guchar *) g_value_dup_string (value); break; case GST_CMML_TAG_CLIP_TRACK: g_free (clip->track); clip->track = (guchar *) g_value_dup_string (value); break; case GST_CMML_TAG_CLIP_START_TIME: clip->start_time = g_value_get_uint64 (value); break; case GST_CMML_TAG_CLIP_END_TIME: clip->end_time = g_value_get_uint64 (value); break; case GST_CMML_TAG_CLIP_ANCHOR_HREF: g_free (clip->anchor_href); clip->anchor_href = (guchar *) g_value_dup_string (value); break; case GST_CMML_TAG_CLIP_ANCHOR_TEXT: g_free (clip->anchor_text); clip->anchor_text = (guchar *) g_value_dup_string (value); break; case GST_CMML_TAG_CLIP_IMG_SRC: g_free (clip->img_src); clip->img_src = (guchar *) g_value_dup_string (value); break; case GST_CMML_TAG_CLIP_IMG_ALT: g_free (clip->img_alt); clip->img_alt = (guchar *) g_value_dup_string (value); break; case GST_CMML_TAG_CLIP_DESC_TEXT: g_free (clip->desc_text); clip->desc_text = (guchar *) g_value_dup_string (value); break; case GST_CMML_TAG_CLIP_META: { GValueArray *va = (GValueArray *) g_value_get_boxed (value); if (clip->meta) g_value_array_free (clip->meta); clip->meta = va != NULL ? g_value_array_copy (va) : NULL; break; } } }
static void channel_get_all_properties_cb (TpProxy *proxy, GHashTable *properties, const GError *error, gpointer user_data, GObject *weak_object) { CallbacksData *cb_data = user_data; EmpathyFTHandler *handler = EMPATHY_FT_HANDLER (weak_object); EmpathyFTHandlerPriv *priv = GET_PRIV (handler); TpHandle c_handle; if (error != NULL) { if (!g_cancellable_is_cancelled (priv->cancellable)) g_cancellable_cancel (priv->cancellable); cb_data->callback (handler, (GError *) error, cb_data->user_data); callbacks_data_free (cb_data); return; } priv->total_bytes = g_value_get_uint64 ( g_hash_table_lookup (properties, "Size")); priv->transferred_bytes = g_value_get_uint64 ( g_hash_table_lookup (properties, "TransferredBytes")); priv->filename = g_value_dup_string ( g_hash_table_lookup (properties, "Filename")); priv->content_hash = g_value_dup_string ( g_hash_table_lookup (properties, "ContentHash")); priv->content_hash_type = g_value_get_uint ( g_hash_table_lookup (properties, "ContentHashType")); priv->content_type = g_value_dup_string ( g_hash_table_lookup (properties, "ContentType")); priv->description = g_value_dup_string ( g_hash_table_lookup (properties, "Description")); c_handle = tp_channel_get_handle (TP_CHANNEL (proxy), NULL); empathy_tp_contact_factory_get_from_handle ( tp_channel_borrow_connection (TP_CHANNEL (proxy)), c_handle, contact_factory_contact_cb, cb_data, callbacks_data_free, G_OBJECT (handler)); }
static void gst_splitmux_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstSplitMuxSink *splitmux = GST_SPLITMUX_SINK (object); switch (prop_id) { case PROP_LOCATION:{ GST_OBJECT_LOCK (splitmux); g_free (splitmux->location); splitmux->location = g_value_dup_string (value); GST_OBJECT_UNLOCK (splitmux); break; } case PROP_MAX_SIZE_BYTES: GST_OBJECT_LOCK (splitmux); splitmux->threshold_bytes = g_value_get_uint64 (value); GST_OBJECT_UNLOCK (splitmux); break; case PROP_MAX_SIZE_TIME: GST_OBJECT_LOCK (splitmux); splitmux->threshold_time = g_value_get_uint64 (value); GST_OBJECT_UNLOCK (splitmux); break; case PROP_MUXER_OVERHEAD: GST_OBJECT_LOCK (splitmux); splitmux->mux_overhead = g_value_get_double (value); GST_OBJECT_UNLOCK (splitmux); break; case PROP_SINK: GST_OBJECT_LOCK (splitmux); if (splitmux->provided_sink) gst_object_unref (splitmux->provided_sink); splitmux->provided_sink = g_value_dup_object (value); GST_OBJECT_UNLOCK (splitmux); break; case PROP_MUXER: GST_OBJECT_LOCK (splitmux); if (splitmux->provided_muxer) gst_object_unref (splitmux->provided_muxer); splitmux->provided_muxer = g_value_dup_object (value); GST_OBJECT_UNLOCK (splitmux); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
G_GNUC_UNUSED static gboolean _g_value_equal (const GValue *a, const GValue *b) { gboolean ret = FALSE; g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b)); switch (G_VALUE_TYPE (a)) { case G_TYPE_BOOLEAN: ret = (g_value_get_boolean (a) == g_value_get_boolean (b)); break; case G_TYPE_UCHAR: ret = (g_value_get_uchar (a) == g_value_get_uchar (b)); break; case G_TYPE_INT: ret = (g_value_get_int (a) == g_value_get_int (b)); break; case G_TYPE_UINT: ret = (g_value_get_uint (a) == g_value_get_uint (b)); break; case G_TYPE_INT64: ret = (g_value_get_int64 (a) == g_value_get_int64 (b)); break; case G_TYPE_UINT64: ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b)); break; case G_TYPE_DOUBLE: { /* Avoid -Wfloat-equal warnings by doing a direct bit compare */ gdouble da = g_value_get_double (a); gdouble db = g_value_get_double (b); ret = memcmp (&da, &db, sizeof (gdouble)) == 0; } break; case G_TYPE_STRING: ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0); break; case G_TYPE_VARIANT: ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b)); break; default: if (G_VALUE_TYPE (a) == G_TYPE_STRV) ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b)); else g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a))); break; } return ret; }
static void do_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { EmpathyFTHandler *self = EMPATHY_FT_HANDLER (object); EmpathyFTHandlerPriv *priv = self->priv; switch (property_id) { case PROP_ACCOUNT: priv->account = g_value_dup_object (value); break; case PROP_CONTACT: priv->contact = g_value_dup_object (value); break; case PROP_CONTENT_TYPE: priv->content_type = g_value_dup_string (value); break; case PROP_DESCRIPTION: priv->description = g_value_dup_string (value); break; case PROP_FILENAME: priv->filename = g_value_dup_string (value); break; case PROP_MODIFICATION_TIME: priv->mtime = g_value_get_uint64 (value); break; case PROP_TOTAL_BYTES: priv->total_bytes = g_value_get_uint64 (value); break; case PROP_TRANSFERRED_BYTES: priv->transferred_bytes = g_value_get_uint64 (value); break; case PROP_G_FILE: priv->gfile = g_value_dup_object (value); break; case PROP_CHANNEL: priv->channel = g_value_dup_object (value); break; case PROP_USER_ACTION_TIME: priv->user_action_time = g_value_get_int64 (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static guint64 get_size_from_column(GtkTreeModel* model, GtkTreeIter* first, const guint index) { GValue value = { 0 }; gtk_tree_model_get_value(model, first, index, &value); guint64 size; switch (G_VALUE_TYPE(&value)) { case G_TYPE_UINT: size = g_value_get_uint(&value); break; case G_TYPE_ULONG: size = g_value_get_ulong(&value); break; case G_TYPE_UINT64: size = g_value_get_uint64(&value); break; default: g_assert_not_reached(); } g_value_unset(&value); return size; }
int ce_get_property_default (NMSetting *setting, const char *property_name) { GParamSpec *spec; GValue value = { 0, }; g_return_val_if_fail (NM_IS_SETTING (setting), -1); spec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), property_name); g_return_val_if_fail (spec != NULL, -1); g_value_init (&value, spec->value_type); g_param_value_set_default (spec, &value); if (G_VALUE_HOLDS_CHAR (&value)) return (int) g_value_get_schar (&value); else if (G_VALUE_HOLDS_INT (&value)) return g_value_get_int (&value); else if (G_VALUE_HOLDS_INT64 (&value)) return (int) g_value_get_int64 (&value); else if (G_VALUE_HOLDS_LONG (&value)) return (int) g_value_get_long (&value); else if (G_VALUE_HOLDS_UINT (&value)) return (int) g_value_get_uint (&value); else if (G_VALUE_HOLDS_UINT64 (&value)) return (int) g_value_get_uint64 (&value); else if (G_VALUE_HOLDS_ULONG (&value)) return (int) g_value_get_ulong (&value); else if (G_VALUE_HOLDS_UCHAR (&value)) return (int) g_value_get_uchar (&value); g_return_val_if_fail (FALSE, 0); return 0; }
static void gst_dv1394src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstDV1394Src *filter = GST_DV1394SRC (object); switch (prop_id) { case PROP_PORT: filter->port = g_value_get_int (value); g_free (filter->uri); filter->uri = g_strdup_printf ("dv://%d", filter->port); break; case PROP_CHANNEL: filter->channel = g_value_get_int (value); break; case PROP_SKIP: filter->skip = g_value_get_int (value); break; case PROP_CONSECUTIVE: filter->consecutive = g_value_get_int (value); break; case PROP_DROP_INCOMPLETE: filter->drop_incomplete = g_value_get_boolean (value); break; case PROP_USE_AVC: filter->use_avc = g_value_get_boolean (value); break; case PROP_GUID: filter->guid = g_value_get_uint64 (value); gst_dv1394src_update_device_name (filter); break; default: break; } }
static void gst_fastspectrum_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstFastSpectrum *filter = GST_FASTSPECTRUM (object); switch (prop_id) { case PROP_INTERVAL:{ guint64 interval = g_value_get_uint64 (value); g_mutex_lock (&filter->lock); if (filter->interval != interval) { filter->interval = interval; gst_fastspectrum_reset_state (filter); } g_mutex_unlock (&filter->lock); break; } case PROP_BANDS:{ guint bands = g_value_get_uint (value); g_mutex_lock (&filter->lock); if (filter->bands != bands) { filter->bands = bands; gst_fastspectrum_reset_state (filter); } g_mutex_unlock (&filter->lock); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/** * gst_event_parse_qos: * @event: The event to query * @type: (out): A pointer to store the QoS type in * @proportion: (out): A pointer to store the proportion in * @diff: (out): A pointer to store the diff in * @timestamp: (out): A pointer to store the timestamp in * * Get the type, proportion, diff and timestamp in the qos event. See * gst_event_new_qos() for more information about the different QoS values. */ void gst_event_parse_qos (GstEvent * event, GstQOSType * type, gdouble * proportion, GstClockTimeDiff * diff, GstClockTime * timestamp) { const GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_QOS); structure = GST_EVENT_STRUCTURE (event); if (type) *type = (GstQOSType) g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (TYPE))); if (proportion) *proportion = g_value_get_double (gst_structure_id_get_value (structure, GST_QUARK (PROPORTION))); if (diff) *diff = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (DIFF))); if (timestamp) *timestamp = g_value_get_uint64 (gst_structure_id_get_value (structure, GST_QUARK (TIMESTAMP))); }
/** * gst_event_parse_step: * @event: The event to query * @format: (out) (allow-none): a pointer to store the format in * @amount: (out) (allow-none): a pointer to store the amount in * @rate: (out) (allow-none): a pointer to store the rate in * @flush: (out) (allow-none): a pointer to store the flush boolean in * @intermediate: (out) (allow-none): a pointer to store the intermediate * boolean in * * Parse the step event. */ void gst_event_parse_step (GstEvent * event, GstFormat * format, guint64 * amount, gdouble * rate, gboolean * flush, gboolean * intermediate) { const GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_STEP); structure = GST_EVENT_STRUCTURE (event); if (format) *format = (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (FORMAT))); if (amount) *amount = g_value_get_uint64 (gst_structure_id_get_value (structure, GST_QUARK (AMOUNT))); if (rate) *rate = g_value_get_double (gst_structure_id_get_value (structure, GST_QUARK (RATE))); if (flush) *flush = g_value_get_boolean (gst_structure_id_get_value (structure, GST_QUARK (FLUSH))); if (intermediate) *intermediate = g_value_get_boolean (gst_structure_id_get_value (structure, GST_QUARK (INTERMEDIATE))); }
static void gimp_base_config_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpBaseConfig *base_config = GIMP_BASE_CONFIG (object); switch (property_id) { case PROP_TEMP_PATH: g_free (base_config->temp_path); base_config->temp_path = g_value_dup_string (value); break; case PROP_SWAP_PATH: g_free (base_config->swap_path); base_config->swap_path = g_value_dup_string (value); break; case PROP_NUM_PROCESSORS: base_config->num_processors = g_value_get_uint (value); break; case PROP_TILE_CACHE_SIZE: base_config->tile_cache_size = g_value_get_uint64 (value); break; case PROP_STINGY_MEMORY_USE: /* ignored */ break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gst_audio_fir_filter_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAudioFIRFilter *self = GST_AUDIO_FIR_FILTER (object); g_return_if_fail (GST_IS_AUDIO_FIR_FILTER (self)); switch (prop_id) { case PROP_KERNEL: g_mutex_lock (self->lock); /* update kernel already pushes residues */ gst_audio_fir_filter_update_kernel (self, g_value_dup_boxed (value)); g_mutex_unlock (self->lock); break; case PROP_LATENCY: g_mutex_lock (self->lock); self->latency = g_value_get_uint64 (value); gst_audio_fir_filter_update_kernel (self, NULL); g_mutex_unlock (self->lock); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_live_adder_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { switch (prop_id) { case LIVEADDER_PROP_LATENCY: { GParamSpec *parent_spec = g_object_class_find_property (G_OBJECT_CLASS (gst_live_adder_parent_class), "latency"); GObjectClass *pspec_class = g_type_class_peek (parent_spec->owner_type); GValue v = { 0 }; g_value_init (&v, G_TYPE_UINT64); G_OBJECT_CLASS (pspec_class)->get_property (object, parent_spec->param_id, &v, parent_spec); g_value_set_uint (value, g_value_get_uint64 (&v) / GST_MSECOND); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void size_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data) { const guint index = GPOINTER_TO_UINT(user_data); guint64 size; GValue value = { 0 }; gtk_tree_model_get_value(model, iter, index, &value); switch (G_VALUE_TYPE(&value)) { case G_TYPE_ULONG: size = g_value_get_ulong(&value); break; case G_TYPE_UINT64: size = g_value_get_uint64(&value); break; default: g_assert_not_reached(); } g_value_unset(&value); char *str = procman::format_size(size); g_object_set(renderer, "text", str, NULL); g_free(str); }
static void gst_vaapi_surface_proxy_set_property( GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec ) { GstVaapiSurfaceProxy * const proxy = GST_VAAPI_SURFACE_PROXY(object); switch (prop_id) { case PROP_CONTEXT: gst_vaapi_surface_proxy_set_context(proxy, g_value_get_pointer(value)); break; case PROP_SURFACE: gst_vaapi_surface_proxy_set_surface(proxy, g_value_get_pointer(value)); break; case PROP_TIMESTAMP: gst_vaapi_surface_proxy_set_timestamp(proxy, g_value_get_uint64(value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
void duration_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data) { const guint index = GPOINTER_TO_UINT(user_data); unsigned time; GValue value = { 0 }; gtk_tree_model_get_value(model, iter, index, &value); switch (G_VALUE_TYPE(&value)) { case G_TYPE_ULONG: time = g_value_get_ulong(&value); break; case G_TYPE_UINT64: time = g_value_get_uint64(&value); break; default: g_assert_not_reached(); } g_value_unset(&value); time = 100 * time / ProcData::get_instance()->frequency; char *str = format_duration_for_display(time); g_object_set(renderer, "text", str, NULL); g_free(str); }
static void gabble_jingle_share_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GabbleJingleShare *self = GABBLE_JINGLE_SHARE (object); GabbleJingleSharePrivate *priv = self->priv; switch (property_id) { case PROP_MEDIA_TYPE: break; case PROP_FILENAME: g_free (priv->filename); priv->filename = g_value_dup_string (value); free_manifest (self); /* simulate a media_ready when we know our own filename */ _wocky_jingle_content_set_media_ready (WOCKY_JINGLE_CONTENT (self)); break; case PROP_FILESIZE: priv->filesize = g_value_get_uint64 (value); free_manifest (self); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static guint get_buffered_amount(OwrDataChannel *data_channel) { OwrDataChannelPrivate *priv = data_channel->priv; guint64 bytes_sent = 0; if (priv->on_request_bytes_sent) { GValue ret_value = G_VALUE_INIT; GValue params[1] = { G_VALUE_INIT }; g_value_init(&ret_value, G_TYPE_UINT64); g_value_init(¶ms[0], OWR_TYPE_DATA_CHANNEL); g_value_set_instance(¶ms[0], data_channel); g_closure_invoke(priv->on_request_bytes_sent, &ret_value, 1, (const GValue *)¶ms, NULL); bytes_sent = g_value_get_uint64(&ret_value); g_value_unset(¶ms[0]); g_value_unset(&ret_value); } else g_warning("on_request_bytes_sent closure not set. Cannot get buffered amount."); if (priv->bytes_sent < bytes_sent) bytes_sent = 0; else bytes_sent = priv->bytes_sent - bytes_sent; if (bytes_sent > G_MAXUINT) bytes_sent = G_MAXUINT; return (guint) bytes_sent; }
static void gst_clock_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstClock *clock; GstClockPrivate *priv; clock = GST_CLOCK (object); priv = clock->priv; switch (prop_id) { case PROP_WINDOW_SIZE: GST_CLOCK_SLAVE_LOCK (clock); priv->window_size = g_value_get_int (value); priv->window_threshold = MIN (priv->window_threshold, priv->window_size); priv->times = g_renew (GstClockTime, priv->times, 4 * priv->window_size); /* restart calibration */ priv->filling = TRUE; priv->time_index = 0; GST_CLOCK_SLAVE_UNLOCK (clock); break; case PROP_WINDOW_THRESHOLD: GST_CLOCK_SLAVE_LOCK (clock); priv->window_threshold = MIN (g_value_get_int (value), priv->window_size); GST_CLOCK_SLAVE_UNLOCK (clock); break; case PROP_TIMEOUT: gst_clock_set_timeout (clock, g_value_get_uint64 (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }