From 7feadd2f32d0d506faa8d48e61efe154895a58d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 22 Feb 2019 12:13:16 +0200 Subject: [PATCH] Update documentation --- docs/gstreamer-base/docs.md | 6 +- docs/gstreamer-pbutils/docs.md | 1522 ++++++++++++++++++-------------- docs/gstreamer-video/docs.md | 301 +++++++ docs/gstreamer/docs.md | 143 +-- 4 files changed, 1222 insertions(+), 750 deletions(-) diff --git a/docs/gstreamer-base/docs.md b/docs/gstreamer-base/docs.md index ae4094b91..ba6ce92c0 100644 --- a/docs/gstreamer-base/docs.md +++ b/docs/gstreamer-base/docs.md @@ -779,7 +779,7 @@ Subclasses that synchronise on the clock in the `BaseSinkClass.render`() method are supported as well. These classes typically receive a buffer in the render method and can then potentially block on the clock while rendering. A typical example is an audiosink. -These subclasses can use `BaseSinkExt::wait_preroll` to perform the +These subclasses can use `BaseSink::wait_preroll` to perform the blocking wait. Upon receiving the EOS event in the PLAYING state, `BaseSink` will wait @@ -1245,7 +1245,7 @@ can only produce data in the PLAYING state, when the clock is actually distributed and running. Live sources that synchronize and block on the clock (an audio source, for -example) can use `BaseSrcExt::wait_playing` when the +example) can use `BaseSrc::wait_playing` when the `BaseSrcClass.create`() function was interrupted by a state change to PAUSED. @@ -1451,7 +1451,7 @@ be GST_STATE_CHANGE_NO_PREROLL. new live-mode Complete an asynchronous start operation. When the subclass overrides the -start method, it should call `BaseSrcExt::start_complete` when the start +start method, it should call `BaseSrc::start_complete` when the start operation completes either from the same thread or from an asynchronous helper thread. ## `ret` diff --git a/docs/gstreamer-pbutils/docs.md b/docs/gstreamer-pbutils/docs.md index a3d723109..6cda12fb7 100644 --- a/docs/gstreamer-pbutils/docs.md +++ b/docs/gstreamer-pbutils/docs.md @@ -1,747 +1,909 @@ - + +The `Discoverer` is a utility object which allows to get as much +information as possible from one or many URIs. +It provides two APIs, allowing usage in blocking or non-blocking mode. -# Implements +The blocking mode just requires calling `Discoverer::discover_uri` +with the URI one wishes to discover. -[`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) - -Creates a new `Player` instance that uses `signal_dispatcher` to dispatch -signals to some event loop system, or emits signals directly if NULL is -passed. See `PlayerGMainContextSignalDispatcher::new`. +The non-blocking mode requires a running `glib::MainLoop` iterating a +`glib::MainContext`, where one connects to the various signals, appends the +URIs to be processed (through `Discoverer::discover_uri_async`) and then +asks for the discovery to begin (through `Discoverer::start`). +By default this will use the GLib default main context unless you have +set a custom context using `glib::MainContext::push_thread_default`. -Video is going to be rendered by `video_renderer`, or if `None` is provided -no special video set up will be done and some default handling will be -performed. -## `video_renderer` -GstPlayerVideoRenderer to use -## `signal_dispatcher` -GstPlayerSignalDispatcher to use - -# Returns - -a new `Player` instance - -## `config` -a `Player` configuration - -# Returns - -current position update interval in milliseconds - -Since 1.10 - -## `config` -a `Player` configuration - -# Returns - -`true` if accurate seeking is enabled - -Since 1.12 - -Return the user agent which has been configured using -`Player::config_set_user_agent` if any. -## `config` -a `Player` configuration - -# Returns - -the configured agent, or `None` -Since 1.10 - -set interval in milliseconds between two position-updated signals. -pass 0 to stop updating the position. -Since 1.10 -## `config` -a `Player` configuration -## `interval` -interval in ms - -Enable or disable accurate seeking. When enabled, elements will try harder -to seek as accurately as possible to the requested seek position. Generally -it will be slower especially for formats that don't have any indexes or -timestamp markers in the stream. - -If accurate seeking is disabled, elements will seek as close as the request -position without slowing down seeking too much. - -Accurate seeking is disabled by default. -## `config` -a `Player` configuration -## `accurate` -accurate seek or not - -Set the user agent to pass to the server if `player` needs to connect -to a server during playback. This is typically used when playing HTTP -or RTSP streams. - -Since 1.10 -## `config` -a `Player` configuration -## `agent` -the string to use as user agent - -## `info` -a `PlayerMediaInfo` - -# Returns - -A `glib::List` of -matching `PlayerAudioInfo`. - -## `info` -a `PlayerMediaInfo` - -# Returns - -A `glib::List` of -matching `PlayerSubtitleInfo`. - -## `info` -a `PlayerMediaInfo` - -# Returns - -A `glib::List` of -matching `PlayerVideoInfo`. - -Frees a `None` terminated array of `PlayerVisualization`. -## `viss` -a `None` terminated array of `PlayerVisualization` to free - - -# Returns - - - a `None` terminated array containing all available - visualizations. Use `Player::visualizations_free` after - usage. - -Retrieve the current value of audio-video-offset property - -# Returns - -The current value of audio-video-offset in nanoseconds - -Since 1.10 - -Retrieve the current value of the indicated `type_`. -## `type_` -`PlayerColorBalanceType` - -# Returns - -The current value of `type_`, between [0,1]. In case of - error -1 is returned. - -Get a copy of the current configuration of the player. This configuration -can either be modified and used for the `Player::set_config` call -or it must be freed after usage. - -# Returns - -a copy of the current configuration of `self`. Use -`gst::Structure::free` after usage or `Player::set_config`. - -Since 1.10 - -A Function to get current audio `PlayerAudioInfo` instance. - -# Returns - -current audio track. - -The caller should free it with `gobject::ObjectExt::unref` - -A Function to get current subtitle `PlayerSubtitleInfo` instance. - -# Returns - -current subtitle track. - -The caller should free it with `gobject::ObjectExt::unref` - -A Function to get current video `PlayerVideoInfo` instance. - -# Returns - -current video track. - -The caller should free it with `gobject::ObjectExt::unref` - - -# Returns - -Name of the currently enabled visualization. - `g_free` after usage. - -Retrieves the duration of the media stream that self represents. - -# Returns - -the duration of the currently-playing media stream, in -nanoseconds. - -A Function to get the current media info `PlayerMediaInfo` instance. - -# Returns - -media info instance. - -The caller should free it with `gobject::ObjectExt::unref` - -Retrieve the current value of the indicated `type_`. - -# Returns - -The current value of `type_`, Default: 0x00000000 "none - -Retrieve the current value of the indicated `type_`. - -# Returns - -The current value of `type_`, Default: -1 "none" - - -# Returns - -`true` if the currently-playing stream is muted. - - -# Returns - -The internal playbin instance - - -# Returns - -the absolute position time, in nanoseconds, of the -currently-playing stream. - - -# Returns - -current playback rate - -current subtitle URI - -# Returns - -URI of the current external subtitle. - `g_free` after usage. - -Gets the URI of the currently-playing stream. - -# Returns - -a string containing the URI of the -currently-playing stream. `g_free` after usage. - -Get a snapshot of the currently selected video stream, if any. The format can be -selected with `format` and optional configuration is possible with `config` -Currently supported settings are: -- width, height of type G_TYPE_INT -- pixel-aspect-ratio of type GST_TYPE_FRACTION - Except for GST_PLAYER_THUMBNAIL_RAW_NATIVE format, if no config is set, pixel-aspect-ratio would be 1/1 -## `format` -output format of the video snapshot -## `config` -Additional configuration - -# Returns - -Current video snapshot sample or `None` on failure - -Since 1.12 - -Returns the current volume level, as a percentage between 0 and 1. - -# Returns - -the volume as percentage between 0 and 1. - -Checks whether the `self` has color balance support available. - -# Returns - -`true` if `self` has color balance support. Otherwise, - `false`. - -Pauses the current stream. - -Request to play the loaded stream. - -Seeks the currently-playing stream to the absolute `position` time -in nanoseconds. -## `position` -position to seek in nanoseconds - -## `stream_index` -stream index - -# Returns - -`true` or `false` - -Sets the audio track `stream_idex`. - -Enable or disable the current audio track. -## `enabled` -TRUE or FALSE - -Sets audio-video-offset property by value of `offset` - -Since 1.10 -## `offset` -`gint64` in nanoseconds - -Sets the current value of the indicated channel `type_` to the passed -value. -## `type_` -`PlayerColorBalanceType` -## `value` -The new value for the `type_`, ranged [0,1] - -Set the configuration of the player. If the player is already configured, and -the configuration haven't change, this function will return `true`. If the -player is not in the GST_PLAYER_STATE_STOPPED, this method will return `false` -and active configuration will remain. - -`config` is a `gst::Structure` that contains the configuration parameters for -the player. - -This function takes ownership of `config`. -## `config` -a `gst::Structure` - -# Returns - -`true` when the configuration could be set. -Since 1.10 - -Sets the current value of the indicated mode `type_` to the passed -value. -## `flags` -The new value for the `type_` - -Sets the current value of the indicated mode `type_` to the passed -value. -## `mode` -The new value for the `type_` - -`true` if the currently-playing stream should be muted. -## `val` -Mute state the should be set - -Playback at specified rate -## `rate` -playback rate - -## `stream_index` -stream index - -# Returns - -`true` or `false` - -Sets the subtitle strack `stream_index`. - -Enable or disable the current subtitle track. -## `enabled` -TRUE or FALSE - -Sets the external subtitle URI. This should be combined with a call to -gst_player_set_subtitle_track_enabled(`self`, TRUE) so the subtitles are actually -rendered. -## `uri` -subtitle URI - -Sets the next URI to play. -## `uri` -next URI to play. - -## `stream_index` -stream index - -# Returns - -`true` or `false` - -Sets the video track `stream_index`. - -Enable or disable the current video track. -## `enabled` -TRUE or FALSE - -## `name` -visualization element obtained from -`Player::visualizations_get`() - -# Returns - -`true` if the visualizations was set correctly. Otherwise, -`false`. - -Enable or disable the visualization. -## `enabled` -TRUE or FALSE - -Sets the volume level of the stream as a percentage between 0 and 1. -## `val` -the new volume level, as a percentage between 0 and 1 - -Stops playing the current stream and resets to the first position -in the stream. - -`PlayerStreamInfo` specific to audio streams. - -# Implements - -[`PlayerStreamInfoExt`](trait.PlayerStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) - - -# Returns - -the audio bitrate in `PlayerAudioInfo`. - - -# Returns - -the number of audio channels in `PlayerAudioInfo`. - - -# Returns - -the language of the stream, or NULL if unknown. - - -# Returns - -the audio maximum bitrate in `PlayerAudioInfo`. - - -# Returns - -the audio sample rate in `PlayerAudioInfo`. - - -hue or color balance. - -brightness or black level. - -color saturation or chroma -gain. - -contrast or luma gain. - - -generic error. - - - -# Implements - -[`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`PlayerSignalDispatcherExt`](trait.PlayerSignalDispatcherExt.html) - -Creates a new GstPlayerSignalDispatcher that uses `application_context`, -or the thread default one if `None` is used. See `gst_player_new_full`. -## `application_context` -GMainContext to use or `None` - -# Returns - -the new GstPlayerSignalDispatcher - -Structure containing the media information of a URI. +All the information is returned in a `DiscovererInfo` structure. # Implements [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) - + +Creates a new `Discoverer` with the provided timeout. +## `timeout` +timeout per file, in nanoseconds. Allowed are values between + one second (`GST_SECOND`) and one hour (3600 * `GST_SECOND`) # Returns -A `glib::List` of -matching `PlayerAudioInfo`. - +The new `Discoverer`. +If an error occurred when creating the discoverer, `err` will be set +accordingly and `None` will be returned. If `err` is set, the caller must +free it when no longer needed using `glib::Error::free`. + +Synchronously discovers the given `uri`. + +A copy of `uri` will be made internally, so the caller can safely `g_free` +afterwards. +## `uri` +The URI to run on. # Returns -the container format. - +the result of the scanning. Can be `None` if an +error occurred. + +Appends the given `uri` to the list of URIs to discoverer. The actual +discovery of the `uri` will only take place if `Discoverer::start` has +been called. + +A copy of `uri` will be made internally, so the caller can safely `g_free` +afterwards. +## `uri` +the URI to add. # Returns -duration of the media. - -Function to get the image (or preview-image) stored in taglist. -Application can use gst_sample_*`_` API's to get caps, buffer etc. +`true` if the `uri` was successfully appended to the list of pending +uris, else `false` + +Allow asynchronous discovering of URIs to take place. +A `glib::MainLoop` must be available for `Discoverer` to properly work in +asynchronous mode. + +Stop the discovery of any pending URIs and clears the list of +pending URIS (if any). + +Will be emitted in async mode when all information on a URI could be +discovered, or an error occurred. -# Returns +When an error occurs, `info` might still contain some partial information, +depending on the circumstances of the error. +## `info` +the results `DiscovererInfo` +## `error` +`glib::Error`, which will be non-NULL + if an error occurred during + discovery. You must not free + this `glib::Error`, it will be freed by + the discoverer. + +Will be emitted in async mode when all pending URIs have been processed. + +This signal is emitted after the source element has been created for, so +the URI being discovered, so it can be configured by setting additional +properties (e.g. set a proxy server for an http source, or set the device +and read speed for an audio cd source). -GstSample or NULL. - +This signal is usually emitted from the context of a GStreamer streaming +thread. +## `source` +source element + +Will be emitted when the discover starts analyzing the pending URIs + +The duration (in nanoseconds) after which the discovery of an individual +URI will timeout. -# Returns - -number of audio streams. - - -# Returns - -number of total streams. - - -# Returns - -number of subtitle streams. - - -# Returns - -number of video streams. - - -# Returns - -A `glib::List` of -matching `PlayerStreamInfo`. - - -# Returns - -A `glib::List` of -matching `PlayerSubtitleInfo`. - - -# Returns - -the tags contained in media info. - - -# Returns - -the media title. - - -# Returns - -the URI associated with `PlayerMediaInfo`. - - -# Returns - -A `glib::List` of -matching `PlayerVideoInfo`. - - -# Returns - -`true` if the media is live. - - -# Returns - -`true` if the media is seekable. - +If the discovery of a URI times out, the `DiscovererResult::Timeout` will be +set on the result flags. + +The duration (in nanoseconds) after which the discovery of an individual +URI will timeout. +If the discovery of a URI times out, the `DiscovererResult::Timeout` will be +set on the result flags. + +`DiscovererStreamInfo` specific to audio streams. # Implements -[`PlayerSignalDispatcherExt`](trait.PlayerSignalDispatcherExt.html) - -Trait containing all `PlayerSignalDispatcher` methods. - -# Implementors - -[`PlayerGMainContextSignalDispatcher`](struct.PlayerGMainContextSignalDispatcher.html), [`PlayerSignalDispatcher`](struct.PlayerSignalDispatcher.html) - - - -the player is stopped. - -the player is buffering. - -the player is paused. - -the player is currently playing a -stream. - -Base structure for information concering a media stream. Depending on -the stream type, one can find more media-specific information in -`PlayerVideoInfo`, `PlayerAudioInfo`, `PlayerSubtitleInfo`. - -# Implements - -[`PlayerStreamInfoExt`](trait.PlayerStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) - -Trait containing all `PlayerStreamInfo` methods. - -# Implementors - -[`PlayerAudioInfo`](struct.PlayerAudioInfo.html), [`PlayerStreamInfo`](struct.PlayerStreamInfo.html), [`PlayerSubtitleInfo`](struct.PlayerSubtitleInfo.html), [`PlayerVideoInfo`](struct.PlayerVideoInfo.html) - +[`DiscovererStreamInfoExt`](trait.DiscovererStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + # Returns -the `gst::Caps` of the stream. - -A string describing codec used in `PlayerStreamInfo`. +the average or nominal bitrate of the stream in bits/second. + + +Feature: `v1_14` + # Returns -codec string or NULL on unknown. - -Function to get stream index from `PlayerStreamInfo` instance. +the channel-mask of the stream, refer to +`gst_audio_channel_positions_from_mask` for more +information. + # Returns -the stream index of this stream. - -Function to return human readable name for the stream type -of the given `self` (ex: "audio", "video", "subtitle") +the number of channels in the stream. + # Returns -a human readable name - - -# Returns - -the tags contained in this stream. - -`PlayerStreamInfo` specific to subtitle streams. - -# Implements - -[`PlayerStreamInfoExt`](trait.PlayerStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) - +the number of bits used per sample in each channel. + # Returns the language of the stream, or NULL if unknown. - -`PlayerStreamInfo` specific to video streams. + + +# Returns + +the maximum bitrate of the stream in bits/second. + + +# Returns + +the sample rate of the stream in Hertz. + +`DiscovererStreamInfo` specific to container streams. # Implements -[`PlayerStreamInfoExt`](trait.PlayerStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) - +[`DiscovererStreamInfoExt`](trait.DiscovererStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + # Returns -the current bitrate of video in `PlayerVideoInfo`. - -## `fps_n` -Numerator of frame rate -## `fps_d` -Denominator of frame rate - - -# Returns - -the height of video in `PlayerVideoInfo`. - - -# Returns - -the maximum bitrate of video in `PlayerVideoInfo`. - -Returns the pixel aspect ratio in `par_n` and `par_d` -## `par_n` -numerator -## `par_d` -denominator - - -# Returns - -the width of video in `PlayerVideoInfo`. - - +the list of +`DiscovererStreamInfo` this container stream offers. +Free with `DiscovererStreamInfo::list_free` after usage. + +Structure containing the information of a URI analyzed by `Discoverer`. # Implements -[`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`PlayerVideoRendererExt`](trait.PlayerVideoRendererExt.html) - -## `window_handle` -Window handle to use or `None` - -## `window_handle` -Window handle to use or `None` -## `video_sink` -the custom video_sink element to be set for the video renderer +[`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + +Parses a `glib::Variant` as produced by `DiscovererInfo::to_variant` +back to a `DiscovererInfo`. +## `variant` +A `glib::Variant` to deserialize into a `DiscovererInfo`. # Returns - - -Since 1.12 - -Tell an overlay that it has been exposed. This will redraw the current frame -in the drawable even if the pipeline is PAUSED. - -Return the currently configured render rectangle. See `PlayerVideoOverlayVideoRenderer::set_render_rectangle` -for details. -## `x` -the horizontal offset of the render area inside the window -## `y` -the vertical offset of the render area inside the window -## `width` -the width of the render area inside the window -## `height` -the height of the render area inside the window - +A newly-allocated `DiscovererInfo`. + # Returns -The currently set, platform specific window -handle - -Configure a subregion as a video target within the window set by -`PlayerVideoOverlayVideoRenderer::set_window_handle`. If this is not -used or not supported the video will fill the area of the window set as the -overlay to 100%. By specifying the rectangle, the video can be overlaid to -a specific region of that window only. After setting the new rectangle one -should call `PlayerVideoOverlayVideoRenderer::expose` to force a -redraw. To unset the region pass -1 for the `width` and `height` parameters. +A copy of the `DiscovererInfo` + +Finds all the `DiscovererAudioInfo` contained in `self` -This method is needed for non fullscreen video overlay in UI toolkits that -do not support subwindows. -## `x` -the horizontal offset of the render area inside the window -## `y` -the vertical offset of the render area inside the window -## `width` -the width of the render area inside the window -## `height` -the height of the render area inside the window - -Sets the platform specific window handle into which the video -should be rendered -## `window_handle` -handle referencing to the platform specific window - +# Returns +A `glib::List` of +matching `DiscovererStreamInfo`. The caller should free it with +`DiscovererStreamInfo::list_free`. + +Finds all the `DiscovererContainerInfo` contained in `self` + +# Returns + +A `glib::List` of +matching `DiscovererStreamInfo`. The caller should free it with +`DiscovererStreamInfo::list_free`. + + +# Returns + +the duration of the URI in `gst::ClockTime` (nanoseconds). + + +Feature: `v1_14` + + +# Returns + +whether the URI is live. + + +# Deprecated + +This functions is deprecated since version 1.4, use +`DiscovererInfo::get_missing_elements_installer_details` + +# Returns + +Miscellaneous information stored as a `gst::Structure` +(for example: information about missing plugins). If you wish to use the +`gst::Structure` after the life-time of `self`, you will need to copy it. + +Get the installer details for missing elements + +# Returns + +An array of strings +containing informations about how to install the various missing elements +for `self` to be usable. If you wish to use the strings after the life-time +of `self`, you will need to copy them. + + +# Returns + +the result of the discovery as a `DiscovererResult`. + + +# Returns + +the whether the URI is seekable. + + +# Returns + +the structure (or topology) of the URI as a +`DiscovererStreamInfo`. +This structure can be traversed to see the original hierarchy. Unref with +`gst_discoverer_stream_info_unref` after usage. + + +# Returns + +the list of +all streams contained in the `info`. Free after usage +with `DiscovererStreamInfo::list_free`. + +Finds the `DiscovererStreamInfo` contained in `self` that match the +given `streamtype`. +## `streamtype` +a `glib::Type` derived from `DiscovererStreamInfo` + +# Returns + +A `glib::List` of +matching `DiscovererStreamInfo`. The caller should free it with +`DiscovererStreamInfo::list_free`. + +Finds all the `DiscovererSubtitleInfo` contained in `self` + +# Returns + +A `glib::List` of +matching `DiscovererStreamInfo`. The caller should free it with +`DiscovererStreamInfo::list_free`. + + +# Returns + +all tags contained in the URI. If you wish to use +the tags after the life-time of `self`, you will need to copy them. + + +# Returns + +TOC contained in the URI. If you wish to use +the TOC after the life-time of `self`, you will need to copy it. + + +# Returns + +the URI to which this information corresponds to. +Copy it if you wish to use it after the life-time of `self`. + +Finds all the `DiscovererVideoInfo` contained in `self` + +# Returns + +A `glib::List` of +matching `DiscovererStreamInfo`. The caller should free it with +`DiscovererStreamInfo::list_free`. + +Serializes `self` to a `glib::Variant` that can be parsed again +through `DiscovererInfo::from_variant`. + +Note that any `gst::Toc` (s) that might have been discovered will not be serialized +for now. +## `flags` +A combination of `DiscovererSerializeFlags` to specify +what needs to be serialized. + +# Returns + +A newly-allocated `glib::Variant` representing `self`. + +Result values for the discovery process. + +The discovery was successful + +the URI is invalid + +an error happened and the GError is set + +the discovery timed-out + +the discoverer was already discovering a file + +Some plugins are missing for full discovery + +Base structure for information concerning a media stream. Depending on the +stream type, one can find more media-specific information in +`DiscovererAudioInfo`, `DiscovererVideoInfo`, and +`DiscovererContainerInfo`. + +The `DiscovererStreamInfo` represents the topology of the stream. Siblings +can be iterated over with `DiscovererStreamInfoExt::get_next` and +`DiscovererStreamInfoExt::get_previous`. Children (sub-streams) of a +stream can be accessed using the `DiscovererContainerInfo` API. + +As a simple example, if you run `Discoverer` on an AVI file with one audio +and one video stream, you will get a `DiscovererContainerInfo` +corresponding to the AVI container, which in turn will have a +`DiscovererAudioInfo` sub-stream and a `DiscovererVideoInfo` sub-stream +for the audio and video streams respectively. # Implements -[`PlayerVideoRendererExt`](trait.PlayerVideoRendererExt.html) - -Trait containing all `PlayerVideoRenderer` methods. +[`DiscovererStreamInfoExt`](trait.DiscovererStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + +Trait containing all `DiscovererStreamInfo` methods. # Implementors -[`PlayerVideoOverlayVideoRenderer`](struct.PlayerVideoOverlayVideoRenderer.html), [`PlayerVideoRenderer`](struct.PlayerVideoRenderer.html) - -A `PlayerVisualization` descriptor. - -Makes a copy of the `PlayerVisualization`. The result must be -freed using `PlayerVisualization::free`. +[`DiscovererAudioInfo`](struct.DiscovererAudioInfo.html), [`DiscovererContainerInfo`](struct.DiscovererContainerInfo.html), [`DiscovererStreamInfo`](struct.DiscovererStreamInfo.html), [`DiscovererSubtitleInfo`](struct.DiscovererSubtitleInfo.html), [`DiscovererVideoInfo`](struct.DiscovererVideoInfo.html) + +Decrements the reference count of all contained `DiscovererStreamInfo` +and fress the `glib::List`. +## `infos` +a `glib::List` of `DiscovererStreamInfo` + # Returns -an allocated copy of `self`. - -Frees a `PlayerVisualization`. +the `gst::Caps` of the stream. Unref with +`gst_caps_unref` after usage. + + +# Deprecated + +This functions is deprecated since version 1.4, use +`DiscovererInfo::get_missing_elements_installer_details` + +# Returns + +additional information regarding the stream (for +example codec version, profile, etc..). If you wish to use the `gst::Structure` +after the life-time of `self` you will need to copy it. + + +# Returns + +the next `DiscovererStreamInfo` in a chain. `None` +for final streams. +Unref with `gst_discoverer_stream_info_unref` after usage. + + +# Returns + +the previous `DiscovererStreamInfo` in a chain. +`None` for starting points. Unref with `gst_discoverer_stream_info_unref` +after usage. + + +# Returns + +the stream ID of this stream. If you wish to +use the stream ID after the life-time of `self` you will need to copy it. + + +# Returns + +a human readable name for the stream type of the given `self` (ex : "audio", +"container",...). + + +# Returns + +the tags contained in this stream. If you wish to +use the tags after the life-time of `self` you will need to copy them. + + +# Returns + +the TOC contained in this stream. If you wish to +use the TOC after the life-time of `self` you will need to copy it. + +`DiscovererStreamInfo` specific to subtitle streams (this includes text and +image based ones). + +# Implements + +[`DiscovererStreamInfoExt`](trait.DiscovererStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + + +# Returns + +the language of the stream, or NULL if unknown. + +`DiscovererStreamInfo` specific to video streams (this includes images). + +# Implements + +[`DiscovererStreamInfoExt`](trait.DiscovererStreamInfoExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + + +# Returns + +the average or nominal bitrate of the video stream in bits/second. + + +# Returns + +the depth in bits of the video stream. + + +# Returns + +the framerate of the video stream (denominator). + + +# Returns + +the framerate of the video stream (numerator). + + +# Returns + +the height of the video stream in pixels. + + +# Returns + +the maximum bitrate of the video stream in bits/second. + + +# Returns + +the Pixel Aspect Ratio (PAR) of the video stream (denominator). + + +# Returns + +the Pixel Aspect Ratio (PAR) of the video stream (numerator). + + +# Returns + +the width of the video stream in pixels. + + +# Returns + +`true` if the video stream corresponds to an image (i.e. only contains +one frame). + + +# Returns + +`true` if the stream is interlaced, else `false`. + +Variant of `EncodingProfile` for audio streams. + +# Implements + +[`EncodingProfileExt`](trait.EncodingProfileExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + +Creates a new `EncodingAudioProfile` + +All provided allocatable arguments will be internally copied, so can be +safely freed/unreferenced after calling this method. +## `format` +the `gst::Caps` +## `preset` +the preset(s) to use on the encoder, can be `None` +## `restriction` +the `gst::Caps` used to restrict the input to the encoder, can be +NULL. See `EncodingProfileExt::get_restriction` for more details. +## `presence` +the number of time this stream must be used. 0 means any number of + times (including never) + +# Returns + +the newly created `EncodingAudioProfile`. + +Encoding profiles for containers. Keeps track of a list of `EncodingProfile` + +# Implements + +[`EncodingContainerProfileExt`](trait.EncodingContainerProfileExt.html), [`EncodingProfileExt`](trait.EncodingProfileExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + +Trait containing all `EncodingContainerProfile` methods. + +# Implementors + +[`EncodingContainerProfile`](struct.EncodingContainerProfile.html) + +Creates a new `EncodingContainerProfile`. +## `name` +The name of the container profile, can be `None` +## `description` +The description of the container profile, + can be `None` +## `format` +The format to use for this profile +## `preset` +The preset to use for this profile. + +# Returns + +The newly created `EncodingContainerProfile`. + +Add a `EncodingProfile` to the list of profiles handled by `self`. + +No copy of `profile` will be made, if you wish to use it elsewhere after this +method you should increment its reference count. +## `profile` +the `EncodingProfile` to add. + +# Returns + +`true` if the `stream` was properly added, else `false`. + +Checks if `self` contains a `EncodingProfile` identical to +`profile`. +## `profile` +a `EncodingProfile` + +# Returns + +`true` if `self` contains a `EncodingProfile` identical +to `profile`, else `false`. + + +# Returns + + +the list of contained `EncodingProfile`. + +The opaque base class object for all encoding profiles. This contains generic +information like name, description, format and preset. + +# Implements + +[`EncodingProfileExt`](trait.EncodingProfileExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + +Trait containing all `EncodingProfile` methods. + +# Implementors + +[`EncodingAudioProfile`](struct.EncodingAudioProfile.html), [`EncodingContainerProfile`](struct.EncodingContainerProfile.html), [`EncodingProfile`](struct.EncodingProfile.html), [`EncodingVideoProfile`](struct.EncodingVideoProfile.html) + +Find the `EncodingProfile` with the specified name and category. +## `targetname` +The name of the target +## `profilename` +The name of the profile, if `None` +provided, it will default to the encoding profile called `default`. +## `category` +The target category. Can be `None` + +# Returns + +The matching `EncodingProfile` or `None`. + +Creates a `EncodingProfile` matching the formats from the given +`DiscovererInfo`. Streams other than audio or video (eg, +subtitles), are currently ignored. +## `info` +The `DiscovererInfo` to read from + +# Returns + +The new `EncodingProfile` or `None`. + +Makes a deep copy of `self` + +# Returns + +The copy of `self` + +Since 1.12 + +Get whether the format that has been negotiated in at some point can be renegotiated +later during the encoding. + + +# Returns + +the description of the profile, can be `None`. + + +# Returns + +a suitable file extension for `self`, or NULL. + + +# Returns + +the `gst::Caps` corresponding to the media format used +in the profile. Unref after usage. + +Computes the full output caps that this `self` will be able to consume. + +# Returns + +The full caps the given `self` can consume. Call +`gst_caps_unref` when you are done with the caps. + + +# Returns + +the name of the profile, can be `None`. + + +# Returns + +The number of times the profile is used in its parent +container profile. If 0, it is not a mandatory stream. + + +# Returns + +the name of the `gst::Preset` to be used in the profile. +This is the name that has been set when saving the preset. + + +# Returns + +the name of the `gst::Preset` factory to be used in the profile. + + +# Returns + +The restriction `gst::Caps` to apply before the encoder +that will be used in the profile. The fields present in restriction caps are +properties of the raw stream (that is before encoding), such as height and +width for video and depth and sampling rate for audio. Does not apply to +`EncodingContainerProfile` (since there is no corresponding raw stream). +Can be `None`. Unref after usage. + + +# Returns + +the human-readable name of the type of `self`. + +Checks whether the two `EncodingProfile` are equal +## `b` +a `EncodingProfile` + +# Returns + +`true` if `self` and `b` are equal, else `false`. + +Sets whether the format that has been negotiated in at some point can be renegotiated +later during the encoding. +## `allow_dynamic_output` +Whether the format that has been negotiated first can be renegotiated +during the encoding + +Set `description` as the given description for the `self`. A copy of +`description` will be made internally. +## `description` +the description to set on the profile + +Set whether the profile should be used or not. + +Since 1.6 +## `enabled` +`false` to disable `profile`, `true` to enable it + +Sets the media format used in the profile. +## `format` +the media format to use in the profile. + +Set `name` as the given name for the `self`. A copy of `name` will be made +internally. +## `name` +the name to set on the profile + +Set the number of time the profile is used in its parent +container profile. If 0, it is not a mandatory stream +## `presence` +the number of time the profile can be used + +Sets the name of the `gst::Element` that implements the `gst::Preset` interface +to use for the profile. +This is the name that has been set when saving the preset. +## `preset` +the element preset to use + +Sets the name of the `gst::Preset`'s factory to be used in the profile. +## `preset_name` +The name of the preset to use in this `self`. + +Set the restriction `gst::Caps` to apply before the encoder +that will be used in the profile. See `EncodingProfileExt::get_restriction` +for more about restrictions. Does not apply to `EncodingContainerProfile`. +## `restriction` +the restriction to apply + +Collection of `EncodingProfile` for a specific target or use-case. + +When being stored/loaded, targets come from a specific category, like +`GST_ENCODING_CATEGORY_DEVICE`. + +# Implements + +[`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + +Creates a new `EncodingTarget`. + +The name and category can only consist of lowercase ASCII letters for the +first character, followed by either lowercase ASCII letters, digits or +hyphens ('-'). + +The `category` ``should`` be one of the existing +well-defined categories, like `GST_ENCODING_CATEGORY_DEVICE`, but it +``can`` be a application or user specific category if +needed. +## `name` +The name of the target. +## `category` +The name of the category to which this `target` +belongs. For example: `GST_ENCODING_CATEGORY_DEVICE`. +## `description` +A description of `EncodingTarget` in the +current locale. +## `profiles` +A `glib::List` of +`EncodingProfile`. + +# Returns + +The newly created `EncodingTarget` or `None` if +there was an error. + +Searches for the `EncodingTarget` with the given name, loads it +and returns it. + +If the category name is specified only targets from that category will be +searched for. +## `name` +the name of the `EncodingTarget` to load (automatically +converted to lower case internally as capital letters are not +valid for target names). +## `category` +the name of the target category, like +`GST_ENCODING_CATEGORY_DEVICE`. Can be `None` + +# Returns + +The `EncodingTarget` if available, else `None`. + +Opens the provided file and returns the contained `EncodingTarget`. +## `filepath` +The file location to load the `EncodingTarget` from + +# Returns + +The `EncodingTarget` contained in the file, else +`None` + +Adds the given `profile` to the `self`. Each added profile must have +a unique name within the profile. + +The `self` will steal a reference to the `profile`. If you wish to use +the profile after calling this method, you should increase its reference +count. +## `profile` +the `EncodingProfile` to add + +# Returns + +`true` if the profile was added, else `false`. + + +# Returns + +The category of the `self`. For example: +`GST_ENCODING_CATEGORY_DEVICE`. + + +# Returns + +The description of the `self`. + + +# Returns + +The name of the `self`. + +## `name` +the name of the profile to retrieve + +# Returns + +The matching `EncodingProfile`, or `None`. + + +# Returns + +A list of +`EncodingProfile`(s) this `self` handles. + +Saves the `self` to a default user-local directory. + +# Returns + +`true` if the target was correctly saved, else `false`. + +Saves the `self` to the provided file location. +## `filepath` +the location to store the `self` at. + +# Returns + +`true` if the target was correctly saved, else `false`. + +Variant of `EncodingProfile` for video streams, allows specifying the `pass`. + +# Implements + +[`EncodingProfileExt`](trait.EncodingProfileExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html) + +Creates a new `EncodingVideoProfile` + +All provided allocatable arguments will be internally copied, so can be +safely freed/unreferenced after calling this method. + +If you wish to control the pass number (in case of multi-pass scenarios), +please refer to the `EncodingVideoProfile::set_pass` documentation. + +If you wish to use/force a constant framerate please refer to the +`EncodingVideoProfile::set_variableframerate` documentation. +## `format` +the `gst::Caps` +## `preset` +the preset(s) to use on the encoder, can be `None` +## `restriction` +the `gst::Caps` used to restrict the input to the encoder, can be +NULL. See `EncodingProfileExt::get_restriction` for more details. +## `presence` +the number of time this stream must be used. 0 means any number of + times (including never) + +# Returns + +the newly created `EncodingVideoProfile`. + +Get the pass number if this is part of a multi-pass profile. + +# Returns + +The pass number. Starts at 1 for multi-pass. 0 if this is +not a multi-pass profile + + +# Returns + +Whether non-constant video framerate is allowed for encoding. + +Sets the pass number of this video profile. The first pass profile should have +this value set to 1. If this video profile isn't part of a multi-pass profile, +you may set it to 0 (the default value). +## `pass` +the pass number for this profile + +If set to `true`, then the incoming stream will be allowed to have non-constant +framerate. If set to `false` (default value), then the incoming stream will +be normalized by dropping/duplicating frames in order to produce a +constance framerate. +## `variableframerate` +a boolean diff --git a/docs/gstreamer-video/docs.md b/docs/gstreamer-video/docs.md index c9d9d9c78..641690bf0 100644 --- a/docs/gstreamer-video/docs.md +++ b/docs/gstreamer-video/docs.md @@ -941,6 +941,307 @@ Every four adjacent blocks - two horizontally and two vertically are grouped together and are located in memory in Z or flipped Z order. In case of odd rows, the last row of blocks is arranged in linear order. + +`field_count` must be 0 for progressive video and 1 or 2 for interlaced. + +A representation of a SMPTE time code. + +`hours` must be positive and less than 24. Will wrap around otherwise. +`minutes` and `seconds` must be positive and less than 60. +`frames` must be less than or equal to `config.fps_n` / `config.fps_d` +These values are *NOT* automatically normalized. + +Feature: `v1_10` + +`field_count` is 0 for progressive, 1 or 2 for interlaced. +`latest_daiy_jam` reference is stolen from caller. + +Feature: `v1_10` + +## `fps_n` +Numerator of the frame rate +## `fps_d` +Denominator of the frame rate +## `latest_daily_jam` +The latest daily jam of the `VideoTimeCode` +## `flags` +`VideoTimeCodeFlags` +## `hours` +the hours field of `VideoTimeCode` +## `minutes` +the minutes field of `VideoTimeCode` +## `seconds` +the seconds field of `VideoTimeCode` +## `frames` +the frames field of `VideoTimeCode` +## `field_count` +Interlaced video field count + +# Returns + +a new `VideoTimeCode` with the given values. +The values are not checked for being in a valid range. To see if your +timecode actually has valid content, use `VideoTimeCode::is_valid`. + + +Feature: `v1_10` + + +# Returns + +a new empty `VideoTimeCode` + +The resulting config->latest_daily_jam is set to +midnight, and timecode is set to the given time. + +Feature: `v1_12` + +## `fps_n` +Numerator of the frame rate +## `fps_d` +Denominator of the frame rate +## `dt` +`glib::DateTime` to convert +## `flags` +`VideoTimeCodeFlags` +## `field_count` +Interlaced video field count + +# Returns + +the `GVideoTimeCode` representation of `dt`. + + +Feature: `v1_12` + +## `tc_str` +The string that represents the `VideoTimeCode` + +# Returns + +a new `VideoTimeCode` from the given string + +Adds or subtracts `frames` amount of frames to `self`. tc needs to +contain valid data, as verified by `VideoTimeCode::is_valid`. + +Feature: `v1_10` + +## `frames` +How many frames to add or subtract + +This makes a component-wise addition of `tc_inter` to `self`. For example, +adding ("01:02:03:04", "00:01:00:00") will return "01:03:03:04". +When it comes to drop-frame timecodes, +adding ("00:00:00;00", "00:01:00:00") will return "00:01:00;02" +because of drop-frame oddities. However, +adding ("00:09:00;02", "00:01:00:00") will return "00:10:00;00" +because this time we can have an exact minute. + +Feature: `v1_12` + +## `tc_inter` +The `VideoTimeCodeInterval` to add to `self`. +The interval must contain valid values, except that for drop-frame +timecode, it may also contain timecodes which would normally +be dropped. These are then corrected to the next reasonable timecode. + +# Returns + +A new `VideoTimeCode` with `tc_inter` added. + +Initializes `self` with empty/zero/NULL values. + +Feature: `v1_10` + + +Compares `self` and `tc2` . If both have latest daily jam information, it is +taken into account. Otherwise, it is assumed that the daily jam of both +`self` and `tc2` was at the same time. Both time codes must be valid. + +Feature: `v1_10` + +## `tc2` +another `VideoTimeCode` + +# Returns + +1 if `self` is after `tc2`, -1 if `self` is before `tc2`, 0 otherwise. + + +Feature: `v1_10` + + +# Returns + +a new `VideoTimeCode` with the same values as `self` . + + +Feature: `v1_10` + + +# Returns + +how many frames have passed since the daily jam of `self` . + +Frees `self` . + +Feature: `v1_10` + + +Adds one frame to `self` . + +Feature: `v1_10` + + +`field_count` is 0 for progressive, 1 or 2 for interlaced. +`latest_daiy_jam` reference is stolen from caller. + +Initializes `self` with the given values. +The values are not checked for being in a valid range. To see if your +timecode actually has valid content, use `VideoTimeCode::is_valid`. + +Feature: `v1_10` + +## `fps_n` +Numerator of the frame rate +## `fps_d` +Denominator of the frame rate +## `latest_daily_jam` +The latest daily jam of the `VideoTimeCode` +## `flags` +`VideoTimeCodeFlags` +## `hours` +the hours field of `VideoTimeCode` +## `minutes` +the minutes field of `VideoTimeCode` +## `seconds` +the seconds field of `VideoTimeCode` +## `frames` +the frames field of `VideoTimeCode` +## `field_count` +Interlaced video field count + +The resulting config->latest_daily_jam is set to +midnight, and timecode is set to the given time. + +Feature: `v1_12` + +## `fps_n` +Numerator of the frame rate +## `fps_d` +Denominator of the frame rate +## `dt` +`glib::DateTime` to convert +## `flags` +`VideoTimeCodeFlags` +## `field_count` +Interlaced video field count + + +Feature: `v1_10` + + +# Returns + +whether `self` is a valid timecode (supported frame rate, +hours/minutes/seconds/frames not overflowing) + + +Feature: `v1_10` + + +# Returns + +how many nsec have passed since the daily jam of `self` . + +The `self.config`->latest_daily_jam is required to be non-NULL. + +Feature: `v1_10` + + +# Returns + +the `glib::DateTime` representation of `self`. + + +Feature: `v1_10` + + +# Returns + +the SMPTE ST 2059-1:2015 string representation of `self`. That will +take the form hh:mm:ss:ff . The last separator (between seconds and frames) +may vary: + +';' for drop-frame, non-interlaced content and for drop-frame interlaced +field 2 +',' for drop-frame interlaced field 1 +':' for non-drop-frame, non-interlaced content and for non-drop-frame +interlaced field 2 +'.' for non-drop-frame interlaced field 1 + +A representation of a difference between two `VideoTimeCode` instances. +Will not necessarily correspond to a real timecode (e.g. 00:00:10;00) + +Feature: `v1_12` + + +Feature: `v1_12` + +## `hours` +the hours field of `VideoTimeCodeInterval` +## `minutes` +the minutes field of `VideoTimeCodeInterval` +## `seconds` +the seconds field of `VideoTimeCodeInterval` +## `frames` +the frames field of `VideoTimeCodeInterval` + +# Returns + +a new `VideoTimeCodeInterval` with the given values. + +`tc_inter_str` must only have ":" as separators. + +Feature: `v1_12` + +## `tc_inter_str` +The string that represents the `VideoTimeCodeInterval` + +# Returns + +a new `VideoTimeCodeInterval` from the given string + +Initializes `self` with empty/zero/NULL values. + +Feature: `v1_12` + + + +Feature: `v1_12` + + +# Returns + +a new `VideoTimeCodeInterval` with the same values as `self` . + +Frees `self` . + +Feature: `v1_12` + + +Initializes `self` with the given values. + +Feature: `v1_12` + +## `hours` +the hours field of `VideoTimeCodeInterval` +## `minutes` +the minutes field of `VideoTimeCodeInterval` +## `seconds` +the seconds field of `VideoTimeCodeInterval` +## `frames` +the frames field of `VideoTimeCodeInterval` The video transfer function defines the formula for converting between non-linear RGB (R'G'B') and linear RGB diff --git a/docs/gstreamer/docs.md b/docs/gstreamer/docs.md index aeed3252b..294385d59 100644 --- a/docs/gstreamer/docs.md +++ b/docs/gstreamer/docs.md @@ -11,15 +11,15 @@ want to create a toplevel bin because a normal bin doesn't have a bus or handle clock distribution of its own. After the bin has been created you will typically add elements to it with -`BinExt::add`. You can remove elements with `BinExt::remove`. +`GstBinExt::add`. You can remove elements with `GstBinExt::remove`. -An element can be retrieved from a bin with `BinExt::get_by_name`, using the -elements name. `BinExt::get_by_name_recurse_up` is mainly used for internal +An element can be retrieved from a bin with `GstBinExt::get_by_name`, using the +elements name. `GstBinExt::get_by_name_recurse_up` is mainly used for internal purposes and will query the parent bins when the element is not found in the current bin. An iterator of elements in a bin can be retrieved with -`BinExt::iterate_elements`. Various other iterators exist to retrieve the +`GstBinExt::iterate_elements`. Various other iterators exist to retrieve the elements in a bin. `GstObjectExt::unref` is used to drop your reference to the bin. @@ -99,8 +99,8 @@ handler will return `true`. # Implements -[`BinExt`](trait.BinExt.html), [`ElementExt`](trait.ElementExt.html), [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`ChildProxyExt`](trait.ChildProxyExt.html) - +[`GstBinExt`](trait.GstBinExt.html), [`ElementExt`](trait.ElementExt.html), [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`ChildProxyExt`](trait.ChildProxyExt.html) + Trait containing all `Bin` methods. # Implementors @@ -114,7 +114,7 @@ the name of the new bin # Returns a new `Bin` - + Adds the given element to the bin. Sets the element's parent, and thus takes ownership of the element. An element can only be added to one bin. @@ -124,7 +124,7 @@ before the element is added to the bin. > When you add an element to an already-running pipeline, you will have to > take care to set the state of the newly-added element to the desired > state (usually PLAYING or PAUSED, same you set the pipeline to originally) -> with `ElementExt::set_state`, or use `ElementExt::sync_state_with_parent`. +> with `Element::set_state`, or use `ElementExt::sync_state_with_parent`. > The bin or pipeline will not take care of this for you. MT safe. @@ -135,13 +135,13 @@ the `Element` to add `true` if the element could be added, `false` if the bin does not want to accept the element. - + Adds a `None`-terminated list of elements to a bin. This function is -equivalent to calling `BinExt::add` for each member of the list. The return -value of each `BinExt::add` is ignored. +equivalent to calling `GstBinExt::add` for each member of the list. The return +value of each `GstBinExt::add` is ignored. ## `element_1` the `Element` element to add to the bin - + Recursively looks for elements with an unlinked pad of the given direction within the specified bin and returns an unlinked pad if one is found, or `None` otherwise. If a pad is found, the caller @@ -154,12 +154,12 @@ whether to look for an unlinked source or sink pad unlinked pad of the given direction, `None`. - + Looks for an element inside the bin that implements the given interface. If such an element is found, it returns the element. You can cast this element to the given interface afterwards. If you want all elements that implement the interface, use -`BinExt::iterate_all_by_interface`. This function recurses into child bins. +`GstBinExt::iterate_all_by_interface`. This function recurses into child bins. MT safe. Caller owns returned reference. ## `iface` @@ -169,7 +169,7 @@ the `glib::Type` of an interface A `Element` inside the bin implementing the interface - + Gets the element with the given name from a bin. This function recurses into child bins. @@ -183,7 +183,7 @@ the element name to search for the `Element` with the given name, or `None` - + Gets the element with the given name from this bin. If the element is not found, a recursion is performed on the parent bin. @@ -198,7 +198,7 @@ the element name to search for the `Element` with the given name, or `None` - + Return the suppressed flags of the bin. MT safe. @@ -209,7 +209,7 @@ Feature: `v1_10` # Returns the bin's suppressed `ElementFlags`. - + Looks for all elements inside the bin that implements the given interface. You can safely cast all returned elements to the given interface. The function recurses inside child bins. The iterator will yield a series @@ -224,7 +224,7 @@ the `glib::Type` of an interface a `Iterator` of `Element` for all elements in the bin implementing the given interface, or `None` - + Gets an iterator for the elements in this bin. MT safe. Caller owns returned value. @@ -233,7 +233,7 @@ MT safe. Caller owns returned value. a `Iterator` of `Element`, or `None` - + Gets an iterator for the elements in this bin. This iterator recurses into GstBin children. @@ -243,7 +243,7 @@ MT safe. Caller owns returned value. a `Iterator` of `Element`, or `None` - + Gets an iterator for all elements in the bin that have the `ElementFlags::Sink` flag set. @@ -253,7 +253,7 @@ MT safe. Caller owns returned value. a `Iterator` of `Element`, or `None` - + Gets an iterator for the elements in this bin in topologically sorted order. This means that the elements are returned from the most downstream elements (sinks) to the sources. @@ -267,7 +267,7 @@ MT safe. Caller owns returned value. a `Iterator` of `Element`, or `None` - + Gets an iterator for all elements in the bin that have the `ElementFlags::Source` flag set. @@ -277,7 +277,7 @@ MT safe. Caller owns returned value. a `Iterator` of `Element`, or `None` - + Query `self` for the current latency using and reconfigures this latency to all the elements with a LATENCY event. @@ -290,7 +290,7 @@ calculations will be performed. # Returns `true` if the latency could be queried and reconfigured. - + Removes the element from the bin, unparenting it as well. Unparenting the element means that the element will be dereferenced, so if the bin holds the only reference to the element, the element @@ -309,12 +309,12 @@ the `Element` to remove `true` if the element could be removed, `false` if the bin does not want to remove the element. - + Remove a list of elements from a bin. This function is equivalent -to calling `BinExt::remove` with each member of the list. +to calling `GstBinExt::remove` with each member of the list. ## `element_1` the first `Element` to remove from the bin - + Suppress the given flags on the bin. `ElementFlags` of a child element are propagated when it is added to the bin. When suppressed flags are set, those specified flags will @@ -326,7 +326,7 @@ Feature: `v1_10` ## `flags` the `ElementFlags` to suppress - + Synchronizes the state of every child of `self` with the state of `self`. See also `ElementExt::sync_state_with_parent`. @@ -334,7 +334,7 @@ of `self`. See also `ElementExt::sync_state_with_parent`. `true` if syncing the state was successful for all children, otherwise `false`. - + Will be emitted after the element was added to sub_bin. Feature: `v1_10` @@ -343,7 +343,7 @@ Feature: `v1_10` the `Bin` the element was added to ## `element` the `Element` that was added to `sub_bin` - + Will be emitted after the element was removed from sub_bin. Feature: `v1_10` @@ -352,7 +352,7 @@ Feature: `v1_10` the `Bin` the element was removed from ## `element` the `Element` that was removed from `sub_bin` - + Will be emitted when the bin needs to perform latency calculations. This signal is only emitted for toplevel bins or when async-handling is enabled. @@ -364,23 +364,23 @@ possible latency to all sinks. Connect to this signal if the default latency calculations are not sufficient, like when you need different latencies for different sinks in the same pipeline. - + Will be emitted after the element was added to the bin. ## `element` the `Element` that was added to the bin - + Will be emitted after the element was removed from the bin. ## `element` the `Element` that was removed from the bin - + If set to `true`, the bin will handle asynchronous state changes. This should be used only if the bin subclass is modifying the state of its children on its own. - + If set to `true`, the bin will handle asynchronous state changes. This should be used only if the bin subclass is modifying the state of its children on its own. - + Forward all children messages, even those that would normally be filtered by the bin. This can be interesting when one wants to be notified of the EOS state of individual elements, for example. @@ -389,7 +389,7 @@ The messages are converted to an ELEMENT message with the bin as the source. The structure of the message is named 'GstBinForwarded' and contains a field named 'message' of type GST_TYPE_MESSAGE that contains the original forwarded message. - + Forward all children messages, even those that would normally be filtered by the bin. This can be interesting when one wants to be notified of the EOS state of individual elements, for example. @@ -3887,7 +3887,7 @@ providers. `true` when all devices will be shown. Removes a filter from the `DeviceMonitor` using the id that was returned -by `DeviceMonitorExt::add_filter`. +by `DeviceMonitor::add_filter`. ## `filter_id` the id of the filter @@ -4165,7 +4165,7 @@ For finer control, use `ElementExt::link_pads` and each element by name. Each element has a state (see `State`). You can get and set the state -of an element with `ElementExt::get_state` and `ElementExt::set_state`. +of an element with `Element::get_state` and `Element::set_state`. Setting a state triggers a `StateChange`. To get a string representation of a `State`, use `Element::state_get_name`. @@ -4298,7 +4298,7 @@ a watch id, which can be used in connection with Calls `func` from another thread and passes `user_data` to it. This is to be used for cases when a state change has to be performed from a streaming -thread, directly via `ElementExt::set_state` or indirectly e.g. via SEEK +thread, directly via `Element::set_state` or indirectly e.g. via SEEK events. Calling those functions directly from the streaming thread will cause @@ -4570,7 +4570,7 @@ the start time of the element. Gets the state of the element. For elements that performed an ASYNC state change, as reported by -`ElementExt::set_state`, this function will block up to the +`Element::set_state`, this function will block up to the specified timeout value for the state change to complete. If the element completes the state change or goes into an error, this function returns immediately with a return value of @@ -4672,7 +4672,7 @@ Such pads need to be released manually when unlinking. If multiple links are possible, only one is established. Make sure you have added your elements to a bin or pipeline with -`BinExt::add` before trying to link them. +`GstBinExt::add` before trying to link them. ## `dest` the `Element` containing the destination pad. @@ -4687,7 +4687,7 @@ existing pads that aren't linked yet. It will request new pads if necessary. If multiple links are possible, only one is established. Make sure you have added your elements to a bin or pipeline with -`BinExt::add` before trying to link them. +`GstBinExt::add` before trying to link them. ## `dest` the `Element` containing the destination pad. ## `filter` @@ -4700,7 +4700,7 @@ the `Caps` to filter the link, Chain together a series of elements. Uses `ElementExt::link`. Make sure you have added your elements to a bin or pipeline with -`BinExt::add` before trying to link them. +`GstBinExt::add` before trying to link them. ## `element_2` the second `Element` in the link chain. @@ -4754,7 +4754,7 @@ Calling `ElementExt::link_pads_full` with `flags` == `PadLinkCheck::Default` is the same as calling `ElementExt::link_pads` and the recommended way of linking pads with safety checks applied. -This is a convenience function for `PadExt::link_full`. +This is a convenience function for `Pad::link_full`. ## `srcpadname` the name of the `Pad` in source element or `None` for any pad. @@ -4772,7 +4772,7 @@ the `PadLinkCheck` to be performed when linking pads. Brings the element to the lost state. The current state of the element is copied to the pending state so that any call to -`ElementExt::get_state` will return `StateChangeReturn::Async`. +`Element::get_state` will return `StateChangeReturn::Async`. An ASYNC_START message is posted. If the element was PLAYING, it will go to PAUSED. The element will be restored to its PLAYING state by @@ -5144,7 +5144,7 @@ the class's state change function for each. This function can return `StateChangeReturn::Async`, in which case the element will perform the remainder of the state change asynchronously in another thread. -An application can use `ElementExt::get_state` to wait for the completion +An application can use `Element::get_state` to wait for the completion of the state change or it can wait for a `MessageType::AsyncDone` or `MessageType::StateChanged` on the bus. @@ -5198,7 +5198,7 @@ a new `Pad` has been added to the element. Note that this signal will usually be emitted from the context of the streaming thread. Also keep in mind that if you add new elements to the pipeline in the signal handler you will need to set them to the desired target state with -`ElementExt::set_state` or `ElementExt::sync_state_with_parent`. +`Element::set_state` or `ElementExt::sync_state_with_parent`. ## `new_pad` the pad that has been added @@ -7883,7 +7883,7 @@ found under the same name in the base class of `Object` which is `gobject::Objec (e.g. `gobject::ObjectExt::ref` becomes `GstObjectExt::ref`). Since `Object` derives from `gobject::InitiallyUnowned`, it also inherits the -floating reference. Be aware that functions such as `BinExt::add` and +floating reference. Be aware that functions such as `GstBinExt::add` and `ElementExt::add_pad` take ownership of the floating reference. In contrast to `gobject::Object` instances, `Object` adds a name property. The functions @@ -8332,7 +8332,7 @@ dataflow on the pads. `gst_pad_get_parent` will retrieve the `Element` that owns the pad. After two pads are retrieved from an element by `ElementExt::get_static_pad`, -the pads can be linked with `PadExt::link`. (For quick links, +the pads can be linked with `Pad::link`. (For quick links, you can also use `ElementExt::link`, which will make the obvious link for you if it's straightforward.). Pads can be unlinked again with `PadExt::unlink`. `PadExt::get_peer` can be used to check what the pad is @@ -8347,7 +8347,7 @@ properties of the pad and the stream. To send a `Event` on a pad, use `Pad::send_event` and `Pad::push_event`. Some events will be sticky on the pad, meaning that after they pass on the pad they can be queried later with -`PadExt::get_sticky_event` and `PadExt::sticky_events_foreach`. +`PadExt::get_sticky_event` and `Pad::sticky_events_foreach`. `PadExt::get_current_caps` and `PadExt::has_current_caps` are convenience functions to query the current sticky CAPS event on a pad. @@ -8355,7 +8355,7 @@ GstElements will use `Pad::push` and `Pad::pull_range` to push out or pull in a buffer. The dataflow, events and queries that happen on a pad can be monitored with -probes that can be installed with `PadExt::add_probe`. `PadExt::is_blocked` +probes that can be installed with `Pad::add_probe`. `PadExt::is_blocked` can be used to check if a block probe is installed on the pad. `PadExt::is_blocking` checks if the blocking probe is currently blocking the pad. `Pad::remove_probe` is used to remove a previously installed probe @@ -8366,7 +8366,7 @@ offset will be applied to the running_time of all data passing over the pad. `PadExt::set_offset` can be used to change the offset. Convenience functions exist to start, pause and stop the task on a pad with -`PadExt::start_task`, `PadExt::pause_task` and `PadExt::stop_task` +`Pad::start_task`, `PadExt::pause_task` and `PadExt::stop_task` respectively. # Implements @@ -8390,8 +8390,7 @@ the `PadDirection` of the pad. # Returns -a new `Pad`, or `None` in -case of an error. +a new `Pad`. MT safe. @@ -8406,8 +8405,7 @@ the name of the pad # Returns -a new `Pad`, or `None` in -case of an error. +a new `Pad`. Creates a new pad with the given name from the given template. If name is `None`, a guaranteed unique name (across all pads) @@ -8420,8 +8418,7 @@ the name of the pad # Returns -a new `Pad`, or `None` in -case of an error. +a new `Pad`. Gets a string representing the given pad-link return. ## `ret` @@ -8452,7 +8449,7 @@ every state that matches `mask`. Probes are called in groups: First GST_PAD_PROBE_TYPE_BLOCK probes are called, then others, then finally GST_PAD_PROBE_TYPE_IDLE. The only exception here are GST_PAD_PROBE_TYPE_IDLE probes that are called -immediately if the pad is already idle while calling `PadExt::add_probe`. +immediately if the pad is already idle while calling `Pad::add_probe`. In each of the groups, probes are called in the order in which they were added. ## `mask` @@ -8899,7 +8896,7 @@ MT Safe. Links the source pad and the sink pad. -This variant of `PadExt::link` provides a more granular control on the +This variant of `Pad::link` provides a more granular control on the checks being done when linking. While providing some considerable speedups the caller of this method must be aware that wrong usage of those flags can cause severe issues. Refer to the documentation of `PadLinkCheck` @@ -9803,7 +9800,7 @@ the pipeline, use `GstObjectExt::unref` to free its resources including all added `Element` objects (if not otherwise referenced). Elements are added and removed from the pipeline using the `Bin` -methods like `BinExt::add` and `BinExt::remove` (see `Bin`). +methods like `GstBinExt::add` and `GstBinExt::remove` (see `Bin`). Before changing the state of the `Pipeline` (see `Element`) a `Bus` can be retrieved with `Pipeline::get_bus`. This bus can then be @@ -9818,7 +9815,7 @@ When the `Pipeline` performs the PAUSED to PLAYING state change it will select a clock for the elements. The clock selection algorithm will by default select a clock provided by an element that is most upstream (closest to the source). For live pipelines (ones that return -`StateChangeReturn::NoPreroll` from the `ElementExt::set_state` call) this +`StateChangeReturn::NoPreroll` from the `Element::set_state` call) this will select the clock provided by the live source. For normal pipelines this will select a clock provided by the sinks (most likely the audio sink). If no element provides a clock, a default `SystemClock` is used. @@ -9841,7 +9838,7 @@ in the PLAYING state. This default behaviour can be changed with the # Implements -[`PipelineExt`](trait.PipelineExt.html), [`BinExt`](trait.BinExt.html), [`ElementExt`](trait.ElementExt.html), [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`ChildProxyExt`](trait.ChildProxyExt.html) +[`PipelineExt`](trait.PipelineExt.html), [`GstBinExt`](trait.GstBinExt.html), [`ElementExt`](trait.ElementExt.html), [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`ChildProxyExt`](trait.ChildProxyExt.html) Trait containing all `Pipeline` methods. @@ -12330,7 +12327,7 @@ result stream-time a 1 or -1 on success, 0 on failure. The possible states an element can be in. States can be changed using -`ElementExt::set_state` and checked using `ElementExt::get_state`. +`Element::set_state` and checked using `Element::get_state`. no pending state. @@ -12422,7 +12419,7 @@ they should make sure to go back to real 'PAUSED' state (prerolling for example) state change from PLAYING to PLAYING. (Since 1.14) The possible return values from a state change function such as -`ElementExt::set_state`. Only `StateChangeReturn::Failure` is a real failure. +`Element::set_state`. Only `StateChangeReturn::Failure` is a real failure. the state change failed @@ -13595,6 +13592,18 @@ clock. MT safe. ## `new_clock` a `Clock` + +Extra tag flags used when registering tags. + +undefined flag + +tag is meta data + +tag is encoded + +tag is decoded + +number of tag flags List of tags and values used to describe media metadata.