/** * gst_buffer_pool_config_add_option: * @config: a #GstBufferPool configuration * @option: an option to add * * Enabled the option in @config. This will instruct the @bufferpool to enable * the specified option on the buffers that it allocates. * * The supported options by @pool can be retrieved with gst_buffer_pool_get_options(). */ void gst_buffer_pool_config_add_option (GstStructure * config, const gchar * option) { const GValue *value; GValue option_value = { 0, }; guint i, len; g_return_if_fail (config != NULL); value = gst_structure_id_get_value (config, GST_QUARK (OPTIONS)); if (value) { len = gst_value_array_get_size (value); for (i = 0; i < len; ++i) { const GValue *nth_val = gst_value_array_get_value (value, i); if (g_str_equal (option, g_value_get_string (nth_val))) return; } } else { GValue new_array_val = { 0, }; g_value_init (&new_array_val, GST_TYPE_ARRAY); gst_structure_id_take_value (config, GST_QUARK (OPTIONS), &new_array_val); value = gst_structure_id_get_value (config, GST_QUARK (OPTIONS)); } g_value_init (&option_value, G_TYPE_STRING); g_value_set_string (&option_value, option); gst_value_array_append_value ((GValue *) value, &option_value); g_value_unset (&option_value); }
/** * 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))); }
/** * 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))); }
const GstVideoInfo * gst_allocator_get_vaapi_video_info (GstAllocator * allocator, guint * out_flags_ptr) { const GstStructure *structure; const GValue *value; g_return_val_if_fail (GST_IS_ALLOCATOR (allocator), NULL); structure = g_object_get_qdata (G_OBJECT (allocator), GST_VAAPI_VIDEO_INFO_QUARK); if (!structure) return NULL; if (out_flags_ptr) { value = gst_structure_id_get_value (structure, FLAGS_QUARK); if (!value) return NULL; *out_flags_ptr = g_value_get_uint (value); } value = gst_structure_id_get_value (structure, INFO_QUARK); if (!value) return NULL; return g_value_get_boxed (value); }
static void gst_tag_list_add_value_internal (GstStructure * list, GstTagMergeMode mode, GQuark tag, const GValue * value) { GstTagInfo *info = gst_tag_lookup (tag); const GValue *value2; g_assert (info != NULL); if (info->merge_func && (value2 = gst_structure_id_get_value (list, tag)) != NULL) { GValue dest = { 0, }; switch (mode) { case GST_TAG_MERGE_REPLACE_ALL: case GST_TAG_MERGE_REPLACE: gst_structure_id_set_value (list, tag, value); break; case GST_TAG_MERGE_PREPEND: gst_value_list_concat (&dest, value, value2); gst_structure_id_set_value (list, tag, &dest); g_value_unset (&dest); break; case GST_TAG_MERGE_APPEND: gst_value_list_concat (&dest, value2, value); gst_structure_id_set_value (list, tag, &dest); g_value_unset (&dest); break; case GST_TAG_MERGE_KEEP: case GST_TAG_MERGE_KEEP_ALL: break; default: g_assert_not_reached (); break; } } else { switch (mode) { case GST_TAG_MERGE_APPEND: case GST_TAG_MERGE_KEEP: if (gst_structure_id_get_value (list, tag) != NULL) break; /* fall through */ case GST_TAG_MERGE_REPLACE_ALL: case GST_TAG_MERGE_REPLACE: case GST_TAG_MERGE_PREPEND: gst_structure_id_set_value (list, tag, value); break; case GST_TAG_MERGE_KEEP_ALL: break; default: g_assert_not_reached (); break; } } }
/** * gst_query_parse_buffering_percent * @query: A valid #GstQuery of type GST_QUERY_BUFFERING. * @busy: if buffering is busy * @percent: a buffering percent * * Get the percentage of buffered data. This is a value between 0 and 100. * The @busy indicator is %TRUE when the buffering is in progress. * * Since: 0.10.20 */ void gst_query_parse_buffering_percent (GstQuery * query, gboolean * busy, gint * percent) { g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING); if (busy) *busy = g_value_get_boolean (gst_structure_id_get_value (query->structure, GST_QUARK (BUSY))); if (percent) *percent = g_value_get_int (gst_structure_id_get_value (query->structure, GST_QUARK (BUFFER_PERCENT))); }
/** * gst_query_parse_position: * @query: a #GstQuery * @format: the storage for the #GstFormat of the position values (may be NULL) * @cur: the storage for the current position (may be NULL) * * Parse a position query, writing the format into @format, and the position * into @cur, if the respective parameters are non-NULL. */ void gst_query_parse_position (GstQuery * query, GstFormat * format, gint64 * cur) { GstStructure *structure; g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION); structure = gst_query_get_structure (query); if (format) *format = g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (FORMAT))); if (cur) *cur = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (CURRENT))); }
/** * gst_query_parse_duration: * @query: a #GstQuery * @format: the storage for the #GstFormat of the duration value, or NULL. * @duration: the storage for the total duration, or NULL. * * Parse a duration query answer. Write the format of the duration into @format, * and the value into @duration, if the respective variables are non-NULL. */ void gst_query_parse_duration (GstQuery * query, GstFormat * format, gint64 * duration) { GstStructure *structure; g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_DURATION); structure = gst_query_get_structure (query); if (format) *format = g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (FORMAT))); if (duration) *duration = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (DURATION))); }
/** * gst_event_parse_latency: * @event: The event to query * @latency: (out): A pointer to store the latency in. * * Get the latency in the latency event. */ void gst_event_parse_latency (GstEvent * event, GstClockTime * latency) { g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_LATENCY); if (latency) *latency = g_value_get_uint64 (gst_structure_id_get_value (GST_EVENT_STRUCTURE (event), GST_QUARK (LATENCY))); }
/** * gst_event_parse_segment_done: * @event: A valid #GstEvent of type GST_EVENT_SEGMENT_DONE. * @format: (out): Result location for the format, or NULL * @position: (out): Result location for the position, or NULL * * Extracts the position and format from the segment done message. * */ void gst_event_parse_segment_done (GstEvent * event, GstFormat * format, gint64 * position) { const GstStructure *structure; const GValue *val; g_return_if_fail (event != NULL); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT_DONE); structure = gst_event_get_structure (event); val = gst_structure_id_get_value (structure, GST_QUARK (FORMAT)); if (format != NULL) *format = g_value_get_enum (val); val = gst_structure_id_get_value (structure, GST_QUARK (POSITION)); if (position != NULL) *position = g_value_get_int64 (val); }
/** * gst_query_parse_latency: * @query: a #GstQuery * @live: storage for live or NULL * @min_latency: the storage for the min latency or NULL * @max_latency: the storage for the max latency or NULL * * Parse a latency query answer. * * Since: 0.10.12 */ void gst_query_parse_latency (GstQuery * query, gboolean * live, GstClockTime * min_latency, GstClockTime * max_latency) { GstStructure *structure; g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_LATENCY); structure = gst_query_get_structure (query); if (live) *live = g_value_get_boolean (gst_structure_id_get_value (structure, GST_QUARK (LIVE))); if (min_latency) *min_latency = g_value_get_uint64 (gst_structure_id_get_value (structure, GST_QUARK (MIN_LATENCY))); if (max_latency) *max_latency = g_value_get_uint64 (gst_structure_id_get_value (structure, GST_QUARK (MAX_LATENCY))); }
/** * gst_event_parse_sink_message: * @event: The event to query * @msg: (out) (transfer full): a pointer to store the #GstMessage in. * * Parse the sink-message event. Unref @msg after usage. * * Since: 0.10.26 */ void gst_event_parse_sink_message (GstEvent * event, GstMessage ** msg) { g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_SINK_MESSAGE); if (msg) *msg = GST_MESSAGE (gst_value_dup_mini_object (gst_structure_id_get_value (event->structure, GST_QUARK (MESSAGE)))); }
/** * gst_query_parse_buffering_stats: * @query: A valid #GstQuery of type GST_QUERY_BUFFERING. * @mode: a buffering mode * @avg_in: the average input rate * @avg_out: the average output rate * @buffering_left: amount of buffering time left * * Extracts the buffering stats values from @query. * * Since: 0.10.20 */ void gst_query_parse_buffering_stats (GstQuery * query, GstBufferingMode * mode, gint * avg_in, gint * avg_out, gint64 * buffering_left) { g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING); if (mode) *mode = g_value_get_enum (gst_structure_id_get_value (query->structure, GST_QUARK (BUFFERING_MODE))); if (avg_in) *avg_in = g_value_get_int (gst_structure_id_get_value (query->structure, GST_QUARK (AVG_IN_RATE))); if (avg_out) *avg_out = g_value_get_int (gst_structure_id_get_value (query->structure, GST_QUARK (AVG_OUT_RATE))); if (buffering_left) *buffering_left = g_value_get_int64 (gst_structure_id_get_value (query->structure, GST_QUARK (BUFFERING_LEFT))); }
/** * gst_query_parse_uri: * @query: a #GstQuery * @uri: the storage for the current URI (may be NULL) * * Parse an URI query, writing the URI into @uri as a newly * allocated string, if the respective parameters are non-NULL. * Free the string with g_free() after usage. * * Since: 0.10.22 */ void gst_query_parse_uri (GstQuery * query, gchar ** uri) { GstStructure *structure; g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_URI); structure = gst_query_get_structure (query); if (uri) *uri = g_value_dup_string (gst_structure_id_get_value (structure, GST_QUARK (URI))); }
static gboolean copy_missing_fields (GQuark field_id, const GValue * value, gpointer user_data) { GstStructure *st = (GstStructure *) user_data; const GValue *val = gst_structure_id_get_value (st, field_id); if (G_UNLIKELY (val == NULL)) { gst_structure_id_set_value (st, field_id, value); } return TRUE; }
/** * gst_query_parse_convert: * @query: a #GstQuery * @src_format: the storage for the #GstFormat of the source value, or NULL * @src_value: the storage for the source value, or NULL * @dest_format: the storage for the #GstFormat of the destination value, or NULL * @dest_value: the storage for the destination value, or NULL * * Parse a convert query answer. Any of @src_format, @src_value, @dest_format, * and @dest_value may be NULL, in which case that value is omitted. */ void gst_query_parse_convert (GstQuery * query, GstFormat * src_format, gint64 * src_value, GstFormat * dest_format, gint64 * dest_value) { GstStructure *structure; g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONVERT); structure = gst_query_get_structure (query); if (src_format) *src_format = g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (SRC_FORMAT))); if (src_value) *src_value = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (SRC_VALUE))); if (dest_format) *dest_format = g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (DEST_FORMAT))); if (dest_value) *dest_value = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (DEST_VALUE))); }
/** * gst_query_parse_segment: * @query: a #GstQuery * @rate: the storage for the rate of the segment, or NULL * @format: the storage for the #GstFormat of the values, or NULL * @start_value: the storage for the start value, or NULL * @stop_value: the storage for the stop value, or NULL * * Parse a segment query answer. Any of @rate, @format, @start_value, and * @stop_value may be NULL, which will cause this value to be omitted. * * See gst_query_set_segment() for an explanation of the function arguments. */ void gst_query_parse_segment (GstQuery * query, gdouble * rate, GstFormat * format, gint64 * start_value, gint64 * stop_value) { GstStructure *structure; g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEGMENT); structure = gst_query_get_structure (query); if (rate) *rate = g_value_get_double (gst_structure_id_get_value (structure, GST_QUARK (RATE))); if (format) *format = g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (FORMAT))); if (start_value) *start_value = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (START_VALUE))); if (stop_value) *stop_value = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (STOP_VALUE))); }
/** * gst_query_parse_seeking: * @query: a GST_QUERY_SEEKING type query #GstQuery * @format: the format to set for the @segment_start and @segment_end values * @seekable: the seekable flag to set * @segment_start: the segment_start to set * @segment_end: the segment_end to set * * Parse a seeking query, writing the format into @format, and * other results into the passed parameters, if the respective parameters * are non-NULL */ void gst_query_parse_seeking (GstQuery * query, GstFormat * format, gboolean * seekable, gint64 * segment_start, gint64 * segment_end) { GstStructure *structure; g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEEKING); structure = gst_query_get_structure (query); if (format) *format = g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (FORMAT))); if (seekable) *seekable = g_value_get_boolean (gst_structure_id_get_value (structure, GST_QUARK (SEEKABLE))); if (segment_start) *segment_start = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (SEGMENT_START))); if (segment_end) *segment_end = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (SEGMENT_END))); }
/** * gst_buffer_pool_config_get_allocator: * @config: (transfer none): a #GstBufferPool configuration * @allocator: (transfer none): a #GstAllocator * @params: #GstAllocationParams * * Get the allocator and params from @config. */ gboolean gst_buffer_pool_config_get_allocator (GstStructure * config, GstAllocator ** allocator, GstAllocationParams * params) { g_return_val_if_fail (config != NULL, FALSE); if (allocator) *allocator = g_value_get_object (gst_structure_id_get_value (config, GST_QUARK (ALLOCATOR))); if (params) { GstAllocationParams *p; p = g_value_get_boxed (gst_structure_id_get_value (config, GST_QUARK (PARAMS))); if (p) { *params = *p; } else { gst_allocation_params_init (params); } } return TRUE; }
/** * gst_buffer_pool_config_n_options: * @config: a #GstBufferPool configuration * * Retrieve the number of values currently stored in the * options array of the @config structure. * * Returns: the options array size as a #guint. */ guint gst_buffer_pool_config_n_options (GstStructure * config) { const GValue *value; guint size = 0; g_return_val_if_fail (config != NULL, 0); value = gst_structure_id_get_value (config, GST_QUARK (OPTIONS)); if (value) { size = gst_value_array_get_size (value); } return size; }
/** * gst_query_parse_buffering_range: * @query: a GST_QUERY_SEEKING type query #GstQuery * @format: the format to set for the @segment_start and @segment_end values * @start: the start to set * @stop: the stop to set * @estimated_total: estimated total amount of download time * * Parse an available query, writing the format into @format, and * other results into the passed parameters, if the respective parameters * are non-NULL * * Since: 0.10.20 */ void gst_query_parse_buffering_range (GstQuery * query, GstFormat * format, gint64 * start, gint64 * stop, gint64 * estimated_total) { GstStructure *structure; g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING); structure = gst_query_get_structure (query); if (format) *format = g_value_get_enum (gst_structure_id_get_value (structure, GST_QUARK (FORMAT))); if (start) *start = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (START_VALUE))); if (stop) *stop = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (STOP_VALUE))); if (estimated_total) *estimated_total = g_value_get_int64 (gst_structure_id_get_value (structure, GST_QUARK (ESTIMATED_TOTAL))); }
/** * gst_event_parse_tag: * @event: a tag event * @taglist: (out) (transfer none): pointer to metadata list * * Parses a tag @event and stores the results in the given @taglist location. * No reference to the taglist will be returned, it remains valid only until * the @event is freed. Don't modify or free the taglist, make a copy if you * want to modify it or store it for later use. */ void gst_event_parse_tag (GstEvent * event, GstTagList ** taglist) { const GValue *val; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TAG); val = gst_structure_id_get_value (GST_EVENT_STRUCTURE (event), GST_QUARK (TAGLIST)); if (taglist) *taglist = (GstTagList *) g_value_get_boxed (val); }
/** * gst_event_parse_segment: * @event: The event to parse * @segment: (out) (transfer none): a pointer to a #GstSegment * * Parses a segment @event and stores the result in the given @segment location. * @segment remains valid only until the @event is freed. Don't modify the segment * and make a copy if you want to modify it or store it for later use. */ void gst_event_parse_segment (GstEvent * event, const GstSegment ** segment) { GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT); if (segment) { structure = GST_EVENT_STRUCTURE (event); *segment = g_value_get_boxed (gst_structure_id_get_value (structure, GST_QUARK (SEGMENT))); } }
/** * gst_event_parse_caps: * @event: The event to parse * @caps: (out) (transfer none): A pointer to the caps * * Get the caps from @event. The caps remains valid as long as @event remains * valid. */ void gst_event_parse_caps (GstEvent * event, GstCaps ** caps) { GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_CAPS); structure = GST_EVENT_STRUCTURE (event); if (G_LIKELY (caps)) *caps = g_value_get_boxed (gst_structure_id_get_value (structure, GST_QUARK (CAPS))); }
/** * gst_event_parse_flush_stop: * @event: The event to parse * @reset_time: (out): if time should be reset * * Parse the FLUSH_STOP event and retrieve the @reset_time member. */ void gst_event_parse_flush_stop (GstEvent * event, gboolean * reset_time) { GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP); structure = GST_EVENT_STRUCTURE (event); if (G_LIKELY (reset_time)) *reset_time = g_value_get_boolean (gst_structure_id_get_value (structure, GST_QUARK (RESET_TIME))); }
/** * gst_event_parse_sink_message: * @event: The event to query * @msg: (out) (transfer full): a pointer to store the #GstMessage in. * * Parse the sink-message event. Unref @msg after usage. */ void gst_event_parse_sink_message (GstEvent * event, GstMessage ** msg) { const GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_SINK_MESSAGE); structure = GST_EVENT_STRUCTURE (event); if (msg) *msg = GST_MESSAGE (g_value_dup_boxed (gst_structure_id_get_value (structure, GST_QUARK (MESSAGE)))); }
/** * gst_event_parse_latency: * @event: The event to query * @latency: A pointer to store the latency in. * * Get the latency in the latency event. * * Since: 0.10.12 */ void gst_event_parse_latency (GstEvent * event, GstClockTime * latency) { const GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_LATENCY); structure = gst_event_get_structure (event); if (latency) *latency = g_value_get_uint64 (gst_structure_id_get_value (structure, GST_QUARK (LATENCY))); }
/** * gst_event_parse_stream_start: * @event: a stream-start event. * @stream_id: (out) (transfer none): pointer to store the stream-id * * Parse a stream-id @event and store the result in the given @stream_id * location. The string stored in @stream_id must not be modified and will * remain valid only until @event gets freed. Make a copy if you want to * modify it or store it for later use. */ void gst_event_parse_stream_start (GstEvent * event, const gchar ** stream_id) { const GstStructure *structure; const GValue *val; g_return_if_fail (event != NULL); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_STREAM_START); structure = gst_event_get_structure (event); val = gst_structure_id_get_value (structure, GST_QUARK (STREAM_ID)); if (stream_id) *stream_id = g_value_get_string (val); }
/** * gst_buffer_pool_config_get_params: * @config: (transfer none): a #GstBufferPool configuration * @caps: (out) (transfer none) (allow-none): the caps of buffers * @size: (out) (allow-none): the size of each buffer, not including prefix and padding * @min_buffers: (out) (allow-none): the minimum amount of buffers to allocate. * @max_buffers: (out) (allow-none): the maximum amount of buffers to allocate or 0 for unlimited. * * Get the configuration values from @config. * * Returns: %TRUE if all parameters could be fetched. */ gboolean gst_buffer_pool_config_get_params (GstStructure * config, GstCaps ** caps, guint * size, guint * min_buffers, guint * max_buffers) { g_return_val_if_fail (config != NULL, FALSE); if (caps) { *caps = g_value_get_boxed (gst_structure_id_get_value (config, GST_QUARK (CAPS))); } return gst_structure_id_get (config, GST_QUARK (SIZE), G_TYPE_UINT, size, GST_QUARK (MIN_BUFFERS), G_TYPE_UINT, min_buffers, GST_QUARK (MAX_BUFFERS), G_TYPE_UINT, max_buffers, NULL); }