static void _set_property (GObject *object, unsigned int property_id, const GValue *value, GParamSpec *pspec) { MpdStorageDevicePrivate *priv = GET_PRIVATE (object); switch (property_id) { case PROP_AVAILABLE_SIZE: mpd_storage_device_set_available_size (MPD_STORAGE_DEVICE (object), g_value_get_int64 (value)); break; case PROP_PATH: /* Construct-only */ priv->path = g_value_dup_string (value); break; case PROP_SIZE: mpd_storage_device_set_size (MPD_STORAGE_DEVICE (object), g_value_get_int64 (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static void gst_base_audio_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstBaseAudioSrc *src; src = GST_BASE_AUDIO_SRC (object); switch (prop_id) { case PROP_BUFFER_TIME: src->buffer_time = g_value_get_int64 (value); break; case PROP_LATENCY_TIME: src->latency_time = g_value_get_int64 (value); break; case PROP_PROVIDE_CLOCK: gst_base_audio_src_set_provide_clock (src, g_value_get_boolean (value)); break; case PROP_SLAVE_METHOD: gst_base_audio_src_set_slave_method (src, g_value_get_enum (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/** * gst_event_parse_buffer_size: * @event: The event to query * @format: (out): A pointer to store the format in * @minsize: (out): A pointer to store the minsize in * @maxsize: (out): A pointer to store the maxsize in * @async: (out): A pointer to store the async-flag in * * Get the format, minsize, maxsize and async-flag in the buffersize event. */ void gst_event_parse_buffer_size (GstEvent * event, GstFormat * format, gint64 * minsize, gint64 * maxsize, gboolean * async) { const GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_BUFFERSIZE); structure = GST_EVENT_STRUCTURE (event); if (format) *format = (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (FORMAT))); if (minsize) *minsize = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (MINSIZE))); if (maxsize) *maxsize = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (MAXSIZE))); if (async) *async = g_value_get_boolean (gst_structure_id_get_value (structure, GST_QUARK (ASYNC))); }
gint64 ghb_value_int64(const GValue *val) { gint64 result; if (val == NULL) return 0; GValue xform = {0,}; if (G_VALUE_TYPE(val) != G_TYPE_INT64) { g_value_init(&xform, G_TYPE_INT64); if (!g_value_transform(val, &xform)) { debug_show_type(G_VALUE_TYPE(val)); g_warning("int64 can't transform"); return 0; } result = g_value_get_int64(&xform); g_value_unset(&xform); } else { result = g_value_get_int64(val); } return result; }
static void viewers_converter(GBinding* bind, const GValue* from, GValue* to, gpointer udata) { gint64 viewers; gchar* label; if (g_value_get_int64(from) > -1) { viewers = g_value_get_int64(from); if (viewers > 1e4) label = g_strdup_printf("%2.1fk", (gdouble) viewers / 1e3); else label = g_strdup_printf("%ld", viewers); g_value_set_string(to, label); g_free(label); } else { g_value_set_string(to, NULL); } }
static gboolean length_finish (gpointer test, GValue * value) { LengthTest *t = test; if (g_value_get_int64 (value) == -1) return TRUE; return t->value == g_value_get_int64 (value); }
static gboolean timedur_finish (gpointer test, GValue * value) { TimeDurTest *t = test; if (g_value_get_int64 (value) == -1) return TRUE; return (t->diff / MAX (1, t->count)) <= g_value_get_int64 (value); }
static void gst_rtp_base_payload_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstRTPBasePayload *rtpbasepayload; GstRTPBasePayloadPrivate *priv; gint64 val; rtpbasepayload = GST_RTP_BASE_PAYLOAD (object); priv = rtpbasepayload->priv; switch (prop_id) { case PROP_MTU: rtpbasepayload->mtu = g_value_get_uint (value); break; case PROP_PT: rtpbasepayload->pt = g_value_get_uint (value); break; case PROP_SSRC: val = g_value_get_uint (value); rtpbasepayload->ssrc = val; priv->ssrc_random = FALSE; break; case PROP_TIMESTAMP_OFFSET: val = g_value_get_uint (value); rtpbasepayload->ts_offset = val; priv->ts_offset_random = FALSE; break; case PROP_SEQNUM_OFFSET: val = g_value_get_int (value); rtpbasepayload->seqnum_offset = val; priv->seqnum_offset_random = (val == -1); GST_DEBUG_OBJECT (rtpbasepayload, "seqnum offset 0x%04x, random %d", rtpbasepayload->seqnum_offset, priv->seqnum_offset_random); break; case PROP_MAX_PTIME: rtpbasepayload->priv->prop_max_ptime = g_value_get_int64 (value); update_max_ptime (rtpbasepayload); break; case PROP_MIN_PTIME: rtpbasepayload->min_ptime = g_value_get_int64 (value); break; case PROP_PERFECT_RTPTIME: priv->perfect_rtptime = g_value_get_boolean (value); break; case PROP_PTIME_MULTIPLE: rtpbasepayload->ptime_multiple = g_value_get_int64 (value); 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 gimp_thumbnail_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpThumbnail *thumbnail = GIMP_THUMBNAIL (object); switch (property_id) { case PROP_IMAGE_STATE: thumbnail->image_state = g_value_get_enum (value); break; case PROP_IMAGE_URI: gimp_thumbnail_set_uri (GIMP_THUMBNAIL (object), g_value_get_string (value)); break; case PROP_IMAGE_MTIME: thumbnail->image_mtime = g_value_get_int64 (value); break; case PROP_IMAGE_FILESIZE: thumbnail->image_filesize = g_value_get_int64 (value); break; case PROP_IMAGE_MIMETYPE: g_free (thumbnail->image_mimetype); thumbnail->image_mimetype = g_value_dup_string (value); break; case PROP_IMAGE_WIDTH: thumbnail->image_width = g_value_get_int (value); break; case PROP_IMAGE_HEIGHT: thumbnail->image_height = g_value_get_int (value); break; case PROP_IMAGE_TYPE: g_free (thumbnail->image_type); thumbnail->image_type = g_value_dup_string (value); break; case PROP_IMAGE_NUM_LAYERS: thumbnail->image_num_layers = g_value_get_int (value); break; case PROP_THUMB_STATE: thumbnail->thumb_state = g_value_get_enum (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_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 rg_table_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { RgTable *self = (RgTable *)object; switch (prop_id) { case PROP_MAX_SAMPLES: rg_table_set_max_samples (self, g_value_get_uint (value)); break; case PROP_TIMESPAN: rg_table_set_timespan (self, g_value_get_int64 (value)); break; case PROP_VALUE_MAX: rg_table_set_value_max (self, g_value_get_double (value)); break; case PROP_VALUE_MIN: rg_table_set_value_min (self, g_value_get_double (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
/* GObject vmethods implementation */ static void gst_lv2_source_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstLV2Source *self = (GstLV2Source *) object; switch (prop_id) { case GST_LV2_SOURCE_PROP_SAMPLES_PER_BUFFER: self->samples_per_buffer = g_value_get_int (value); gst_base_src_set_blocksize (GST_BASE_SRC (self), GST_AUDIO_INFO_BPF (&self->info) * self->samples_per_buffer); break; case GST_LV2_SOURCE_PROP_IS_LIVE: gst_base_src_set_live (GST_BASE_SRC (self), g_value_get_boolean (value)); break; case GST_LV2_SOURCE_PROP_TIMESTAMP_OFFSET: self->timestamp_offset = g_value_get_int64 (value); break; case GST_LV2_SOURCE_PROP_CAN_ACTIVATE_PUSH: GST_BASE_SRC (self)->can_activate_push = g_value_get_boolean (value); break; case GST_LV2_SOURCE_PROP_CAN_ACTIVATE_PULL: self->can_activate_pull = g_value_get_boolean (value); break; default: gst_lv2_object_set_property (&self->lv2, object, prop_id, value, pspec); break; } }
static void _sw_item_update_from_value_array (SwItem *item, GValueArray *varray) { if (item->service) { g_free (item->service); item->service = NULL; } item->service = g_value_dup_string (g_value_array_get_nth (varray, 0)); if (item->uuid) { g_free (item->uuid); item->uuid = NULL; } item->uuid = g_value_dup_string (g_value_array_get_nth (varray, 1)); item->date.tv_sec = g_value_get_int64 (g_value_array_get_nth (varray, 2)); if (item->props) { g_hash_table_unref (item->props); item->props = NULL; } item->props = g_value_dup_boxed (g_value_array_get_nth (varray, 3)); }
static void gst_ladspa_source_type_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstLADSPASource *ladspa = GST_LADSPA_SOURCE (object); switch (prop_id) { case GST_LADSPA_SOURCE_PROP_SAMPLES_PER_BUFFER: ladspa->samples_per_buffer = g_value_get_int (value); gst_base_src_set_blocksize (GST_BASE_SRC (ladspa), GST_AUDIO_INFO_BPF (&ladspa->info) * ladspa->samples_per_buffer); break; case GST_LADSPA_SOURCE_PROP_IS_LIVE: gst_base_src_set_live (GST_BASE_SRC (ladspa), g_value_get_boolean (value)); break; case GST_LADSPA_SOURCE_PROP_TIMESTAMP_OFFSET: ladspa->timestamp_offset = g_value_get_int64 (value); break; case GST_LADSPA_SOURCE_PROP_CAN_ACTIVATE_PUSH: GST_BASE_SRC (ladspa)->can_activate_push = g_value_get_boolean (value); break; case GST_LADSPA_SOURCE_PROP_CAN_ACTIVATE_PULL: ladspa->can_activate_pull = g_value_get_boolean (value); break; default: gst_ladspa_object_set_property (&ladspa->ladspa, object, prop_id, value, pspec); break; } }
static void gsd_ldsm_dialog_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GsdLdsmDialog *self; g_return_if_fail (GSD_IS_LDSM_DIALOG (object)); self = GSD_LDSM_DIALOG (object); switch (prop_id) { case PROP_OTHER_USABLE_PARTITIONS: self->priv->other_usable_partitions = g_value_get_boolean (value); break; case PROP_OTHER_PARTITIONS: self->priv->other_partitions = g_value_get_boolean (value); break; case PROP_HAS_TRASH: self->priv->has_trash = g_value_get_boolean (value); break; case PROP_SPACE_REMAINING: self->priv->space_remaining = g_value_get_int64 (value); break; case PROP_PARTITION_NAME: self->priv->partition_name = g_value_dup_string (value); break; case PROP_MOUNT_PATH: self->priv->mount_path = g_value_dup_string (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void tpl_call_event_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec) { TplCallEventPriv *priv = TPL_CALL_EVENT (object)->priv; switch (param_id) { case PROP_DURATION: priv->duration = g_value_get_int64 (value); break; case PROP_END_ACTOR: priv->end_actor = g_value_dup_object (value); break; case PROP_END_REASON: priv->end_reason = g_value_get_int (value); break; case PROP_DETAILED_END_REASON: priv->detailed_end_reason = g_value_dup_string (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; } }
static void gst_v4lsrc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstV4lSrc *v4lsrc = GST_V4LSRC (object); switch (prop_id) { case PROP_AUTOPROBE: g_return_if_fail (!GST_V4L_IS_ACTIVE (GST_V4LELEMENT (v4lsrc))); v4lsrc->autoprobe = g_value_get_boolean (value); break; case PROP_AUTOPROBE_FPS: g_return_if_fail (!GST_V4L_IS_ACTIVE (GST_V4LELEMENT (v4lsrc))); v4lsrc->autoprobe_fps = g_value_get_boolean (value); break; case PROP_COPY_MODE: v4lsrc->copy_mode = g_value_get_boolean (value); break; case PROP_TIMESTAMP_OFFSET: v4lsrc->timestamp_offset = g_value_get_int64 (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
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; }
void debug_show_value(GValue *gval) { GType tp; tp = G_VALUE_TYPE(gval); if (tp == G_TYPE_STRING) { g_message("Type %s value %s", "string", g_value_get_string(gval)); } else if (tp == G_TYPE_INT) { g_message("Type %s value %d", "int", g_value_get_int(gval)); } else if (tp == G_TYPE_INT64) { g_message("Type %s value %" PRId64, "int64", g_value_get_int64(gval)); } else if (tp == G_TYPE_DOUBLE) { g_message("Type %s value %f", "double", g_value_get_double(gval)); } else if (tp == G_TYPE_BOOLEAN) { g_message("Type %s value %d", "boolean", g_value_get_boolean(gval)); } else if (tp == ghb_array_get_type()) { g_message("Type %s", "boolean"); } else if (tp == ghb_dict_get_type()) { g_message("Type %s", "dict"); } }
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_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_INT64); G_OBJECT_CLASS (pspec_class)->get_property (object, parent_spec->param_id, &v, parent_spec); g_value_set_uint (value, g_value_get_int64 (&v) / GST_MSECOND); 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 void replay_to_json (gint64 time, const char *name, const char *signature, GValue *arg, gpointer user_data) { ReplayToJsonClosure *closure = user_data; char *event_str; if (closure->error != NULL) return; if (!closure->first) { if (!write_string (closure->out, ",\n ", &closure->error)) return; } closure->first = FALSE; if (strcmp (signature, "") == 0) { event_str = g_strdup_printf ("[%" G_GINT64_FORMAT ", \"%s\"]", time, name); } else if (strcmp (signature, "i") == 0) { event_str = g_strdup_printf ("[%" G_GINT64_FORMAT ", \"%s\", %i]", time, name, g_value_get_int (arg)); } else if (strcmp (signature, "x") == 0) { event_str = g_strdup_printf ("[%" G_GINT64_FORMAT ", \"%s\", %"G_GINT64_FORMAT "]", time, name, g_value_get_int64 (arg)); } else if (strcmp (signature, "s") == 0) { const char *arg_str = g_value_get_string (arg); char *escaped = escape_quotes (arg_str); event_str = g_strdup_printf ("[%" G_GINT64_FORMAT ", \"%s\", \"%s\"]", time, name, g_value_get_string (arg)); if (escaped != arg_str) g_free (escaped); } else { g_assert_not_reached (); } if (!write_string (closure->out, event_str, &closure->error)) return; }
/** * 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))); }
/* * Set the value of a property for the server sink. */ static void gst_shm_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstShmSink *self = GST_SHM_SINK (object); int ret = 0; switch (prop_id) { case PROP_SOCKET_PATH: GST_OBJECT_LOCK (object); g_free (self->socket_path); self->socket_path = g_value_dup_string (value); GST_OBJECT_UNLOCK (object); break; case PROP_PERMS: GST_OBJECT_LOCK (object); self->perms = g_value_get_uint (value); if (self->pipe) ret = sp_writer_setperms_shm (self->pipe, self->perms); GST_OBJECT_UNLOCK (object); if (ret < 0) GST_WARNING_OBJECT (object, "Could not set permissions on pipe: %s", strerror (ret)); break; case PROP_SHM_SIZE: GST_OBJECT_LOCK (object); if (self->pipe) { if (sp_writer_resize (self->pipe, g_value_get_uint (value)) < 0) { /* Swap allocators, so we can know immediately if the memory is * ours */ gst_object_unref (self->allocator); self->allocator = gst_shm_sink_allocator_new (self); GST_DEBUG_OBJECT (self, "Resized shared memory area from %u to " "%u bytes", self->size, g_value_get_uint (value)); } else { GST_WARNING_OBJECT (self, "Could not resize shared memory area from" "%u to %u bytes", self->size, g_value_get_uint (value)); } } self->size = g_value_get_uint (value); GST_OBJECT_UNLOCK (object); break; case PROP_WAIT_FOR_CONNECTION: GST_OBJECT_LOCK (object); self->wait_for_connection = g_value_get_boolean (value); GST_OBJECT_UNLOCK (object); g_cond_broadcast (&self->cond); break; case PROP_BUFFER_TIME: GST_OBJECT_LOCK (object); self->buffer_time = g_value_get_int64 (value); GST_OBJECT_UNLOCK (object); g_cond_broadcast (&self->cond); break; default: break; } }
static void gst_basertppayload_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstBaseRTPPayload *basertppayload; GstBaseRTPPayloadPrivate *priv; gint64 val; basertppayload = GST_BASE_RTP_PAYLOAD (object); priv = basertppayload->priv; switch (prop_id) { case PROP_MTU: basertppayload->mtu = g_value_get_uint (value); break; case PROP_PT: basertppayload->pt = g_value_get_uint (value); break; case PROP_SSRC: val = g_value_get_uint (value); basertppayload->ssrc = val; priv->ssrc_random = FALSE; break; case PROP_TIMESTAMP_OFFSET: val = g_value_get_uint (value); basertppayload->ts_offset = val; priv->ts_offset_random = FALSE; break; case PROP_SEQNUM_OFFSET: val = g_value_get_int (value); basertppayload->seqnum_offset = val; priv->seqnum_offset_random = (val == -1); GST_DEBUG_OBJECT (basertppayload, "seqnum offset 0x%04x, random %d", basertppayload->seqnum_offset, priv->seqnum_offset_random); break; case PROP_MAX_PTIME: basertppayload->max_ptime = g_value_get_int64 (value); break; case PROP_MIN_PTIME: basertppayload->min_ptime = g_value_get_int64 (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/** * gdata_freebase_topic_value_get_int: * @value: a #GDataFreebaseTopicValue * * Returns a #gint64 value held in @value. It is only valid to call this if the #GType is a %G_TYPE_INT64 * * Returns: the #gint64 value * * Since: 0.15.1 **/ gint64 gdata_freebase_topic_value_get_int (GDataFreebaseTopicValue *value) { g_return_val_if_fail (value != NULL, 0); g_return_val_if_fail (G_VALUE_HOLDS_INT64 (&value->value), 0); return g_value_get_int64 (&value->value); }
void ags_port_real_safe_write(AgsPort *port, GValue *value) { guint overall_size; gpointer data; if(port == NULL){ return; } overall_size = port->port_value_length * port->port_value_size; pthread_mutex_lock(&(port->mutex)); if(!port->port_value_is_pointer){ if(port->port_value_type == G_TYPE_BOOLEAN){ port->port_value.ags_port_boolean = g_value_get_boolean(value); }else if(port->port_value_type == G_TYPE_INT64){ port->port_value.ags_port_int = g_value_get_int64(value); }else if(port->port_value_type == G_TYPE_UINT64){ port->port_value.ags_port_uint = g_value_get_uint64(value); }else if(port->port_value_type == G_TYPE_FLOAT){ port->port_value.ags_port_float = (gfloat) g_value_get_float(value); }else if(port->port_value_type == G_TYPE_DOUBLE){ port->port_value.ags_port_double = g_value_get_double(value); }else if(port->port_value_type == G_TYPE_POINTER){ port->port_value.ags_port_pointer = g_value_get_pointer(value); }else if(port->port_value_type == G_TYPE_OBJECT){ port->port_value.ags_port_object = g_value_get_object(value); }else{ g_warning("ags_port.c: unknown type\0"); } }else{ data = g_value_get_pointer(value); if(port->port_value_type == G_TYPE_BOOLEAN){ memcpy(port->port_value.ags_port_boolean_ptr, data, overall_size); }else if(port->port_value_type == G_TYPE_INT64){ memcpy(port->port_value.ags_port_int_ptr, data, overall_size); }else if(port->port_value_type == G_TYPE_UINT64){ memcpy(port->port_value.ags_port_uint_ptr, data, overall_size); }else if(port->port_value_type == G_TYPE_DOUBLE){ memcpy(port->port_value.ags_port_double_ptr, data, overall_size); }else if(port->port_value_type == G_TYPE_POINTER){ port->port_value.ags_port_pointer = data; }else{ data = g_value_get_object(value); if(port->port_value_type == G_TYPE_OBJECT){ port->port_value.ags_port_object = data; }else{ g_warning("ags_port.c: unknown type\0"); } } } pthread_mutex_unlock(&(port->mutex)); }
static void set_property(GObject* obj, guint prop, const GValue* val, GParamSpec* pspec) { GtGame* self = GT_GAME(obj); GtGamePrivate* priv = gt_game_get_instance_private(self); switch (prop) { case PROP_ID: priv->id = g_value_get_int64(val); break; case PROP_NAME: if (priv->name) g_free(priv->name); priv->name = g_value_dup_string(val); if (!priv->name) priv->name = "Untitled broadcast"; break; case PROP_PREVIEW: if (priv->preview) g_object_unref(priv->preview); priv->preview = g_value_ref_sink_object(val); utils_pixbuf_scale_simple(&priv->preview, 200, 270, GDK_INTERP_BILINEAR); break; case PROP_LOGO: if (priv->logo) g_object_unref(priv->logo); priv->logo = g_value_dup_object(val); break; case PROP_VIEWERS: priv->viewers = g_value_get_int64(val); break; case PROP_CHANNELS: priv->channels = g_value_get_int64(val); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop, pspec); } }