/** * gst_query_new_buffering * @format: the default #GstFormat for the new query * * Constructs a new query object for querying the buffering status of * a stream. * * Returns: A #GstQuery * * Since: 0.10.20 */ GstQuery * gst_query_new_buffering (GstFormat format) { GstQuery *query; GstStructure *structure; structure = gst_structure_empty_new ("GstQueryBuffering"); /* by default, we configure the answer as no buffering with a 100% buffering * progress */ gst_structure_id_set (structure, GST_QUARK (BUSY), G_TYPE_BOOLEAN, FALSE, GST_QUARK (BUFFER_PERCENT), G_TYPE_INT, 100, GST_QUARK (BUFFERING_MODE), GST_TYPE_BUFFERING_MODE, GST_BUFFERING_STREAM, GST_QUARK (AVG_IN_RATE), G_TYPE_INT, -1, GST_QUARK (AVG_OUT_RATE), G_TYPE_INT, -1, GST_QUARK (BUFFERING_LEFT), G_TYPE_INT64, G_GINT64_CONSTANT (0), GST_QUARK (ESTIMATED_TOTAL), G_TYPE_INT64, G_GINT64_CONSTANT (-1), GST_QUARK (FORMAT), GST_TYPE_FORMAT, format, GST_QUARK (START_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1), GST_QUARK (STOP_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL); query = gst_query_new (GST_QUERY_BUFFERING, structure); return query; }
/** * 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_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))); }
/** * 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_query_set_buffering_percent * @query: A valid #GstQuery of type GST_QUERY_BUFFERING. * @busy: if buffering is busy * @percent: a buffering percent * * Set 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_set_buffering_percent (GstQuery * query, gboolean busy, gint percent) { g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING); g_return_if_fail (percent >= 0 && percent <= 100); gst_structure_id_set (query->structure, GST_QUARK (BUSY), G_TYPE_BOOLEAN, busy, GST_QUARK (BUFFER_PERCENT), G_TYPE_INT, percent, NULL); }
/** * gst_buffer_pool_config_set_allocator: * @config: a #GstBufferPool configuration * @allocator: a #GstAllocator * @params: #GstAllocationParams * * Set the @allocator and @params on @config. * * One of @allocator and @params can be NULL, but not both. When @allocator * is NULL, the default allocator of the pool will use the values in @param * to perform its allocation. When @param is NULL, the pool will use the * provided allocator with its default #GstAllocationParams. * * A call to gst_buffer_pool_set_config() can update the allocator and params * with the values that it is able to do. Some pools are, for example, not able * to operate with different allocators or cannot allocate with the values * specified in @params. Use gst_buffer_pool_get_config() to get the currently * used values. */ void gst_buffer_pool_config_set_allocator (GstStructure * config, GstAllocator * allocator, const GstAllocationParams * params) { g_return_if_fail (config != NULL); g_return_if_fail (allocator != NULL || params != NULL); gst_structure_id_set (config, GST_QUARK (ALLOCATOR), GST_TYPE_ALLOCATOR, allocator, GST_QUARK (PARAMS), GST_TYPE_ALLOCATION_PARAMS, params, NULL); }
/** * gst_query_set_duration: * @query: a #GstQuery * @format: the #GstFormat for the duration * @duration: the duration of the stream * * Answer a duration query by setting the requested value in the given format. */ void gst_query_set_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); gst_structure_id_set (structure, GST_QUARK (FORMAT), GST_TYPE_FORMAT, format, GST_QUARK (DURATION), G_TYPE_INT64, duration, NULL); }
/** * gst_query_set_position: * @query: a #GstQuery with query type GST_QUERY_POSITION * @format: the requested #GstFormat * @cur: the position to set * * Answer a position query by setting the requested value in the given format. */ void gst_query_set_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); gst_structure_id_set (structure, GST_QUARK (FORMAT), GST_TYPE_FORMAT, format, GST_QUARK (CURRENT), G_TYPE_INT64, cur, NULL); }
/** * gst_event_new_stream_start: * @stream_id: Identifier for this stream * * Create a new STREAM_START event. The stream start event can only * travel downstream synchronized with the buffer flow. It is expected * to be the first event that is sent for a new stream. * * Source elements, demuxers and other elements that create new streams * are supposed to send this event as the first event of a new stream. It * should not be send after a flushing seek or in similar situations * and is used to mark the beginning of a new logical stream. Elements * combining multiple streams must ensure that this event is only forwarded * downstream once and not for every single input stream. * * The @stream_id should be a unique string that consists of the upstream * stream-id, / as separator and a unique stream-id for this specific * stream. A new stream-id should only be created for a stream if the upstream * stream is split into (potentially) multiple new streams, e.g. in a demuxer, * but not for every single element in the pipeline. * gst_pad_create_stream_id() or gst_pad_create_stream_id_printf() can be * used to create a stream-id. * * Returns: (transfer full): the new STREAM_START event. */ GstEvent * gst_event_new_stream_start (const gchar * stream_id) { GstStructure *s; g_return_val_if_fail (stream_id != NULL, NULL); s = gst_structure_new_id (GST_QUARK (EVENT_STREAM_START), GST_QUARK (STREAM_ID), G_TYPE_STRING, stream_id, NULL); return gst_event_new_custom (GST_EVENT_STREAM_START, s); }
/** * gst_query_set_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 * * Configures the buffering stats values in @query. * * Since: 0.10.20 */ void gst_query_set_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); gst_structure_id_set (query->structure, GST_QUARK (BUFFERING_MODE), GST_TYPE_BUFFERING_MODE, mode, GST_QUARK (AVG_IN_RATE), G_TYPE_INT, avg_in, GST_QUARK (AVG_OUT_RATE), G_TYPE_INT, avg_out, GST_QUARK (BUFFERING_LEFT), G_TYPE_INT64, buffering_left, NULL); }
/** * 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_new_uri: * * Constructs a new query URI query object. Use gst_query_unref() * when done with it. An URI query is used to query the current URI * that is used by the source or sink. * * Returns: A #GstQuery * * Since: 0.10.22 */ GstQuery * gst_query_new_uri (void) { GstQuery *query; GstStructure *structure; structure = gst_structure_id_new (GST_QUARK (QUERY_URI), GST_QUARK (URI), G_TYPE_STRING, NULL, NULL); query = gst_query_new (GST_QUERY_URI, structure); return query; }
/** * gst_event_new_flush_stop: * @reset_time: if time should be reset * * Allocate a new flush stop event. The flush stop event can be sent * upstream and downstream and travels serialized with the dataflow. * It is typically sent after sending a FLUSH_START event to make the * pads accept data again. * * Elements can process this event synchronized with the dataflow since * the preceeding FLUSH_START event stopped the dataflow. * * This event is typically generated to complete a seek and to resume * dataflow. * * Returns: (transfer full): a new flush stop event. */ GstEvent * gst_event_new_flush_stop (gboolean reset_time) { GstEvent *event; GST_CAT_INFO (GST_CAT_EVENT, "creating flush stop %d", reset_time); event = gst_event_new_custom (GST_EVENT_FLUSH_STOP, gst_structure_new_id (GST_QUARK (EVENT_FLUSH_STOP), GST_QUARK (RESET_TIME), G_TYPE_BOOLEAN, reset_time, NULL)); return event; }
/** * gst_event_new_toc_select: * @uid: UID in the TOC to start playback from. * * Generate a TOC select event with the given @uid. The purpose of the * TOC select event is to start playback based on the TOC's entry with the * given @uid. * * Returns: a new #GstEvent. */ GstEvent * gst_event_new_toc_select (const gchar * uid) { GstStructure *structure; g_return_val_if_fail (uid != NULL, NULL); GST_CAT_INFO (GST_CAT_EVENT, "creating toc select event for UID: %s", uid); structure = gst_structure_new_id (GST_QUARK (EVENT_TOC_SELECT), GST_QUARK (UID), G_TYPE_STRING, uid, NULL); return gst_event_new_custom (GST_EVENT_TOC_SELECT, structure); }
/** * gst_query_set_latency: * @query: a #GstQuery * @live: if there is a live element upstream * @min_latency: the minimal latency of the live element * @max_latency: the maximal latency of the live element * * Answer a latency query by setting the requested values in the given format. * * Since: 0.10.12 */ void gst_query_set_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); gst_structure_id_set (structure, GST_QUARK (LIVE), G_TYPE_BOOLEAN, live, GST_QUARK (MIN_LATENCY), G_TYPE_UINT64, min_latency, GST_QUARK (MAX_LATENCY), G_TYPE_UINT64, max_latency, NULL); }
/** * gst_buffer_pool_config_set_params: * @config: a #GstBufferPool configuration * @caps: caps for the buffers * @size: the size of each buffer, not including prefix and padding * @min_buffers: the minimum amount of buffers to allocate. * @max_buffers: the maximum amount of buffers to allocate or 0 for unlimited. * * Configure @config with the given parameters. */ void gst_buffer_pool_config_set_params (GstStructure * config, GstCaps * caps, guint size, guint min_buffers, guint max_buffers) { g_return_if_fail (config != NULL); g_return_if_fail (max_buffers == 0 || min_buffers <= max_buffers); g_return_if_fail (caps == NULL || gst_caps_is_fixed (caps)); gst_structure_id_set (config, GST_QUARK (CAPS), GST_TYPE_CAPS, caps, 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); }
/** * gst_query_new_duration: * @format: the #GstFormat for this duration query * * Constructs a new stream duration query object to query in the given format. * Use gst_query_unref() when done with it. A duration query will give the * total length of the stream. * * Returns: A #GstQuery */ GstQuery * gst_query_new_duration (GstFormat format) { GstQuery *query; GstStructure *structure; structure = gst_structure_id_new (GST_QUARK (QUERY_DURATION), GST_QUARK (FORMAT), GST_TYPE_FORMAT, format, GST_QUARK (DURATION), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL); query = gst_query_new (GST_QUERY_DURATION, structure); return query; }
/** * gst_event_parse_gap: * @event: a #GstEvent of type #GST_EVENT_GAP * @timestamp: (out) (allow-none): location where to store the * start time (pts) of the gap, or %NULL * @duration: (out) (allow-none): location where to store the duration of * the gap, or %NULL * * Extract timestamp and duration from a new GAP event. */ void gst_event_parse_gap (GstEvent * event, GstClockTime * timestamp, GstClockTime * duration) { GstStructure *structure; g_return_if_fail (GST_IS_EVENT (event)); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_GAP); structure = GST_EVENT_STRUCTURE (event); gst_structure_id_get (structure, GST_QUARK (TIMESTAMP), GST_TYPE_CLOCK_TIME, timestamp, GST_QUARK (DURATION), GST_TYPE_CLOCK_TIME, duration, NULL); }
/** * gst_event_parse_toc: * @event: a TOC event. * @toc: (out) (transfer full): pointer to #GstToc structure. * @updated: (out): pointer to store TOC updated flag. * * Parse a TOC @event and store the results in the given @toc and @updated locations. */ void gst_event_parse_toc (GstEvent * event, GstToc ** toc, gboolean * updated) { const GstStructure *structure; g_return_if_fail (event != NULL); g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TOC); g_return_if_fail (toc != NULL); structure = gst_event_get_structure (event); gst_structure_id_get (structure, GST_QUARK (TOC), GST_TYPE_TOC, toc, GST_QUARK (UPDATED), G_TYPE_BOOLEAN, updated, NULL); }
/** * gst_query_set_buffering_range: * @query: a #GstQuery * @format: the format to set for the @start and @stop values * @start: the start to set * @stop: the stop to set * @estimated_total: estimated total amount of download time * * Set the available query result fields in @query. * * Since: 0.10.20 */ void gst_query_set_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); gst_structure_id_set (structure, GST_QUARK (FORMAT), GST_TYPE_FORMAT, format, GST_QUARK (START_VALUE), G_TYPE_INT64, start, GST_QUARK (STOP_VALUE), G_TYPE_INT64, stop, GST_QUARK (ESTIMATED_TOTAL), G_TYPE_INT64, estimated_total, NULL); }
/** * gst_query_set_segment: * @query: a #GstQuery * @rate: the rate of the segment * @format: the #GstFormat of the segment values (@start_value and @stop_value) * @start_value: the start value * @stop_value: the stop value * * Answer a segment query by setting the requested values. The normal * playback segment of a pipeline is 0 to duration at the default rate of * 1.0. If a seek was performed on the pipeline to play a different * segment, this query will return the range specified in the last seek. * * @start_value and @stop_value will respectively contain the configured * playback range start and stop values expressed in @format. * The values are always between 0 and the duration of the media and * @start_value <= @stop_value. @rate will contain the playback rate. For * negative rates, playback will actually happen from @stop_value to * @start_value. */ void gst_query_set_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); gst_structure_id_set (structure, GST_QUARK (RATE), G_TYPE_DOUBLE, rate, GST_QUARK (FORMAT), GST_TYPE_FORMAT, format, GST_QUARK (START_VALUE), G_TYPE_INT64, start_value, GST_QUARK (STOP_VALUE), G_TYPE_INT64, stop_value, NULL); }
/** * gst_event_new_latency: * @latency: the new latency value * * Create a new latency event. The event is sent upstream from the sinks and * notifies elements that they should add an additional @latency to the * running time before synchronising against the clock. * * The latency is mostly used in live sinks and is always expressed in * the time format. * * Returns: (transfer full): a new #GstEvent */ GstEvent * gst_event_new_latency (GstClockTime latency) { GstEvent *event; GstStructure *structure; GST_CAT_INFO (GST_CAT_EVENT, "creating latency event %" GST_TIME_FORMAT, GST_TIME_ARGS (latency)); structure = gst_structure_new_id (GST_QUARK (EVENT_LATENCY), GST_QUARK (LATENCY), G_TYPE_UINT64, latency, NULL); event = gst_event_new_custom (GST_EVENT_LATENCY, structure); return event; }
/** * 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); }
/** * 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_new_position: * @format: the default #GstFormat for the new query * * Constructs a new query stream position query object. Use gst_query_unref() * when done with it. A position query is used to query the current position * of playback in the streams, in some format. * * Returns: A #GstQuery */ GstQuery * gst_query_new_position (GstFormat format) { GstQuery *query; GstStructure *structure; structure = gst_structure_empty_new ("GstQueryPosition"); gst_structure_id_set (structure, GST_QUARK (FORMAT), GST_TYPE_FORMAT, format, GST_QUARK (CURRENT), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL); query = gst_query_new (GST_QUERY_POSITION, structure); return query; }
/** * gst_query_set_seeking: * @query: a #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 * * Set the seeking query result fields in @query. */ void gst_query_set_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); gst_structure_id_set (structure, GST_QUARK (FORMAT), GST_TYPE_FORMAT, format, GST_QUARK (SEEKABLE), G_TYPE_BOOLEAN, seekable, GST_QUARK (SEGMENT_START), G_TYPE_INT64, segment_start, GST_QUARK (SEGMENT_END), G_TYPE_INT64, segment_end, NULL); }
/** * gst_query_new_latency: * * Constructs a new latency query object. * Use gst_query_unref() when done with it. A latency query is usually performed * by sinks to compensate for additional latency introduced by elements in the * pipeline. * * Returns: A #GstQuery * * Since: 0.10.12 */ GstQuery * gst_query_new_latency (void) { GstQuery *query; GstStructure *structure; structure = gst_structure_id_new (GST_QUARK (QUERY_LATENCY), GST_QUARK (LIVE), G_TYPE_BOOLEAN, FALSE, GST_QUARK (MIN_LATENCY), G_TYPE_UINT64, G_GUINT64_CONSTANT (0), GST_QUARK (MAX_LATENCY), G_TYPE_UINT64, G_GUINT64_CONSTANT (-1), NULL); query = gst_query_new (GST_QUERY_LATENCY, structure); return query; }
/** * gst_query_set_convert: * @query: a #GstQuery * @src_format: the source #GstFormat * @src_value: the source value * @dest_format: the destination #GstFormat * @dest_value: the destination value * * Answer a convert query by setting the requested values. */ void gst_query_set_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); gst_structure_id_set (structure, GST_QUARK (SRC_FORMAT), GST_TYPE_FORMAT, src_format, GST_QUARK (SRC_VALUE), G_TYPE_INT64, src_value, GST_QUARK (DEST_FORMAT), GST_TYPE_FORMAT, dest_format, GST_QUARK (DEST_VALUE), G_TYPE_INT64, dest_value, NULL); }
/** * gst_event_new_caps: * @caps: (transfer none): a #GstCaps * * Create a new CAPS event for @caps. The caps event can only travel downstream * synchronized with the buffer flow and contains the format of the buffers * that will follow after the event. * * Returns: (transfer full): the new CAPS event. */ GstEvent * gst_event_new_caps (GstCaps * caps) { GstEvent *event; g_return_val_if_fail (caps != NULL, NULL); g_return_val_if_fail (gst_caps_is_fixed (caps), NULL); GST_CAT_INFO (GST_CAT_EVENT, "creating caps event %" GST_PTR_FORMAT, caps); event = gst_event_new_custom (GST_EVENT_CAPS, gst_structure_new_id (GST_QUARK (EVENT_CAPS), GST_QUARK (CAPS), GST_TYPE_CAPS, caps, NULL)); return event; }