And fix memory leaks/null pointer dereferences in GstUri in error cases.
Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/3194>
*
* Get the head element of the queue.
*
- * Returns: (transfer full): the head element of @queue or %NULL when
+ * Returns: (transfer full) (nullable): the head element of @queue or %NULL when
* the queue is empty.
*/
gpointer
* duration and offset end fields are also copied. If not they will be set
* to #GST_CLOCK_TIME_NONE and #GST_BUFFER_OFFSET_NONE.
*
- * Returns: (transfer full): the new #GstBuffer or %NULL if the arguments were
- * invalid.
+ * Returns: (transfer full) (nullable): the new #GstBuffer or %NULL if copying
+ * failed.
*/
GstBuffer *
gst_buffer_copy_region (GstBuffer * buffer, GstBufferCopyFlags flags,
/**
* gst_buffer_pool_acquire_buffer:
* @pool: a #GstBufferPool
- * @buffer: (out): a location for a #GstBuffer
- * @params: (transfer none) (allow-none): parameters.
+ * @buffer: (out) (transfer full) (nullable): a location for a #GstBuffer
+ * @params: (transfer none) (nullable): parameters.
*
* Acquires a buffer from @pool. @buffer should point to a memory location that
* can hold a pointer to the new buffer. When the pool is empty, this function
g_return_val_if_fail (GST_IS_BUFFER_POOL (pool), GST_FLOW_ERROR);
g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
+ *buffer = NULL;
+
pclass = GST_BUFFER_POOL_GET_CLASS (pool);
/* assume we'll have one more outstanding buffer we need to do that so
/**
* GstBufferPoolClass::acquire_buffer:
* @pool: the #GstBufferPool
- * @buffer: (out): a location for a #GstBuffer
- * @params: (transfer none) (allow-none): parameters.
+ * @buffer: (out) (transfer full) (nullable): a location for a #GstBuffer
+ * @params: (transfer none) (nullable): parameters.
*
* Get a new buffer from the pool. The default implementation
* will take a buffer from the queue and optionally wait for a buffer to
/**
* GstBufferPoolClass::alloc_buffer:
* @pool: the #GstBufferPool
- * @buffer: (out): a location for a #GstBuffer
- * @params: (transfer none) (allow-none): parameters.
+ * @buffer: (out) (transfer full) (nullable): a location for a #GstBuffer
+ * @params: (transfer none) (nullable): parameters.
*
* Allocate a buffer. the default implementation allocates
* buffers from the configured memory allocator and with the configured
/**
* gst_element_set_clock:
* @element: a #GstElement to set the clock for.
- * @clock: (transfer none) (allow-none): the #GstClock to set for the element.
+ * @clock: (transfer none) (nullable): the #GstClock to set for the element.
*
* Sets the clock for the element. This function increases the
* refcount on the clock. Any previously set clock on the object
* New custom events can also be created by subclassing the event type if
* needed.
*
- * Returns: (transfer full) (nullable): the new custom event.
+ * Returns: (transfer full): the new custom event.
*/
GstEvent *
gst_event_new_custom (GstEventType type, GstStructure * structure)
/**
* gst_event_parse_flush_stop:
* @event: The event to parse
- * @reset_time: (out): if time should be reset
+ * @reset_time: (out) (optional): if time should be reset
*
* Parse the FLUSH_STOP event and retrieve the @reset_time member.
*/
*
* Note: The list of @streams can not be empty.
*
- * Returns: (transfer full): a new select-streams event or %NULL in case of
- * an error (like an empty streams list).
+ * Returns: (transfer full): a new select-streams event.
*
* Since: 1.10
*/
/**
* gst_event_parse_select_streams:
* @event: The event to parse
- * @streams: (out) (element-type utf8) (transfer full): the streams
+ * @streams: (out) (optional) (element-type utf8) (transfer full): the streams
*
* Parse the SELECT_STREAMS event and retrieve the contained streams.
*
/**
* gst_event_parse_stream_group_done:
* @event: a stream-group-done event.
- * @group_id: (out): address of variable to store the group id into
+ * @group_id: (out) (optional): address of variable to store the group id into
*
* Parse a stream-group-done @event and store the result in the given
* @group_id location.
/**
* gst_event_parse_gap:
* @event: a #GstEvent of type #GST_EVENT_GAP
- * @timestamp: (out) (allow-none): location where to store the
+ * @timestamp: (out) (optional): location where to store the
* start time (pts) of the gap, or %NULL
- * @duration: (out) (allow-none): location where to store the duration of
+ * @duration: (out) (optional): location where to store the duration of
* the gap, or %NULL
*
* Extract timestamp and duration from a new GAP event.
/**
* gst_event_parse_gap_flags:
* @event: a #GstEvent of type #GST_EVENT_GAP
- * @flags: (out): a #GstGapFlags or %NULL
+ * @flags: (out) (optional): a #GstGapFlags or %NULL
*
* Retrieve the gap flags that may have been set on a gap event with
* gst_event_set_gap_flags().
* synchronized with the buffer flow and contains the format of the buffers
* that will follow after the event.
*
- * Returns: (transfer full) (nullable): the new CAPS event.
+ * Returns: (transfer full): the new CAPS event.
*/
GstEvent *
gst_event_new_caps (GstCaps * caps)
/**
* gst_event_parse_caps:
* @event: The event to parse
- * @caps: (out) (transfer none): A pointer to the caps
+ * @caps: (out) (optional) (transfer none): A pointer to the caps
*
* Get the caps from @event. The caps remains valid as long as @event remains
* valid.
*
* time + (TIMESTAMP(buf) - start) * ABS (rate * applied_rate)
*
- * Returns: (transfer full) (nullable): the new SEGMENT event.
+ * Returns: (transfer full): the new SEGMENT event.
*/
GstEvent *
gst_event_new_segment (const GstSegment * segment)
/**
* gst_event_parse_segment:
* @event: The event to parse
- * @segment: (out) (transfer none): a pointer to a #GstSegment
+ * @segment: (out) (optional) (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
/**
* gst_event_parse_tag:
* @event: a tag event
- * @taglist: (out) (transfer none): pointer to metadata list
+ * @taglist: (out) (optional) (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
/**
* 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
+ * @format: (out) (optional): A pointer to store the format in
+ * @minsize: (out) (optional): A pointer to store the minsize in
+ * @maxsize: (out) (optional): A pointer to store the maxsize in
+ * @async: (out) (optional): A pointer to store the async-flag in
*
* Get the format, minsize, maxsize and async-flag in the buffersize event.
*/
* The application can use general event probes to intercept the QoS
* event and implement custom application specific QoS handling.
*
- * Returns: (transfer full) (nullable): a new QOS event.
+ * Returns: (transfer full): a new QOS event.
*/
GstEvent *
gst_event_new_qos (GstQOSType type, gdouble proportion,
/**
* 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
+ * @type: (out) (optional): A pointer to store the QoS type in
+ * @proportion: (out) (optional): A pointer to store the proportion in
+ * @diff: (out) (optional): A pointer to store the diff in
+ * @timestamp: (out) (optional): 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.
* #GST_QUERY_POSITION and update the playback segment current position with a
* #GST_SEEK_TYPE_SET to the desired position.
*
- * Returns: (transfer full) (nullable): a new seek event.
+ * Returns: (transfer full): a new seek event.
*/
GstEvent *
gst_event_new_seek (gdouble rate, GstFormat format, GstSeekFlags flags,
/**
* gst_event_parse_seek:
* @event: a seek event
- * @rate: (out): result location for the rate
- * @format: (out): result location for the stream format
- * @flags: (out): result location for the #GstSeekFlags
- * @start_type: (out): result location for the #GstSeekType of the start position
- * @start: (out): result location for the start position expressed in @format
- * @stop_type: (out): result location for the #GstSeekType of the stop position
- * @stop: (out): result location for the stop position expressed in @format
+ * @rate: (out) (optional): result location for the rate
+ * @format: (out) (optional): result location for the stream format
+ * @flags: (out) (optional): result location for the #GstSeekFlags
+ * @start_type: (out) (optional): result location for the #GstSeekType of the start position
+ * @start: (out) (optional): result location for the start position expressed in @format
+ * @stop_type: (out) (optional): result location for the #GstSeekType of the stop position
+ * @stop: (out) (optional): result location for the stop position expressed in @format
*
* Parses a seek @event and stores the results in the given result locations.
*/
/**
* gst_event_parse_seek_trickmode_interval:
- * @interval: (out)
+ * @interval: (out) (optional): interval
*
* Retrieve the trickmode interval that may have been set on a
* seek event with gst_event_set_seek_trickmode_interval().
/**
* gst_event_parse_latency:
* @event: The event to query
- * @latency: (out): A pointer to store the latency in.
+ * @latency: (out) (optional): A pointer to store the latency in.
*
* Get the latency in the latency event.
*/
* The @intermediate flag instructs the pipeline that this step operation is
* part of a larger step operation.
*
- * Returns: (transfer full) (nullable): a new #GstEvent
+ * Returns: (transfer full): a new #GstEvent
*/
GstEvent *
gst_event_new_step (GstFormat format, guint64 amount, gdouble rate,
/**
* 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
+ * @format: (out) (optional): a pointer to store the format in
+ * @amount: (out) (optional): a pointer to store the amount in
+ * @rate: (out) (optional): a pointer to store the rate in
+ * @flush: (out) (optional): a pointer to store the flush boolean in
+ * @intermediate: (out) (optional): a pointer to store the intermediate
* boolean in
*
* Parse the step event.
/**
* gst_event_parse_sink_message:
* @event: The event to query
- * @msg: (out) (transfer full): a pointer to store the #GstMessage in.
+ * @msg: (out) (optional) (transfer full): a pointer to store the #GstMessage in.
*
* Parse the sink-message event. Unref @msg after usage.
*/
/**
* gst_event_parse_stream_start:
* @event: a stream-start event.
- * @stream_id: (out) (transfer none): pointer to store the stream-id
+ * @stream_id: (out) (optional) (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
/**
* gst_event_parse_stream:
* @event: a stream-start event
- * @stream: (out) (transfer full): address of variable to store the stream
+ * @stream: (out) (optional) (transfer full): address of variable to store the stream
*
* Parse a stream-start @event and extract the #GstStream from it.
*
/**
* gst_event_parse_stream_flags:
* @event: a stream-start event
- * @flags: (out): address of variable where to store the stream flags
+ * @flags: (out) (optional): address of variable where to store the stream flags
*
* Since: 1.2
*/
/**
* gst_event_parse_group_id:
* @event: a stream-start event
- * @group_id: (out): address of variable where to store the group id
+ * @group_id: (out) (optional): address of variable where to store the group id
*
* Returns: %TRUE if a group id was set on the event and could be parsed,
* %FALSE otherwise.
/**
* gst_event_parse_stream_collection:
* @event: a stream-collection event
- * @collection: (out): pointer to store the collection
+ * @collection: (out) (optional): pointer to store the collection
*
* Retrieve new #GstStreamCollection from STREAM_COLLECTION event @event.
*
/**
* gst_event_parse_toc:
* @event: a TOC event.
- * @toc: (out) (transfer full): pointer to #GstToc structure.
- * @updated: (out): pointer to store TOC updated flag.
+ * @toc: (out) (optional) (transfer full): pointer to #GstToc structure.
+ * @updated: (out) (optional): pointer to store TOC updated flag.
*
* Parse a TOC @event and store the results in the given @toc and @updated locations.
*/
/**
* gst_event_parse_toc_select:
* @event: a TOC select event.
- * @uid: (out) (transfer full) (allow-none): storage for the selection UID.
+ * @uid: (out) (transfer full) (optional): storage for the selection UID.
*
* Parse a TOC select @event and store the results in the given @uid location.
*/
* event of a particular @origin and @system_id will
* be stuck to the output pad of the sending element.
*
- * Returns: a #GST_EVENT_PROTECTION event, if successful; %NULL
- * if unsuccessful.
+ * Returns: (transfer full): a #GST_EVENT_PROTECTION event.
*
* Since: 1.6
*/
/**
* gst_event_parse_protection:
* @event: a #GST_EVENT_PROTECTION event.
- * @system_id: (out) (allow-none) (transfer none): pointer to store the UUID
+ * @system_id: (out) (optional) (transfer none): pointer to store the UUID
* string uniquely identifying a content protection system.
- * @data: (out) (allow-none) (transfer none): pointer to store a #GstBuffer
+ * @data: (out) (optional) (transfer none): pointer to store a #GstBuffer
* holding protection system specific information.
- * @origin: (out) (allow-none) (transfer none): pointer to store a value that
+ * @origin: (out) (optional) (transfer none): pointer to store a value that
* indicates where the protection information carried by @event was extracted
* from.
*
/**
* gst_event_parse_segment_done:
* @event: A valid #GstEvent of type GST_EVENT_SEGMENT_DONE.
- * @format: (out) (allow-none): Result location for the format, or %NULL
- * @position: (out) (allow-none): Result location for the position, or %NULL
+ * @format: (out) (optional): Result location for the format, or %NULL
+ * @position: (out) (optional): Result location for the position, or %NULL
*
* Extracts the position and format from the segment done message.
*
/**
* gst_event_parse_instant_rate_change:
* @event: a #GstEvent of type #GST_EVENT_INSTANT_RATE_CHANGE
- * @rate_multiplier: (out) (allow-none): location in which to store the rate
+ * @rate_multiplier: (out) (optional): location in which to store the rate
* multiplier of the instant-rate-change event, or %NULL
- * @new_flags: (out) (allow-none): location in which to store the new
+ * @new_flags: (out) (optional): location in which to store the new
* segment flags of the instant-rate-change event, or %NULL
*
* Extract rate and flags from an instant-rate-change event.
/**
* gst_event_parse_instant_rate_sync_time:
* @event: a #GstEvent of type #GST_EVENT_INSTANT_RATE_CHANGE
- * @rate_multiplier: (out) (allow-none): location where to store the rate of
+ * @rate_multiplier: (out) (optional): location where to store the rate of
* the instant-rate-sync-time event, or %NULL
- * @running_time: (out) (allow-none): location in which to store the running time
+ * @running_time: (out) (optional): location in which to store the running time
* of the instant-rate-sync-time event, or %NULL
- * @upstream_running_time: (out) (allow-none): location in which to store the
+ * @upstream_running_time: (out) (optional): location in which to store the
* upstream running time of the instant-rate-sync-time event, or %NULL
*
* Extract the rate multiplier and running times from an instant-rate-sync-time event.
* gst_event_replace: (skip)
* @old_event: (inout) (transfer full) (nullable): pointer to a
* pointer to a #GstEvent to be replaced.
- * @new_event: (allow-none) (transfer none): pointer to a #GstEvent that will
+ * @new_event: (nullable) (transfer none): pointer to a #GstEvent that will
* replace the event pointed to by @old_event.
*
* Modifies a pointer to a #GstEvent to point to a different #GstEvent. The
* gst_event_take: (skip)
* @old_event: (inout) (transfer full) (nullable): pointer to a
* pointer to a #GstEvent to be stolen.
- * @new_event: (allow-none) (transfer full): pointer to a #GstEvent that will
+ * @new_event: (nullable) (transfer full): pointer to a #GstEvent that will
* replace the event pointed to by @old_event.
*
* Modifies a pointer to a #GstEvent to point to a different #GstEvent. This
* Fetches the current logs per thread from the ring buffer logger. See
* gst_debug_add_ring_buffer_logger() for details.
*
- * Returns: (transfer full) (array zero-terminated): NULL-terminated array of
+ * Returns: (transfer full) (array zero-terminated=1): NULL-terminated array of
* strings with the debug output per thread
*
* Since: 1.14
/**
* gst_message_new_custom:
* @type: The #GstMessageType to distinguish messages
- * @src: (transfer none) (allow-none): The object originating the message.
- * @structure: (transfer full) (allow-none): the structure for the
+ * @src: (transfer none) (nullable): The object originating the message.
+ * @structure: (transfer full) (nullable): the structure for the
* message. The message will take ownership of the structure.
*
* Create a new custom-typed message. This can be used for anything not
* handled by other message-specific functions to pass a message to the
* app. The structure field can be %NULL.
*
- * Returns: (transfer full) (nullable): The new message.
+ * Returns: (transfer full): The new message.
*
* MT safe.
*/
/**
* gst_message_new_eos:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
*
* Create a new eos message. This message is generated and posted in
* the sink elements of a GstBin. The bin will only forward the EOS
/**
* gst_message_new_error_with_details:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @error: (transfer none): The GError for this message.
* @debug: A debugging string.
- * @details: (transfer full) (allow-none): A GstStructure with details
+ * @details: (transfer full) (nullable): A GstStructure with details
*
* Create a new error message. The message will copy @error and
* @debug. This message is posted by element when a fatal event
* occurred. The pipeline will probably (partially) stop. The application
* receiving this message should stop the pipeline.
*
- * Returns: (transfer full) (nullable): the new error message.
+ * Returns: (transfer full): the new error message.
*
* Since: 1.10
*/
/**
* gst_message_new_error:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @error: (transfer none): The GError for this message.
* @debug: A debugging string.
*
/**
* gst_message_parse_error_details:
* @message: The message object
- * @structure: (transfer none) (out): A pointer to the returned details
+ * @structure: (optional) (nullable) (transfer none) (out): A pointer to the returned details
*
* Returns the optional details structure, may be NULL if none.
* The returned structure must not be freed.
/**
* gst_message_new_warning_with_details:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @error: (transfer none): The GError for this message.
* @debug: A debugging string.
- * @details: (transfer full) (allow-none): A GstStructure with details
+ * @details: (transfer full) (nullable): A GstStructure with details
*
* Create a new warning message. The message will make copies of @error and
* @debug.
*
- * Returns: (transfer full) (nullable): the new warning message.
+ * Returns: (transfer full): the new warning message.
*
* Since: 1.10
*/
/**
* gst_message_new_warning:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @error: (transfer none): The GError for this message.
* @debug: A debugging string.
*
/**
* gst_message_parse_warning_details:
* @message: The message object
- * @structure: (transfer none) (out): A pointer to the returned details structure
+ * @structure: (optional) (nullable) (transfer none) (out): A pointer to the returned details
*
* Returns the optional details structure, may be NULL if none
* The returned structure must not be freed.
/**
* gst_message_new_info_with_details:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @error: (transfer none): The GError for this message.
* @debug: A debugging string.
- * @details: (transfer full) (allow-none): A GstStructure with details
+ * @details: (transfer full) (nullable): A GstStructure with details
*
* Create a new info message. The message will make copies of @error and
* @debug.
*
- * Returns: (transfer full) (nullable): the new warning message.
+ * Returns: (transfer full): the new warning message.
*
* Since: 1.10
*/
/**
* gst_message_new_info:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @error: (transfer none): The GError for this message.
* @debug: A debugging string.
*
/**
* gst_message_parse_info_details:
* @message: The message object
- * @structure: (transfer none) (out): A pointer to the returned details structure
+ * @structure: (optional) (nullable) (transfer none) (out): A pointer to the returned details
*
* Returns the optional details structure, may be NULL if none
* The returned structure must not be freed.
/**
* gst_message_new_tag:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @tag_list: (transfer full): the tag list for the message.
*
* Create a new tag message. The message will take ownership of the tag list.
/**
* gst_message_new_buffering:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @percent: The buffering percent
*
* Create a new buffering message. This message can be posted by an element that
*
* MT safe.
*
- * Returns: (transfer full) (nullable): The new buffering message.
+ * Returns: (transfer full): The new buffering message.
*/
GstMessage *
gst_message_new_buffering (GstObject * src, gint percent)
/**
* gst_message_new_state_changed:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @oldstate: the previous state
* @newstate: the new (current) state
* @pending: the pending (target) state
/**
* gst_message_new_state_dirty:
- * @src: (transfer none) (allow-none): The object originating the message
+ * @src: (transfer none) (nullable): The object originating the message
*
* Create a state dirty message. This message is posted whenever an element
* changed its state asynchronously and is used internally to update the
/**
* gst_message_new_clock_provide:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @clock: (transfer none): the clock it provides
* @ready: %TRUE if the sender can provide a clock
*
/**
* gst_message_new_clock_lost:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @clock: (transfer none): the clock that was lost
*
* Create a clock lost message. This message is posted whenever the
/**
* gst_message_new_new_clock:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @clock: (transfer none): the new selected clock
*
* Create a new clock message. This message is posted whenever the
/**
* gst_message_new_structure_change:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @type: The change type.
* @owner: (transfer none): The owner element of @src.
* @busy: Whether the structure change is busy.
/**
* gst_message_new_segment_start:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @format: The format of the position being played
* @position: The position of the segment being played
*
/**
* gst_message_new_segment_done:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @format: The format of the position being done
* @position: The position of the segment being done
*
/**
* gst_message_new_application:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @structure: (transfer full): the structure for the message. The message
* will take ownership of the structure.
*
* Create a new application-typed message. GStreamer will never create these
* messages; they are a gift from us to you. Enjoy.
*
- * Returns: (transfer full) (nullable): The new application message.
+ * Returns: (transfer full): The new application message.
*
* MT safe.
*/
/**
* gst_message_new_element:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @structure: (transfer full): The structure for the
* message. The message will take ownership of the structure.
*
* "the firewire cable was unplugged". The format of the message should be
* documented in the element's documentation. The structure field can be %NULL.
*
- * Returns: (transfer full) (nullable): The new element message.
+ * Returns: (transfer full): The new element message.
*
* MT safe.
*/
/**
* gst_message_new_duration_changed:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
*
* Create a new duration changed message. This message is posted by elements
* that know the duration of a stream when the duration changes. This message
/**
* gst_message_new_async_start:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
*
* This message is posted by elements when they start an ASYNC state change.
*
/**
* gst_message_new_async_done:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @running_time: the desired running_time
*
* The message is posted when elements completed an ASYNC state change.
/**
* gst_message_new_latency:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
*
* This message can be posted by elements when their latency requirements have
* changed.
/**
* gst_message_new_request_state:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @state: The new requested state
*
* This message can be posted by elements when they want to have their state
/**
* gst_message_parse_buffering:
* @message: A valid #GstMessage of type GST_MESSAGE_BUFFERING.
- * @percent: (out) (allow-none): Return location for the percent.
+ * @percent: (out) (optional): Return location for the percent.
*
* Extracts the buffering percent from the GstMessage. see also
* gst_message_new_buffering().
/**
* gst_message_parse_buffering_stats:
* @message: A valid #GstMessage of type GST_MESSAGE_BUFFERING.
- * @mode: (out) (allow-none): a buffering mode, or %NULL
- * @avg_in: (out) (allow-none): the average input rate, or %NULL
- * @avg_out: (out) (allow-none): the average output rate, or %NULL
- * @buffering_left: (out) (allow-none): amount of buffering time left in
+ * @mode: (out) (optional): a buffering mode, or %NULL
+ * @avg_in: (out) (optional): the average input rate, or %NULL
+ * @avg_out: (out) (optional): the average output rate, or %NULL
+ * @buffering_left: (out) (optional): amount of buffering time left in
* milliseconds, or %NULL
*
* Extracts the buffering stats values from @message.
/**
* gst_message_parse_state_changed:
* @message: a valid #GstMessage of type GST_MESSAGE_STATE_CHANGED
- * @oldstate: (out) (allow-none): the previous state, or %NULL
- * @newstate: (out) (allow-none): the new (current) state, or %NULL
- * @pending: (out) (allow-none): the pending (target) state, or %NULL
+ * @oldstate: (out) (optional): the previous state, or %NULL
+ * @newstate: (out) (optional): the new (current) state, or %NULL
+ * @pending: (out) (optional): the pending (target) state, or %NULL
*
* Extracts the old and new states from the GstMessage.
*
/**
* gst_message_parse_clock_provide:
* @message: A valid #GstMessage of type GST_MESSAGE_CLOCK_PROVIDE.
- * @clock: (out) (allow-none) (transfer none): a pointer to hold a clock
+ * @clock: (out) (optional) (transfer none): a pointer to hold a clock
* object, or %NULL
- * @ready: (out) (allow-none): a pointer to hold the ready flag, or %NULL
+ * @ready: (out) (optional): a pointer to hold the ready flag, or %NULL
*
* Extracts the clock and ready flag from the GstMessage.
* The clock object returned remains valid until the message is freed.
/**
* gst_message_parse_clock_lost:
* @message: A valid #GstMessage of type GST_MESSAGE_CLOCK_LOST.
- * @clock: (out) (allow-none) (transfer none): a pointer to hold the lost clock
+ * @clock: (out) (optional) (transfer none): a pointer to hold the lost clock
*
* Extracts the lost clock from the GstMessage.
* The clock object returned remains valid until the message is freed.
/**
* gst_message_parse_new_clock:
* @message: A valid #GstMessage of type GST_MESSAGE_NEW_CLOCK.
- * @clock: (out) (allow-none) (transfer none): a pointer to hold the selected
+ * @clock: (out) (optional) (transfer none): a pointer to hold the selected
* new clock
*
* Extracts the new clock from the GstMessage.
* gst_message_parse_structure_change:
* @message: A valid #GstMessage of type GST_MESSAGE_STRUCTURE_CHANGE.
* @type: (out): A pointer to hold the change type
- * @owner: (out) (allow-none) (transfer none): The owner element of the
+ * @owner: (out) (optional) (transfer none): The owner element of the
* message source
- * @busy: (out) (allow-none): a pointer to hold whether the change is in
+ * @busy: (out) (optional): a pointer to hold whether the change is in
* progress or has been completed
*
* Extracts the change type and completion status from the GstMessage.
/**
* gst_message_parse_error:
* @message: A valid #GstMessage of type GST_MESSAGE_ERROR.
- * @gerror: (out) (allow-none) (transfer full): location for the GError
- * @debug: (out) (allow-none) (transfer full): location for the debug message,
+ * @gerror: (out) (optional) (transfer full): location for the GError
+ * @debug: (out) (optional) (nullable) (transfer full): location for the debug message,
* or %NULL
*
* Extracts the GError and debug string from the GstMessage. The values returned
/**
* gst_message_parse_warning:
* @message: A valid #GstMessage of type GST_MESSAGE_WARNING.
- * @gerror: (out) (allow-none) (transfer full): location for the GError
- * @debug: (out) (allow-none) (transfer full): location for the debug message,
+ * @gerror: (out) (optional) (transfer full): location for the GError
+ * @debug: (out) (optional) (nullable) (transfer full): location for the debug message,
* or %NULL
*
* Extracts the GError and debug string from the GstMessage. The values returned
/**
* gst_message_parse_info:
* @message: A valid #GstMessage of type GST_MESSAGE_INFO.
- * @gerror: (out) (allow-none) (transfer full): location for the GError
- * @debug: (out) (allow-none) (transfer full): location for the debug message,
+ * @gerror: (out) (optional) (transfer full): location for the GError
+ * @debug: (out) (optional) (nullable) (transfer full): location for the debug message,
* or %NULL
*
* Extracts the GError and debug string from the GstMessage. The values returned
/**
* gst_message_parse_segment_start:
* @message: A valid #GstMessage of type GST_MESSAGE_SEGMENT_START.
- * @format: (out) (allow-none): Result location for the format, or %NULL
- * @position: (out) (allow-none): Result location for the position, or %NULL
+ * @format: (out) (optional): Result location for the format, or %NULL
+ * @position: (out) (optional): Result location for the position, or %NULL
*
* Extracts the position and format from the segment start message.
*
/**
* gst_message_parse_segment_done:
* @message: A valid #GstMessage of type GST_MESSAGE_SEGMENT_DONE.
- * @format: (out) (allow-none): Result location for the format, or %NULL
- * @position: (out) (allow-none): Result location for the position, or %NULL
+ * @format: (out) (optional): Result location for the format, or %NULL
+ * @position: (out) (optional): Result location for the position, or %NULL
*
* Extracts the position and format from the segment done message.
*
/**
* gst_message_parse_async_done:
* @message: A valid #GstMessage of type GST_MESSAGE_ASYNC_DONE.
- * @running_time: (out) (allow-none): Result location for the running_time or %NULL
+ * @running_time: (out) (optional): Result location for the running_time or %NULL
*
* Extract the running_time from the async_done message.
*
/**
* gst_message_parse_request_state:
* @message: A valid #GstMessage of type GST_MESSAGE_REQUEST_STATE.
- * @state: (out) (allow-none): Result location for the requested state or %NULL
+ * @state: (out) (optional): Result location for the requested state or %NULL
*
* Extract the requested state from the request_state message.
*
/**
* gst_message_new_stream_status:
- * @src: The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @type: The stream status type.
* @owner: (transfer none): the owner element of @src.
*
/**
* gst_message_new_step_done:
- * @src: The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @format: the format of @amount
* @amount: the amount of stepped data
* @rate: the rate of the stepped amount
/**
* gst_message_parse_step_done:
* @message: A valid #GstMessage of type GST_MESSAGE_STEP_DONE.
- * @format: (out) (allow-none): result location for the format
- * @amount: (out) (allow-none): result location for the amount
- * @rate: (out) (allow-none): result location for the rate
- * @flush: (out) (allow-none): result location for the flush flag
- * @intermediate: (out) (allow-none): result location for the intermediate flag
- * @duration: (out) (allow-none): result location for the duration
- * @eos: (out) (allow-none): result location for the EOS flag
+ * @format: (out) (optional): result location for the format
+ * @amount: (out) (optional): result location for the amount
+ * @rate: (out) (optional): result location for the rate
+ * @flush: (out) (optional): result location for the flush flag
+ * @intermediate: (out) (optional): result location for the intermediate flag
+ * @duration: (out) (optional): result location for the duration
+ * @eos: (out) (optional): result location for the EOS flag
*
* Extract the values the step_done message.
*
/**
* gst_message_new_step_start:
- * @src: The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @active: if the step is active or queued
* @format: the format of @amount
* @amount: the amount of stepped data
/**
* gst_message_parse_step_start:
* @message: A valid #GstMessage of type GST_MESSAGE_STEP_DONE.
- * @active: (out) (allow-none): result location for the active flag
- * @format: (out) (allow-none): result location for the format
- * @amount: (out) (allow-none): result location for the amount
- * @rate: (out) (allow-none): result location for the rate
- * @flush: (out) (allow-none): result location for the flush flag
- * @intermediate: (out) (allow-none): result location for the intermediate flag
+ * @active: (out) (optional): result location for the active flag
+ * @format: (out) (optional): result location for the format
+ * @amount: (out) (optional): result location for the amount
+ * @rate: (out) (optional): result location for the rate
+ * @flush: (out) (optional): result location for the flush flag
+ * @intermediate: (out) (optional): result location for the intermediate flag
*
* Extract the values from step_start message.
*
/**
* gst_message_new_qos:
- * @src: The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @live: if the message was generated by a live element
* @running_time: the running time of the buffer that generated the message
* @stream_time: the stream time of the buffer that generated the message
/**
* gst_message_parse_qos:
* @message: A valid #GstMessage of type GST_MESSAGE_QOS.
- * @live: (out) (allow-none): if the message was generated by a live element
- * @running_time: (out) (allow-none): the running time of the buffer that
+ * @live: (out) (optional): if the message was generated by a live element
+ * @running_time: (out) (optional): the running time of the buffer that
* generated the message
- * @stream_time: (out) (allow-none): the stream time of the buffer that
+ * @stream_time: (out) (optional): the stream time of the buffer that
* generated the message
- * @timestamp: (out) (allow-none): the timestamps of the buffer that
+ * @timestamp: (out) (optional): the timestamps of the buffer that
* generated the message
- * @duration: (out) (allow-none): the duration of the buffer that
+ * @duration: (out) (optional): the duration of the buffer that
* generated the message
*
* Extract the timestamps and live status from the QoS message.
/**
* gst_message_parse_qos_values:
* @message: A valid #GstMessage of type GST_MESSAGE_QOS.
- * @jitter: (out) (allow-none): The difference of the running-time against
+ * @jitter: (out) (optional): The difference of the running-time against
* the deadline.
- * @proportion: (out) (allow-none): Long term prediction of the ideal rate
+ * @proportion: (out) (optional): Long term prediction of the ideal rate
* relative to normal rate to get optimal quality.
- * @quality: (out) (allow-none): An element dependent integer value that
+ * @quality: (out) (optional): An element dependent integer value that
* specifies the current quality level of the element. The default
* maximum quality is 1000000.
*
/**
* gst_message_parse_qos_stats:
* @message: A valid #GstMessage of type GST_MESSAGE_QOS.
- * @format: (out) (allow-none): Units of the 'processed' and 'dropped' fields.
+ * @format: (out) (optional): Units of the 'processed' and 'dropped' fields.
* Video sinks and video filters will use GST_FORMAT_BUFFERS (frames).
* Audio sinks and audio filters will likely use GST_FORMAT_DEFAULT
* (samples).
- * @processed: (out) (allow-none): Total number of units correctly processed
+ * @processed: (out) (optional): Total number of units correctly processed
* since the last state change to READY or a flushing operation.
- * @dropped: (out) (allow-none): Total number of units dropped since the last
+ * @dropped: (out) (optional): Total number of units dropped since the last
* state change to READY or a flushing operation.
*
* Extract the QoS stats representing the history of the current continuous
/**
* gst_message_new_progress:
- * @src: The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @type: a #GstProgressType
* @code: a progress code
* @text: free, user visible text describing the progress
* @code contains a well defined string describing the action.
* @text should contain a user visible string detailing the current action.
*
- * Returns: (transfer full) (nullable): The new qos message.
+ * Returns: (transfer full): The new qos message.
*/
GstMessage *
gst_message_new_progress (GstObject * src, GstProgressType type,
/**
* gst_message_parse_progress:
* @message: A valid #GstMessage of type GST_MESSAGE_PROGRESS.
- * @type: (out) (allow-none): location for the type
- * @code: (out) (allow-none) (transfer full): location for the code
- * @text: (out) (allow-none) (transfer full): location for the text
+ * @type: (out) (optional): location for the type
+ * @code: (out) (optional) (transfer full): location for the code
+ * @text: (out) (optional) (transfer full): location for the text
*
* Parses the progress @type, @code and @text.
*/
/**
* gst_message_new_toc:
- * @src: the object originating the message.
+ * @src: (transfer none) (nullable): the object originating the message.
* @toc: (transfer none): #GstToc structure for the message.
* @updated: whether TOC was updated or not.
*
/**
* gst_message_new_reset_time:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @running_time: the requested running-time
*
* This message is posted when the pipeline running-time should be reset to
/**
* gst_message_parse_reset_time:
* @message: A valid #GstMessage of type GST_MESSAGE_RESET_TIME.
- * @running_time: (out) (allow-none): Result location for the running_time or
+ * @running_time: (out) (optional): Result location for the running_time or
* %NULL
*
* Extract the running-time from the RESET_TIME message.
/**
* gst_message_new_stream_start:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
*
* Create a new stream_start message. This message is generated and posted in
* the sink elements of a GstBin. The bin will only forward the STREAM_START
/**
* gst_message_parse_group_id:
* @message: A valid #GstMessage of type GST_MESSAGE_STREAM_START.
- * @group_id: (out) (allow-none): Result location for the group id or
+ * @group_id: (out) (optional): Result location for the group id or
* %NULL
*
* Extract the group from the STREAM_START message.
/**
* gst_message_new_need_context:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @context_type: The context type that is needed
*
* This message is posted when an element needs a specific #GstContext.
/**
* gst_message_parse_context_type:
* @message: a GST_MESSAGE_NEED_CONTEXT type message
- * @context_type: (out) (transfer none) (allow-none): the context type, or %NULL
+ * @context_type: (out) (transfer none) (optional): the context type, or %NULL
*
* Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message.
*
/**
* gst_message_new_have_context:
- * @src: (transfer none) (allow-none): The object originating the message.
+ * @src: (transfer none) (nullable): The object originating the message.
* @context: (transfer full): the context
*
* This message is posted when an element has a new local #GstContext.
/**
* gst_message_parse_have_context:
* @message: A valid #GstMessage of type GST_MESSAGE_HAVE_CONTEXT.
- * @context: (out) (transfer full) (allow-none): Result location for the
+ * @context: (out) (transfer full) (optional): Result location for the
* context or %NULL
*
* Extract the context from the HAVE_CONTEXT message.
/**
* gst_message_new_device_added:
- * @src: The #GstObject that created the message
+ * @src: (transfer none) (nullable): The #GstObject that created the message
* @device: (transfer none): The new #GstDevice
*
* Creates a new device-added message. The device-added message is produced by
* #GstDeviceProvider or a #GstDeviceMonitor. They announce the appearance
* of monitored devices.
*
- * Returns: a newly allocated #GstMessage
+ * Returns: (transfer full): a newly allocated #GstMessage
*
* Since: 1.4
*/
/**
* gst_message_parse_device_added:
* @message: a #GstMessage of type %GST_MESSAGE_DEVICE_ADDED
- * @device: (out) (allow-none) (transfer full): A location where to store a
+ * @device: (out) (optional) (transfer full): A location where to store a
* pointer to the new #GstDevice, or %NULL
*
* Parses a device-added message. The device-added message is produced by
/**
* gst_message_new_device_removed:
- * @src: The #GstObject that created the message
+ * @src: (transfer none) (nullable): The #GstObject that created the message
* @device: (transfer none): The removed #GstDevice
*
* Creates a new device-removed message. The device-removed message is produced
* by #GstDeviceProvider or a #GstDeviceMonitor. They announce the
* disappearance of monitored devices.
*
- * Returns: a newly allocated #GstMessage
+ * Returns: (transfer full): a newly allocated #GstMessage
*
* Since: 1.4
*/
/**
* gst_message_parse_device_removed:
* @message: a #GstMessage of type %GST_MESSAGE_DEVICE_REMOVED
- * @device: (out) (allow-none) (transfer full): A location where to store a
+ * @device: (out) (optional) (transfer full): A location where to store a
* pointer to the removed #GstDevice, or %NULL
*
* Parses a device-removed message. The device-removed message is produced by
/**
* gst_message_new_device_changed:
- * @src: The #GstObject that created the message
- * @device: (transfer none): The newly created device representing @replaced_device
+ * @src: (transfer none) (nullable): The #GstObject that created the message
+ * @device: (transfer none): The newly created device representing @changed_device
* with its new configuration.
+ * @changed_device: (transfer none): The old version of the device.
*
* Creates a new device-changed message. The device-changed message is produced
* by #GstDeviceProvider or a #GstDeviceMonitor. They announce that a device
* properties has changed and @device represent the new modified version of @changed_device.
*
- * Returns: a newly allocated #GstMessage
+ * Returns: (transfer full): a newly allocated #GstMessage
*
* Since: 1.16
*/
/**
* gst_message_parse_device_changed:
* @message: a #GstMessage of type %GST_MESSAGE_DEVICE_CHANGED
- * @device: (out) (allow-none) (transfer full): A location where to store a
+ * @device: (out) (optional) (transfer full): A location where to store a
* pointer to the updated version of the #GstDevice, or %NULL
- * @changed_device: (out) (allow-none) (transfer full): A location where to store a
+ * @changed_device: (out) (optional) (transfer full): A location where to store a
* pointer to the old version of the #GstDevice, or %NULL
*
* Parses a device-changed message. The device-changed message is produced by
/**
* gst_message_new_property_notify:
- * @src: The #GstObject whose property changed (may or may not be a #GstElement)
+ * @src: (transfer none): The #GstObject whose property changed (may or may not be a #GstElement)
* @property_name: name of the property that changed
- * @val: (allow-none) (transfer full): new property value, or %NULL
+ * @val: (nullable) (transfer full): new property value, or %NULL
*
- * Returns: a newly allocated #GstMessage
+ * Returns: (transfer full): a newly allocated #GstMessage
*
* Since: 1.10
*/
GstStructure *structure;
GValue name_val = G_VALUE_INIT;
+ g_return_val_if_fail (GST_IS_OBJECT (src), NULL);
g_return_val_if_fail (property_name != NULL, NULL);
structure = gst_structure_new_id_empty (GST_QUARK (MESSAGE_PROPERTY_NOTIFY));
/**
* gst_message_parse_property_notify:
* @message: a #GstMessage of type %GST_MESSAGE_PROPERTY_NOTIFY
- * @object: (out) (allow-none) (transfer none): location where to store a
+ * @object: (out) (optional) (transfer none): location where to store a
* pointer to the object whose property got changed, or %NULL
- * @property_name: (out) (transfer none) (allow-none): return location for
+ * @property_name: (out) (transfer none) (optional): return location for
* the name of the property that got changed, or %NULL
- * @property_value: (out) (transfer none) (allow-none): return location for
+ * @property_value: (out) (transfer none) (optional) (nullable): return location for
* the new value of the property that got changed, or %NULL. This will
* only be set if the property notify watch was told to include the value
* when it was set up
/**
* gst_message_new_stream_collection:
- * @src: The #GstObject that created the message
+ * @src: (transfer none) (nullable): The #GstObject that created the message
* @collection: (transfer none): The #GstStreamCollection
*
* Creates a new stream-collection message. The message is used to announce new
* #GstStreamCollection
*
- * Returns: a newly allocated #GstMessage
+ * Returns: (transfer full): a newly allocated #GstMessage
*
* Since: 1.10
*/
/**
* gst_message_parse_stream_collection:
* @message: a #GstMessage of type %GST_MESSAGE_STREAM_COLLECTION
- * @collection: (out) (allow-none) (transfer full): A location where to store a
+ * @collection: (out) (optional) (transfer full): A location where to store a
* pointer to the #GstStreamCollection, or %NULL
*
* Parses a stream-collection message.
/**
* gst_message_new_streams_selected:
- * @src: The #GstObject that created the message
+ * @src: (transfer none) (nullable): The #GstObject that created the message
* @collection: (transfer none): The #GstStreamCollection
*
* Creates a new steams-selected message. The message is used to announce
* Users of gst_message_new_streams_selected() can add the selected streams with
* gst_message_streams_selected_add().
*
- * Returns: a newly allocated #GstMessage
+ * Returns: (transfer full): a newly allocated #GstMessage
*
* Since: 1.10
*/
/**
* gst_message_parse_streams_selected:
* @message: a #GstMessage of type %GST_MESSAGE_STREAMS_SELECTED
- * @collection: (out) (allow-none) (transfer full): A location where to store a
+ * @collection: (out) (optional) (transfer full): A location where to store a
* pointer to the #GstStreamCollection, or %NULL
*
* Parses a streams-selected message.
/**
* gst_message_new_redirect:
- * @src: The #GstObject whose property changed (may or may not be a #GstElement)
+ * @src: (transfer none) (nullable): The #GstObject whose property changed (may or may not be a #GstElement)
* @location: (transfer none): location string for the new entry
- * @tag_list: (transfer full) (allow-none): tag list for the new entry
- * @entry_struct: (transfer full) (allow-none): structure for the new entry
+ * @tag_list: (transfer full) (nullable): tag list for the new entry
+ * @entry_struct: (transfer full) (nullable): structure for the new entry
*
* Creates a new redirect message and adds a new entry to it. Redirect messages
* are posted when an element detects that the actual data has to be retrieved
* The specified location string is copied. However, ownership over the tag
* list and structure are transferred to the message.
*
- * Returns: a newly allocated #GstMessage
+ * Returns: (transfer full): a newly allocated #GstMessage
*
* Since: 1.10
*/
* gst_message_add_redirect_entry:
* @message: a #GstMessage of type %GST_MESSAGE_REDIRECT
* @location: (transfer none): location string for the new entry
- * @tag_list: (transfer full) (allow-none): tag list for the new entry
- * @entry_struct: (transfer full) (allow-none): structure for the new entry
+ * @tag_list: (transfer full) (nullable): tag list for the new entry
+ * @entry_struct: (transfer full) (nullable): structure for the new entry
*
* Creates and appends a new entry.
*
* gst_message_parse_redirect_entry:
* @message: a #GstMessage of type %GST_MESSAGE_REDIRECT
* @entry_index: index of the entry to parse
- * @location: (out) (transfer none) (allow-none): return location for
+ * @location: (out) (transfer none) (optional): return location for
* the pointer to the entry's location string, or %NULL
- * @tag_list: (out) (transfer none) (allow-none): return location for
+ * @tag_list: (out) (transfer none) (optional) (nullable): return location for
* the pointer to the entry's tag list, or %NULL
- * @entry_struct: (out) (transfer none) (allow-none): return location
+ * @entry_struct: (out) (transfer none) (optional) (nullable): return location
* for the pointer to the entry's structure, or %NULL
*
* Parses the location and/or structure from the entry with the given index.
/**
* gst_message_new_instant_rate_request:
- * @src: The #GstObject that posted the message
+ * @src: (transfer none) (nullable): The #GstObject that posted the message
* @rate_multiplier: the rate multiplier factor that should be applied
*
* Creates a new instant-rate-request message. Elements handling the
* @GST_EVENT_INSTANT_RATE_SYNC_TIME event to notify the elements
* in the pipeline.
*
- * Returns: a newly allocated #GstMessage
+ * Returns: (transfer full): a newly allocated #GstMessage
*
* Since: 1.18
*/
/**
* gst_message_parse_instant_rate_request:
* @message: a #GstMessage of type %GST_MESSAGE_INSTANT_RATE_REQUEST
- * @rate_multiplier: (out) (allow-none): return location for the rate, or %NULL
+ * @rate_multiplier: (out) (optional): return location for the rate, or %NULL
*
* Parses the rate_multiplier from the instant-rate-request message.
*
* gst_message_replace: (skip)
* @old_message: (inout) (transfer full) (nullable): pointer to a
* pointer to a #GstMessage to be replaced.
- * @new_message: (allow-none) (transfer none): pointer to a #GstMessage that will
+ * @new_message: (nullable) (transfer none): pointer to a #GstMessage that will
* replace the message pointed to by @old_message.
*
* Modifies a pointer to a #GstMessage to point to a different #GstMessage. The
* gst_message_take:
* @old_message: (inout) (transfer full): pointer to a pointer to a #GstMessage
* to be replaced.
- * @new_message: (transfer full) (allow-none): pointer to a #GstMessage that
+ * @new_message: (transfer full) (nullable): pointer to a #GstMessage that
* will replace the message pointed to by @old_message.
*
* Modifies a pointer to a #GstMessage to point to a different #GstMessage. This
* gst_object_replace:
* @oldobj: (inout) (transfer full) (nullable): pointer to a place of
* a #GstObject to replace
- * @newobj: (transfer none) (allow-none): a new #GstObject
+ * @newobj: (transfer none) (nullable): a new #GstObject
*
* Atomically modifies a pointer to point to a new object.
* The reference count of @oldobj is decreased and the reference count of
/**
* gst_object_set_name:
* @object: a #GstObject
- * @name: (allow-none): new name of object
+ * @name: (nullable): new name of object
*
* Sets the name of @object, or gives @object a guaranteed unique
* name (if @name is %NULL).
*
* Gets the value for the given controlled property at the requested time.
*
- * Returns: (nullable): the GValue of the property at the given time,
+ * Returns: (transfer full) (nullable): the GValue of the property at the given time,
* or %NULL if the property isn't controlled.
*/
GValue *
* @timestamp: the time that should be processed
* @interval: the time spacing between subsequent values
* @n_values: the number of values
- * @values: array to put control-values in
+ * @values: (array length=n_values): array to put control-values in
*
* Gets a number of values for the given controlled property starting at the
* requested time. The array @values need to hold enough space for @n_values of
/**
* gst_parse_launchv_full:
* @argv: (in) (array zero-terminated=1): null-terminated array of arguments
- * @context: (allow-none): a parse context allocated with
+ * @context: (nullable): a parse context allocated with
* gst_parse_context_new(), or %NULL
* @flags: parsing options, or #GST_PARSE_FLAG_NONE
* @error: pointer to a #GError (which must be initialised to %NULL)
/**
* gst_parse_launch_full:
* @pipeline_description: the command line describing the pipeline
- * @context: (allow-none): a parse context allocated with
+ * @context: (nullable): a parse context allocated with
* gst_parse_context_new(), or %NULL
* @flags: parsing options, or #GST_PARSE_FLAG_NONE
* @error: the error message in case of an erroneous pipeline.
/**
* gst_pipeline_new:
- * @name: (allow-none): name of new pipeline
+ * @name: (nullable): name of new pipeline
*
* Create a new pipeline with the given name.
*
/**
* gst_pipeline_set_clock: (skip)
* @pipeline: a #GstPipeline
- * @clock: (transfer none): the clock to set
+ * @clock: (transfer none) (nullable): the clock to set
*
* Set the clock for @pipeline. The clock will be distributed
* to all the elements managed by the pipeline.
/**
* gst_query_parse_position:
* @query: a #GstQuery
- * @format: (out) (allow-none): the storage for the #GstFormat of the
+ * @format: (out) (optional): the storage for the #GstFormat of the
* position values (may be %NULL)
- * @cur: (out) (allow-none): the storage for the current position (may be %NULL)
+ * @cur: (out) (optional): 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.
/**
* gst_query_parse_duration:
* @query: a #GstQuery
- * @format: (out) (allow-none): the storage for the #GstFormat of the duration
+ * @format: (out) (optional): the storage for the #GstFormat of the duration
* value, or %NULL.
- * @duration: (out) (allow-none): the storage for the total duration, or %NULL.
+ * @duration: (out) (optional): 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.
/**
* gst_query_parse_latency:
* @query: a #GstQuery
- * @live: (out) (allow-none): storage for live or %NULL
- * @min_latency: (out) (allow-none): the storage for the min latency or %NULL
- * @max_latency: (out) (allow-none): the storage for the max latency or %NULL
+ * @live: (out) (optional): storage for live or %NULL
+ * @min_latency: (out) (optional): the storage for the min latency or %NULL
+ * @max_latency: (out) (optional): the storage for the max latency or %NULL
*
* Parse a latency query answer.
*/
/**
* gst_query_parse_convert:
* @query: a #GstQuery
- * @src_format: (out) (allow-none): the storage for the #GstFormat of the
+ * @src_format: (out) (optional): the storage for the #GstFormat of the
* source value, or %NULL
- * @src_value: (out) (allow-none): the storage for the source value, or %NULL
- * @dest_format: (out) (allow-none): the storage for the #GstFormat of the
+ * @src_value: (out) (optional): the storage for the source value, or %NULL
+ * @dest_format: (out) (optional): the storage for the #GstFormat of the
* destination value, or %NULL
- * @dest_value: (out) (allow-none): the storage for the destination value,
+ * @dest_value: (out) (optional): the storage for the destination value,
* or %NULL
*
* Parse a convert query answer. Any of @src_format, @src_value, @dest_format,
/**
* gst_query_parse_segment:
* @query: a #GstQuery
- * @rate: (out) (allow-none): the storage for the rate of the segment, or %NULL
- * @format: (out) (allow-none): the storage for the #GstFormat of the values,
+ * @rate: (out) (optional): the storage for the rate of the segment, or %NULL
+ * @format: (out) (optional): the storage for the #GstFormat of the values,
* or %NULL
- * @start_value: (out) (allow-none): the storage for the start value, or %NULL
- * @stop_value: (out) (allow-none): the storage for the stop value, or %NULL
+ * @start_value: (out) (optional): the storage for the start value, or %NULL
+ * @stop_value: (out) (optional): 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.
/**
* gst_query_new_custom:
* @type: the query type
- * @structure: (allow-none) (transfer full): a structure for the query
+ * @structure: (nullable) (transfer full): a structure for the query
*
* Constructs a new custom query object. Use gst_query_unref()
* when done with it.
*
* Free-function: gst_query_unref()
*
- * Returns: (transfer full) (nullable): a new #GstQuery
+ * Returns: (transfer full): a new #GstQuery
*/
GstQuery *
gst_query_new_custom (GstQueryType type, GstStructure * structure)
/**
* gst_query_parse_seeking:
* @query: a GST_QUERY_SEEKING type query #GstQuery
- * @format: (out) (allow-none): the format to set for the @segment_start
+ * @format: (out) (optional): the format to set for the @segment_start
* and @segment_end values, or %NULL
- * @seekable: (out) (allow-none): the seekable flag to set, or %NULL
- * @segment_start: (out) (allow-none): the segment_start to set, or %NULL
- * @segment_end: (out) (allow-none): the segment_end to set, or %NULL
+ * @seekable: (out) (optional): the seekable flag to set, or %NULL
+ * @segment_start: (out) (optional): the segment_start to set, or %NULL
+ * @segment_end: (out) (optional): the segment_end to set, or %NULL
*
* Parse a seeking query, writing the format into @format, and
* other results into the passed parameters, if the respective parameters
/**
* gst_query_parse_n_formats:
* @query: a #GstQuery
- * @n_formats: (out) (allow-none): the number of formats in this query.
+ * @n_formats: (out) (optional): the number of formats in this query.
*
* Parse the number of formats in the formats @query.
*/
* gst_query_parse_nth_format:
* @query: a #GstQuery
* @nth: the nth format to retrieve.
- * @format: (out) (allow-none): a pointer to store the nth format
+ * @format: (out) (optional): a pointer to store the nth format
*
* Parse the format query and retrieve the @nth format from it into
* @format. If the list contains less elements than @nth, @format will be
/**
* gst_query_parse_buffering_percent:
* @query: A valid #GstQuery of type GST_QUERY_BUFFERING.
- * @busy: (out) (allow-none): if buffering is busy, or %NULL
- * @percent: (out) (allow-none): a buffering percent, or %NULL
+ * @busy: (out) (optional): if buffering is busy, or %NULL
+ * @percent: (out) (optional): a buffering percent, or %NULL
*
* 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.
/**
* gst_query_parse_buffering_stats:
* @query: A valid #GstQuery of type GST_QUERY_BUFFERING.
- * @mode: (out) (allow-none): a buffering mode, or %NULL
- * @avg_in: (out) (allow-none): the average input rate, or %NULL
- * @avg_out: (out) (allow-none): the average output rat, or %NULL
- * @buffering_left: (out) (allow-none): amount of buffering time left in
+ * @mode: (out) (optional): a buffering mode, or %NULL
+ * @avg_in: (out) (optional): the average input rate, or %NULL
+ * @avg_out: (out) (optional): the average output rat, or %NULL
+ * @buffering_left: (out) (optional): amount of buffering time left in
* milliseconds, or %NULL
*
* Extracts the buffering stats values from @query.
/**
* gst_query_parse_buffering_range:
* @query: a GST_QUERY_BUFFERING type query #GstQuery
- * @format: (out) (allow-none): the format to set for the @segment_start
+ * @format: (out) (optional): the format to set for the @segment_start
* and @segment_end values, or %NULL
- * @start: (out) (allow-none): the start to set, or %NULL
- * @stop: (out) (allow-none): the stop to set, or %NULL
- * @estimated_total: (out) (allow-none): estimated total amount of download
+ * @start: (out) (optional): the start to set, or %NULL
+ * @stop: (out) (optional): the stop to set, or %NULL
+ * @estimated_total: (out) (optional): estimated total amount of download
* time remaining in milliseconds, or %NULL
*
* Parse an available query, writing the format into @format, and
* gst_query_parse_nth_buffering_range:
* @query: a GST_QUERY_BUFFERING type query #GstQuery
* @index: position in the buffered-ranges array to read
- * @start: (out) (allow-none): the start position to set, or %NULL
- * @stop: (out) (allow-none): the stop position to set, or %NULL
+ * @start: (out) (optional): the start position to set, or %NULL
+ * @stop: (out) (optional): the stop position to set, or %NULL
*
* Parse an available query and get the start and stop values stored
* at the @index of the buffered ranges array.
/**
* gst_query_set_uri:
* @query: a #GstQuery with query type GST_QUERY_URI
- * @uri: the URI to set
+ * @uri: (nullable): the URI to set
*
* Answer a URI query by setting the requested URI.
*/
/**
* gst_query_parse_uri:
* @query: a #GstQuery
- * @uri: (out) (transfer full) (allow-none): the storage for the current URI
+ * @uri: (out) (transfer full) (optional) (nullable): the storage for the current URI
* (may be %NULL)
*
* Parse an URI query, writing the URI into @uri as a newly
/**
* gst_query_set_uri_redirection:
* @query: a #GstQuery with query type GST_QUERY_URI
- * @uri: the URI to set
+ * @uri: (nullable): the URI to set
*
* Answer a URI query by setting the requested URI redirection.
*
/**
* gst_query_parse_uri_redirection:
* @query: a #GstQuery
- * @uri: (out) (transfer full) (allow-none): the storage for the redirect URI
+ * @uri: (out) (transfer full) (optional) (nullable): the storage for the redirect URI
* (may be %NULL)
*
* Parse an URI query, writing the URI into @uri as a newly
/**
* gst_query_parse_uri_redirection_permanent:
* @query: a #GstQuery
- * @permanent: (out) (allow-none): if the URI redirection is permanent
+ * @permanent: (out) (optional): if the URI redirection is permanent
* (may be %NULL)
*
* Parse an URI query, and set @permanent to %TRUE if there is a redirection
/**
* gst_query_parse_allocation:
* @query: a #GstQuery
- * @caps: (out) (transfer none) (allow-none): The #GstCaps
- * @need_pool: (out) (allow-none): Whether a #GstBufferPool is needed
+ * @caps: (out) (transfer none) (optional): The #GstCaps
+ * @need_pool: (out) (optional): Whether a #GstBufferPool is needed
*
* Parse an allocation query, writing the requested caps in @caps and
* whether a pool is needed in @need_pool, if the respective parameters
/**
* gst_query_add_allocation_pool:
* @query: A valid #GstQuery of type GST_QUERY_ALLOCATION.
- * @pool: (transfer none) (allow-none): the #GstBufferPool
+ * @pool: (transfer none) (nullable): the #GstBufferPool
* @size: the buffer size
* @min_buffers: the min buffers
* @max_buffers: the max buffers
* gst_query_parse_nth_allocation_pool:
* @query: A valid #GstQuery of type GST_QUERY_ALLOCATION.
* @index: index to parse
- * @pool: (out) (allow-none) (transfer full): the #GstBufferPool
- * @size: (out) (allow-none): the buffer size
- * @min_buffers: (out) (allow-none): the min buffers
- * @max_buffers: (out) (allow-none): the max buffers
+ * @pool: (out) (optional) (transfer full) (nullable): the #GstBufferPool
+ * @size: (out) (optional): the buffer size
+ * @min_buffers: (out) (optional): the min buffers
+ * @max_buffers: (out) (optional): the max buffers
*
* Get the pool parameters in @query.
*
* gst_query_set_nth_allocation_pool:
* @index: index to modify
* @query: A valid #GstQuery of type GST_QUERY_ALLOCATION.
- * @pool: (transfer none) (allow-none): the #GstBufferPool
+ * @pool: (transfer none) (nullable): the #GstBufferPool
* @size: the buffer size
* @min_buffers: the min buffers
* @max_buffers: the max buffers
* gst_query_add_allocation_meta:
* @query: a GST_QUERY_ALLOCATION type query #GstQuery
* @api: the metadata API
- * @params: (transfer none) (allow-none): API specific parameters
+ * @params: (transfer none) (nullable): API specific parameters
*
* Add @api with @params as one of the supported metadata API to @query.
*/
* gst_query_parse_nth_allocation_meta:
* @query: a GST_QUERY_ALLOCATION type query #GstQuery
* @index: position in the metadata API array to read
- * @params: (out) (transfer none) (allow-none): API specific parameters
+ * @params: (out) (transfer none) (optional): API specific parameters
*
* Parse an available query and get the metadata API
* at @index of the metadata API array.
* gst_query_find_allocation_meta:
* @query: a GST_QUERY_ALLOCATION type query #GstQuery
* @api: the metadata API
- * @index: (out) (transfer none) (allow-none): the index
+ * @index: (out) (transfer none) (optional): the index
*
* Check if @query has metadata @api set. When this function returns %TRUE,
* @index will contain the index where the requested API and the parameters
/**
* gst_query_add_allocation_param:
* @query: a GST_QUERY_ALLOCATION type query #GstQuery
- * @allocator: (transfer none) (allow-none): the memory allocator
- * @params: (transfer none) (allow-none): a #GstAllocationParams
+ * @allocator: (transfer none) (nullable): the memory allocator
+ * @params: (transfer none) (nullable): a #GstAllocationParams
*
* Add @allocator and its @params as a supported memory allocator.
*/
* gst_query_parse_nth_allocation_param:
* @query: a GST_QUERY_ALLOCATION type query #GstQuery
* @index: position in the allocator array to read
- * @allocator: (out) (transfer full) (allow-none): variable to hold the result
- * @params: (out) (allow-none): parameters for the allocator
+ * @allocator: (out) (transfer full) (optional) (nullable): variable to hold the result
+ * @params: (out) (optional): parameters for the allocator
*
* Parse an available query and get the allocator and its params
* at @index of the allocator array.
* gst_query_set_nth_allocation_param:
* @query: a GST_QUERY_ALLOCATION type query #GstQuery
* @index: position in the allocator array to set
- * @allocator: (transfer none) (allow-none): new allocator to set
- * @params: (transfer none) (allow-none): parameters for the allocator
+ * @allocator: (transfer none) (nullable): new allocator to set
+ * @params: (transfer none) (nullable): parameters for the allocator
*
* Parse an available query and get the allocator and its params
* at @index of the allocator array.
/**
* gst_query_parse_scheduling:
* @query: A valid #GstQuery of type GST_QUERY_SCHEDULING.
- * @flags: (out) (allow-none): #GstSchedulingFlags
- * @minsize: (out) (allow-none): the suggested minimum size of pull requests
- * @maxsize: (out) (allow-none): the suggested maximum size of pull requests:
- * @align: (out) (allow-none): the suggested alignment of pull requests
+ * @flags: (out) (optional): #GstSchedulingFlags
+ * @minsize: (out) (optional): the suggested minimum size of pull requests
+ * @maxsize: (out) (optional): the suggested maximum size of pull requests:
+ * @align: (out) (optional): the suggested alignment of pull requests
*
* Set the scheduling properties.
*/
/**
* gst_query_parse_accept_caps_result:
* @query: a GST_QUERY_ACCEPT_CAPS type query #GstQuery
- * @result: (out) (allow-none): location for the result
+ * @result: (out) (nullable): location for the result
*
* Parse the result from @query and store in @result.
*/
/**
* gst_query_set_caps_result:
* @query: The query to use
- * @caps: (in): A pointer to the caps
+ * @caps: (nullable): A pointer to the caps
*
* Set the @caps result in @query.
*/
/**
* gst_query_parse_caps_result:
* @query: The query to parse
- * @caps: (out) (transfer none): A pointer to the caps
+ * @caps: (out) (transfer none) (nullable): A pointer to the caps
*
* Get the caps result from @query. The caps remains valid as long as
* @query remains valid.
/**
* gst_query_set_context:
* @query: a #GstQuery with query type GST_QUERY_CONTEXT
- * @context: the requested #GstContext
+ * @context: (nullable): the requested #GstContext
*
* Answer a context query by setting the requested context.
*
/**
* gst_query_parse_context:
* @query: The query to parse
- * @context: (out) (transfer none): A pointer to store the #GstContext
+ * @context: (out) (transfer none) (nullable): A pointer to store the #GstContext
*
* Get the context from the context @query. The context remains valid as long as
* @query remains valid.
/**
* gst_query_parse_context_type:
* @query: a GST_QUERY_CONTEXT type query
- * @context_type: (out) (transfer none) (allow-none): the context type, or %NULL
+ * @context_type: (out) (transfer none) (optional): the context type, or %NULL
*
* Parse a context type from an existing GST_QUERY_CONTEXT query.
*
/**
* gst_query_parse_bitrate:
* @query: a GST_QUERY_BITRATE type #GstQuery
- * @nominal_bitrate: (out) (allow-none): The resulting bitrate in bits per second
+ * @nominal_bitrate: (out) (optional): The resulting bitrate in bits per second
*
* Get the results of a bitrate query. See also gst_query_set_bitrate().
*
/**
* gst_query_parse_selectable:
* @query: a GST_QUERY_SELECTABLE type #GstQuery
- * @selectable: (out) (allow-none): The resulting stream selection capability
+ * @selectable: (out) (optional): The resulting stream selection capability
*
* Get the results of a selectable query. See also gst_query_set_selectable().
*
* gst_query_replace: (skip)
* @old_query: (inout) (transfer full) (nullable): pointer to a pointer to a
* #GstQuery to be replaced.
- * @new_query: (allow-none) (transfer none): pointer to a #GstQuery that will
+ * @new_query: (nullable) (transfer none): pointer to a #GstQuery that will
* replace the query pointed to by @old_query.
*
* Modifies a pointer to a #GstQuery to point to a different #GstQuery. The
* gst_query_take:
* @old_query: (inout) (transfer full) (nullable): pointer to a
* pointer to a #GstQuery to be stolen.
- * @new_query: (allow-none) (transfer full): pointer to a #GstQuery that will
+ * @new_query: (nullable) (transfer full): pointer to a #GstQuery that will
* replace the query pointed to by @old_query.
*
* Modifies a pointer to a #GstQuery to point to a different #GstQuery. This
* gst_structure_take:
* @oldstr_ptr: (inout) (transfer full) (nullable): pointer to a place of
* a #GstStructure to take
- * @newstr: (transfer full) (allow-none): a new #GstStructure
+ * @newstr: (transfer full) (nullable): a new #GstStructure
*
* Atomically modifies a pointer to point to a new structure.
* The #GstStructure @oldstr_ptr is pointing to is freed and
* gst_structure_get_flagset:
* @structure: a #GstStructure
* @fieldname: the name of a field
- * @value_flags: (out) (allow-none): a pointer to a guint for the flags field
- * @value_mask: (out) (allow-none): a pointer to a guint for the mask field
+ * @value_flags: (out) (optional): a pointer to a guint for the flags field
+ * @value_mask: (out) (optional): a pointer to a guint for the mask field
*
* Read the GstFlagSet flags and mask out of the structure into the
* provided pointers.
/**
* gst_structure_from_string: (constructor):
* @string: a string representation of a #GstStructure.
- * @end: (out) (allow-none) (transfer none) (skip): pointer to store the end of the string in.
+ * @end: (out) (optional) (transfer none) (skip): pointer to store the end of the string in.
*
* Creates a #GstStructure from a string representation.
* If end is not %NULL, a pointer to the place inside the given string
*
* Intersects @struct1 and @struct2 and returns the intersection.
*
- * Returns: (nullable): Intersection of @struct1 and @struct2
+ * Returns: (transfer full) (nullable): Intersection of @struct1 and @struct2
*/
GstStructure *
gst_structure_intersect (const GstStructure * struct1,
* Returns the human-readable name of this tag, You must not change or free
* this string.
*
- * Returns: (nullable): the human-readable name of this tag
+ * Returns: the human-readable name of this tag
*/
const gchar *
gst_tag_get_nick (const gchar * tag)
* Returns the human-readable description of this tag, You must not change or
* free this string.
*
- * Returns: (nullable): the human-readable description of this tag
+ * Returns: the human-readable description of this tag
*/
const gchar *
gst_tag_get_description (const gchar * tag)
*
* Serializes a tag list to a string.
*
- * Returns: (nullable): a newly-allocated string, or %NULL in case of
- * an error. The string must be freed with g_free() when no longer
+ * Returns: (transfer full): a newly-allocated string.
+ * The string must be freed with g_free() when no longer
* needed.
*/
gchar *
*
* Deserializes a tag list.
*
- * Returns: (nullable): a new #GstTagList, or %NULL in case of an
+ * Returns: (transfer full) (nullable): a new #GstTagList, or %NULL in case of an
* error.
*/
GstTagList *
/**
* gst_tag_list_merge:
- * @list1: (allow-none): first list to merge
- * @list2: (allow-none): second list to merge
+ * @list1: (nullable): first list to merge
+ * @list2: (nullable): second list to merge
* @mode: the mode to use
*
* Merges the two given lists into a new list. If one of the lists is %NULL, a
*
* When you are finished with the taglist, call gst_tag_list_unref() on it.
*
- * Returns: the new #GstTagList
+ * Returns: (transfer full): the new #GstTagList
*/
GstTagList *(gst_tag_list_copy) (const GstTagList * taglist)
{
/**
* gst_toc_set_tags:
* @toc: A #GstToc instance
- * @tags: (allow-none) (transfer full): A #GstTagList or %NULL
+ * @tags: (nullable) (transfer full): A #GstTagList or %NULL
*
* Set a #GstTagList with tags for the complete @toc.
*/
/**
* gst_toc_merge_tags:
* @toc: A #GstToc instance
- * @tags: (allow-none): A #GstTagList or %NULL
+ * @tags: (nullable): A #GstTagList or %NULL
* @mode: A #GstTagMergeMode
*
* Merge @tags into the existing tags of @toc using @mode.
*
* Gets the tags for @toc.
*
- * Returns: (transfer none): A #GstTagList for @entry
+ * Returns: (transfer none) (nullable): A #GstTagList for @entry
*/
GstTagList *
gst_toc_get_tags (const GstToc * toc)
*
* Create new #GstTocEntry structure.
*
- * Returns: newly allocated #GstTocEntry structure, free it with gst_toc_entry_unref().
+ * Returns: (transfer full): newly allocated #GstTocEntry structure, free it with gst_toc_entry_unref().
*/
GstTocEntry *
gst_toc_entry_new (GstTocEntryType type, const gchar * uid)
*
* Copy #GstTocEntry with all subentries (deep copy).
*
- * Returns: (nullable): newly allocated #GstTocEntry in case of
- * success, %NULL otherwise; free it when done with
+ * Returns: (transfer full): newly allocated #GstTocEntry; free it when done with
* gst_toc_entry_unref().
*/
static GstTocEntry *
*
* Copy #GstToc with all subentries (deep copy).
*
- * Returns: (nullable): newly allocated #GstToc in case of success,
- * %NULL otherwise; free it when done with gst_toc_unref().
+ * Returns: (transfer full): newly allocated #GstToc; free it when done with gst_toc_unref().
*/
static GstToc *
gst_toc_copy (const GstToc * toc)
/**
* gst_toc_entry_get_start_stop_times:
* @entry: #GstTocEntry to get values from.
- * @start: (out) (allow-none): the storage for the start value, leave
+ * @start: (out) (optional): the storage for the start value, leave
* %NULL if not need.
- * @stop: (out) (allow-none): the storage for the stop value, leave
+ * @stop: (out) (optional): the storage for the stop value, leave
* %NULL if not need.
*
* Get @start and @stop values from the @entry and write them into appropriate
/**
* gst_toc_entry_get_loop:
* @entry: #GstTocEntry to get values from.
- * @loop_type: (out) (allow-none): the storage for the loop_type
+ * @loop_type: (out) (optional): the storage for the loop_type
* value, leave %NULL if not need.
- * @repeat_count: (out) (allow-none): the storage for the repeat_count
+ * @repeat_count: (out) (optional): the storage for the repeat_count
* value, leave %NULL if not need.
*
* Get @loop_type and @repeat_count values from the @entry and write them into
/**
* gst_toc_entry_set_tags:
* @entry: A #GstTocEntry instance
- * @tags: (allow-none) (transfer full): A #GstTagList or %NULL
+ * @tags: (nullable) (transfer full): A #GstTagList or %NULL
*
* Set a #GstTagList with tags for the complete @entry.
*/
/**
* gst_toc_entry_merge_tags:
* @entry: A #GstTocEntry instance
- * @tags: (allow-none): A #GstTagList or %NULL
+ * @tags: (nullable): A #GstTagList or %NULL
* @mode: A #GstTagMergeMode
*
* Merge @tags into the existing tags of @entry using @mode.
*
* Gets the tags for @entry.
*
- * Returns: (transfer none): A #GstTagList for @entry
+ * Returns: (nullable) (transfer none): A #GstTagList for @entry
*/
GstTagList *
gst_toc_entry_get_tags (const GstTocEntry * entry)
*
* Gets the parent #GstToc of @entry.
*
- * Returns: (transfer none): The parent #GstToc of @entry
+ * Returns: (transfer none) (nullable): The parent #GstToc of @entry
*/
GstToc *
gst_toc_entry_get_toc (GstTocEntry * entry)
*
* Free-function: g_free
*
- * Returns: (transfer full): a new string for this URI. Returns %NULL if the
- * given URI protocol is not valid, or the given location is %NULL.
+ * Returns: (transfer full): a new string for this URI.
*
* Deprecated: Use GstURI instead.
*/
* gst_element_make_from_uri:
* @type: Whether to create a source or a sink
* @uri: URI to create an element for
- * @elementname: (allow-none): Name of created element, can be %NULL.
- * @error: (allow-none): address where to store error information, or %NULL.
+ * @elementname: (nullable): Name of created element, can be %NULL.
+ * @error: (optional): address where to store error information, or %NULL.
*
* Creates an element for handling the given URI.
*
* Gets the list of protocols supported by @handler. This list may not be
* modified.
*
- * Returns: (transfer none) (element-type utf8) (nullable): the
+ * Returns: (transfer none) (element-type utf8) (nullable) (array zero-terminated=1): the
* supported protocols. Returns %NULL if the @handler isn't
* implemented properly, or the @handler doesn't support any
* protocols.
* gst_uri_handler_set_uri:
* @handler: A #GstURIHandler
* @uri: URI to set
- * @error: (allow-none): address where to store a #GError in case of
+ * @error: (optional): address where to store a #GError in case of
* an error, or %NULL
*
* Tries to set the URI of the given handler.
*
* On Windows @filename should be in UTF-8 encoding.
*
- * Returns: newly-allocated URI string, or NULL on error. The caller must
+ * Returns: (nullable): newly-allocated URI string, or NULL on error. The caller must
* free the URI string with g_free() when no longer needed.
*/
gchar *
*
* Like gst_uri_from_string() but also joins with a base URI.
*
- * Returns: (transfer full): A new #GstUri object.
+ * Returns: (transfer full) (nullable): A new #GstUri object.
*
* Since: 1.6
*/
g_return_val_if_fail (base == NULL || GST_IS_URI (base), NULL);
new_rel_uri = gst_uri_from_string (uri);
+ if (!new_rel_uri)
+ return NULL;
+
new_uri = gst_uri_join (base, new_rel_uri);
gst_uri_unref (new_rel_uri);
* This is a convenience function to join two URI strings and return the result.
* The returned string should be g_free()'d after use.
*
- * Returns: (transfer full): A string representing the percent-encoded join of
+ * Returns: (transfer full) (nullable): A string representing the percent-encoded join of
* the two URIs.
*
* Since: 1.6
gchar *result_uri;
base = gst_uri_from_string (base_uri);
+ if (!base)
+ return NULL;
+
result = gst_uri_from_string_with_base (base, ref_uri);
+ if (!result) {
+ gst_uri_unref (base);
+ return NULL;
+ }
+
result_uri = gst_uri_to_string (result);
gst_uri_unref (base);
gst_uri_unref (result);
/**
* gst_uri_is_normalized:
- * @uri: The #GstUri to test to see if it is normalized.
+ * @uri: (nullable): The #GstUri to test to see if it is normalized.
*
* Tests the @uri to see if it is normalized. A %NULL @uri is considered to be
* normalized.
/**
* gst_uri_get_path:
- * @uri: The #GstUri to get the path from.
+ * @uri: (nullable): The #GstUri to get the path from.
*
* Extract the path string from the URI object.
*
/**
* gst_uri_set_path:
* @uri: (transfer none) (nullable): The #GstUri to modify.
- * @path: The new path to set with path segments separated by '/', or use %NULL
+ * @path: (nullable): The new path to set with path segments separated by '/', or use %NULL
* to unset the path.
*
* Sets or unsets the path in the URI.
/**
* gst_uri_get_path_string:
- * @uri: The #GstUri to get the path from.
+ * @uri: (nullable): The #GstUri to get the path from.
*
* Extract the path string from the URI object as a percent encoded URI path.
*
/**
* gst_uri_append_path:
* @uri: (transfer none)(nullable): The #GstUri to modify.
- * @relative_path: Relative path to append to the end of the current path.
+ * @relative_path: (nullable): Relative path to append to the end of the current path.
*
* Append a path onto the end of the path in the URI. The path is not
* normalized, call #gst_uri_normalize() to normalize the path.
/**
* gst_uri_append_path_segment:
* @uri: (transfer none)(nullable): The #GstUri to modify.
- * @path_segment: The path segment string to append to the URI path.
+ * @path_segment: (nullable): The path segment string to append to the URI path.
*
* Append a single path segment onto the end of the URI path.
*
/**
* gst_uri_set_query_string:
* @uri: (transfer none)(nullable): The #GstUri to modify.
- * @query: The new percent encoded query string to use to populate the query
+ * @query: (nullable): The new percent encoded query string to use to populate the query
* table, or use %NULL to unset the query table.
*
* Sets or unsets the query table in the URI.
* gst_element_get_compatible_pad:
* @element: (transfer none): a #GstElement in which the pad should be found.
* @pad: (transfer none): the #GstPad to find a compatible one for.
- * @caps: (allow-none): the #GstCaps to use as a filter.
+ * @caps: (nullable): the #GstCaps to use as a filter.
*
* Looks for an unlinked pad to which the given pad can link. It is not
* guaranteed that linking the pads will work, though it should work in most
/**
* gst_element_link_pads_full:
* @src: a #GstElement containing the source pad.
- * @srcpadname: (allow-none): the name of the #GstPad in source element
+ * @srcpadname: (nullable): the name of the #GstPad in source element
* or %NULL for any pad.
* @dest: (transfer none): the #GstElement containing the destination pad.
- * @destpadname: (allow-none): the name of the #GstPad in destination element,
+ * @destpadname: (nullable): the name of the #GstPad in destination element,
* or %NULL for any pad.
* @flags: the #GstPadLinkCheck to be performed when linking pads.
*
/**
* gst_element_link_pads:
* @src: a #GstElement containing the source pad.
- * @srcpadname: (allow-none): the name of the #GstPad in source element
+ * @srcpadname: (nullable): the name of the #GstPad in source element
* or %NULL for any pad.
* @dest: (transfer none): the #GstElement containing the destination pad.
- * @destpadname: (allow-none): the name of the #GstPad in destination element,
+ * @destpadname: (nullable): the name of the #GstPad in destination element,
* or %NULL for any pad.
*
* Links the two named pads of the source and destination elements.
/**
* gst_element_link_pads_filtered:
* @src: a #GstElement containing the source pad.
- * @srcpadname: (allow-none): the name of the #GstPad in source element
+ * @srcpadname: (nullable): the name of the #GstPad in source element
* or %NULL for any pad.
* @dest: (transfer none): the #GstElement containing the destination pad.
- * @destpadname: (allow-none): the name of the #GstPad in destination element
+ * @destpadname: (nullable): the name of the #GstPad in destination element
* or %NULL for any pad.
- * @filter: (transfer none) (allow-none): the #GstCaps to filter the link,
+ * @filter: (transfer none) (nullable): the #GstCaps to filter the link,
* or %NULL for no filter.
*
* Links the two named pads of the source and destination elements. Side effect
* gst_element_link_filtered:
* @src: a #GstElement containing the source pad.
* @dest: (transfer none): the #GstElement containing the destination pad.
- * @filter: (transfer none) (allow-none): the #GstCaps to filter the link,
+ * @filter: (transfer none) (nullable): the #GstCaps to filter the link,
* or %NULL for no filter.
*
* Links @src to @dest using the given caps as filtercaps.
* gst_element_query_position:
* @element: a #GstElement to invoke the position query on.
* @format: the #GstFormat requested
- * @cur: (out) (allow-none): a location in which to store the current
+ * @cur: (out) (optional): a location in which to store the current
* position, or %NULL.
*
* Queries an element (usually top-level pipeline or playbin element) for the
* gst_element_query_duration:
* @element: a #GstElement to invoke the duration query on.
* @format: the #GstFormat requested
- * @duration: (out) (allow-none): A location in which to store the total duration, or %NULL.
+ * @duration: (out) (optional): A location in which to store the total duration, or %NULL.
*
* Queries an element (usually top-level pipeline or playbin element) for the
* total stream duration in nanoseconds. This query will only work once the
return TRUE;
}
+ *dest_val = -1;
+
query = gst_query_new_convert (src_format, src_val, dest_format);
ret = gst_element_query (element, query);
* gst_object_default_error:
* @source: the #GstObject that initiated the error.
* @error: (in): the GError.
- * @debug: (in) (allow-none): an additional debug information string, or %NULL
+ * @debug: (in) (nullable): an additional debug information string, or %NULL
*
* A default error function that uses g_printerr() to display the error message
* and the optional debug string..
* gst_pad_query_position:
* @pad: a #GstPad to invoke the position query on.
* @format: the #GstFormat requested
- * @cur: (out) (allow-none): A location in which to store the current position, or %NULL.
+ * @cur: (out) (optional): A location in which to store the current position, or %NULL.
*
* Queries a pad for the stream position.
*
* @pad: a #GstPad on whose peer to invoke the position query on.
* Must be a sink pad.
* @format: the #GstFormat requested
- * @cur: (out) (allow-none): a location in which to store the current
+ * @cur: (out) (optional): a location in which to store the current
* position, or %NULL.
*
* Queries the peer of a given sink pad for the stream position.
* gst_pad_query_duration:
* @pad: a #GstPad to invoke the duration query on.
* @format: the #GstFormat requested
- * @duration: (out) (allow-none): a location in which to store the total
+ * @duration: (out) (optional): a location in which to store the total
* duration, or %NULL.
*
* Queries a pad for the total stream duration.
* @pad: a #GstPad on whose peer pad to invoke the duration query on.
* Must be a sink pad.
* @format: the #GstFormat requested
- * @duration: (out) (allow-none): a location in which to store the total
+ * @duration: (out) (optional): a location in which to store the total
* duration, or %NULL.
*
* Queries the peer pad of a given sink pad for the total stream duration.
return TRUE;
}
+ *dest_val = -1;
+
query = gst_query_new_convert (src_format, src_val, dest_format);
if ((ret = gst_pad_query (pad, query)))
gst_query_parse_convert (query, NULL, NULL, NULL, dest_val);
g_return_val_if_fail (dest_format != GST_FORMAT_UNDEFINED, FALSE);
g_return_val_if_fail (dest_val != NULL, FALSE);
+ *dest_val = -1;
+
query = gst_query_new_convert (src_format, src_val, dest_format);
if ((ret = gst_pad_peer_query (pad, query)))
gst_query_parse_convert (query, NULL, NULL, NULL, dest_val);
/**
* gst_pad_query_caps:
* @pad: a #GstPad to get the capabilities of.
- * @filter: (allow-none): suggested #GstCaps, or %NULL
+ * @filter: (nullable): suggested #GstCaps, or %NULL
*
* Gets the capabilities this pad can produce or consume.
* Note that this method doesn't necessarily return the caps set by sending a
/**
* gst_pad_peer_query_caps:
* @pad: a #GstPad to get the capabilities of.
- * @filter: (allow-none): a #GstCaps filter, or %NULL.
+ * @filter: (nullable): a #GstCaps filter, or %NULL.
*
* Gets the capabilities of the peer connected to this pad. Similar to
* gst_pad_query_caps().
* @bin_description: command line describing the bin
* @ghost_unlinked_pads: whether to automatically create ghost pads
* for unlinked source or sink pads within the bin
- * @context: (transfer none) (allow-none): a parse context allocated with
+ * @context: (transfer none) (nullable): a parse context allocated with
* gst_parse_context_new(), or %NULL
* @flags: parsing options, or #GST_PARSE_FLAG_NONE
* @err: where to store the error message in case of an error, or %NULL
* gst_pad_create_stream_id_printf_valist:
* @pad: A source #GstPad
* @parent: Parent #GstElement of @pad
- * @stream_id: (allow-none): The stream-id
+ * @stream_id: (nullable): The stream-id
* @var_args: parameters for the @stream_id format string
*
* Creates a stream-id for the source #GstPad @pad by combining the
* gst_pad_create_stream_id_printf:
* @pad: A source #GstPad
* @parent: Parent #GstElement of @pad
- * @stream_id: (allow-none): The stream-id
+ * @stream_id: (nullable): The stream-id
* @...: parameters for the @stream_id format string
*
* Creates a stream-id for the source #GstPad @pad by combining the
* gst_pad_create_stream_id:
* @pad: A source #GstPad
* @parent: Parent #GstElement of @pad
- * @stream_id: (allow-none): The stream-id
+ * @stream_id: (nullable): The stream-id
*
* Creates a stream-id for the source #GstPad @pad by combining the
* upstream information with the optional @stream_id of the stream
/**
* gst_type_is_plugin_api:
* @type: a GType
- * @flags: (out) (nullable): What #GstPluginAPIFlags the plugin was marked with
+ * @flags: (out) (optional): What #GstPluginAPIFlags the plugin was marked with
*
* Checks if @type is plugin API. See gst_type_mark_as_plugin_api() for
* details.
projects / platform / upstream / gstreamer.git / commitdiff