A baseclass for scopes (visualizers). It takes care of re-fitting the audio-rate to video-rate and handles renegotiation (downstream video size changes). It also provides several background shading effects. These effects are applied to a previous picture before the `render()` implementation can draw a new frame. Different types of supported background shading functions. no shading plain fading fade and move up fade and move down fade and move left fade and move right fade and move horizontally out fade and move horizontally in fade and move vertically out fade and move vertically in The #GstDiscoverer 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. The blocking mode just requires calling gst_discoverer_discover_uri() with the URI one wishes to discover. The non-blocking mode requires a running #GMainLoop iterating a #GMainContext, where one connects to the various signals, appends the URIs to be processed (through gst_discoverer_discover_uri_async()) and then asks for the discovery to begin (through gst_discoverer_start()). By default this will use the GLib default main context unless you have set a custom context using g_main_context_push_thread_default(). All the information is returned in a #GstDiscovererInfo structure. Creates a new #GstDiscoverer with the provided timeout. The new #GstDiscoverer. If an error occurred when creating the discoverer, @err will be set accordingly and %NULL will be returned. If @err is set, the caller must free it when no longer needed using g_error_free(). timeout per file, in nanoseconds. Allowed are values between one second (#GST_SECOND) and one hour (3600 * #GST_SECOND) Loads the serialized info from the given uri. the #GstDiscovererInfo or %NULL if it could not be loaded the #GstDiscoverer the uri to load the info from Synchronously discovers the given @uri. A copy of @uri will be made internally, so the caller can safely g_free() afterwards. the result of the scanning. Can be %NULL if an error occurred. A #GstDiscoverer The URI to run on. Appends the given @uri to the list of URIs to discoverer. The actual discovery of the @uri will only take place if gst_discoverer_start() has been called. A copy of @uri will be made internally, so the caller can safely g_free() afterwards. %TRUE if the @uri was successfully appended to the list of pending uris, else %FALSE A #GstDiscoverer the URI to add. Allow asynchronous discovering of URIs to take place. A #GMainLoop must be available for #GstDiscoverer to properly work in asynchronous mode. A #GstDiscoverer Stop the discovery of any pending URIs and clears the list of pending URIS (if any). A #GstDiscoverer The duration (in nanoseconds) after which the discovery of an individual URI will timeout. If the discovery of a URI times out, the %GST_DISCOVERER_TIMEOUT will be set on the result flags. Will be emitted in async mode when all information on a URI could be discovered, or an error occurred. When an error occurs, @info might still contain some partial information, depending on the circumstances of the error. the results #GstDiscovererInfo #GError, which will be non-NULL if an error occurred during discovery. You must not free this #GError, it will be freed by the discoverer. Will be emitted in async mode when all pending URIs have been processed. Retrieves information about a URI from and external source of information, like a cache file. This is used by the discoverer to speed up the discovery. The #GstDiscovererInfo representing @uri, or %NULL if no information THe URI to load the serialized info for 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). This signal is usually emitted from the context of a GStreamer streaming thread. source element Will be emitted when the discover starts analyzing the pending URIs #GstDiscovererStreamInfo specific to audio streams. the average or nominal bitrate of the stream in bits/second. a #GstDiscovererAudioInfo the channel-mask of the stream, refer to gst_audio_channel_positions_from_mask() for more information. a #GstDiscovererAudioInfo the number of channels in the stream. a #GstDiscovererAudioInfo the number of bits used per sample in each channel. a #GstDiscovererAudioInfo the language of the stream, or NULL if unknown. a #GstDiscovererAudioInfo the maximum bitrate of the stream in bits/second. a #GstDiscovererAudioInfo the sample rate of the stream in Hertz. a #GstDiscovererAudioInfo the #GstDiscovererInfo or %NULL if it could not be loaded the #GstDiscoverer the uri to load the info from #GstDiscovererStreamInfo specific to container streams. the list of #GstDiscovererStreamInfo this container stream offers. Free with gst_discoverer_stream_info_list_free() after usage. a #GstDiscovererStreamInfo tags specific to the given container. If you wish to use the tags after the life-time of @info, you will need to copy them. a #GstDiscovererStreamInfo Structure containing the information of a URI analyzed by #GstDiscoverer. Parses a #GVariant as produced by gst_discoverer_info_to_variant() back to a #GstDiscovererInfo. A newly-allocated #GstDiscovererInfo. A #GVariant to deserialize into a #GstDiscovererInfo. A copy of the #GstDiscovererInfo a #GstDiscovererInfo Finds all the #GstDiscovererAudioInfo contained in @info A #GList of matching #GstDiscovererStreamInfo. The caller should free it with gst_discoverer_stream_info_list_free(). a #GstDiscovererInfo Finds all the #GstDiscovererContainerInfo contained in @info A #GList of matching #GstDiscovererStreamInfo. The caller should free it with gst_discoverer_stream_info_list_free(). a #GstDiscovererInfo the duration of the URI in #GstClockTime (nanoseconds). a #GstDiscovererInfo whether the URI is live. a #GstDiscovererInfo This functions is deprecated since version 1.4, use #gst_discoverer_info_get_missing_elements_installer_details Miscellaneous information stored as a #GstStructure (for example: information about missing plugins). If you wish to use the #GstStructure after the life-time of @info, you will need to copy it. a #GstDiscovererInfo Get the installer details for missing elements An array of strings containing information about how to install the various missing elements for @info to be usable. If you wish to use the strings after the life-time of @info, you will need to copy them. a #GstDiscovererStreamInfo to retrieve installer detail for the missing element the result of the discovery as a #GstDiscovererResult. a #GstDiscovererInfo the whether the URI is seekable. a #GstDiscovererInfo the structure (or topology) of the URI as a #GstDiscovererStreamInfo. This structure can be traversed to see the original hierarchy. Unref with gst_discoverer_stream_info_unref() after usage. a #GstDiscovererInfo the list of all streams contained in the #info. Free after usage with gst_discoverer_stream_info_list_free(). a #GstDiscovererInfo Finds the #GstDiscovererStreamInfo contained in @info that match the given @streamtype. A #GList of matching #GstDiscovererStreamInfo. The caller should free it with gst_discoverer_stream_info_list_free(). a #GstDiscovererInfo a #GType derived from #GstDiscovererStreamInfo Finds all the #GstDiscovererSubtitleInfo contained in @info A #GList of matching #GstDiscovererStreamInfo. The caller should free it with gst_discoverer_stream_info_list_free(). a #GstDiscovererInfo Use gst_discoverer_{container,stream}_info_get_tags() instead. all tags contained in the URI. If you wish to use the tags after the life-time of @info, you will need to copy them. a #GstDiscovererInfo TOC contained in the URI. If you wish to use the TOC after the life-time of @info, you will need to copy it. a #GstDiscovererInfo the URI to which this information corresponds to. Copy it if you wish to use it after the life-time of @info. a #GstDiscovererInfo Finds all the #GstDiscovererVideoInfo contained in @info A #GList of matching #GstDiscovererStreamInfo. The caller should free it with gst_discoverer_stream_info_list_free(). a #GstDiscovererInfo Serializes @info to a #GVariant that can be parsed again through gst_discoverer_info_from_variant(). Note that any #GstToc (s) that might have been discovered will not be serialized for now. A newly-allocated #GVariant representing @info. A #GstDiscovererInfo A combination of #GstDiscovererSerializeFlags to specify what needs to be serialized. 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 You can use these flags to control what is serialized by gst_discoverer_info_to_variant() Serialize only basic information, excluding caps, tags and miscellaneous information Serialize the caps for each stream Serialize the tags for each stream Serialize miscellaneous information for each stream Serialize all the available info, including caps, tags and miscellaneous information Base structure for information concerning a media stream. Depending on the stream type, one can find more media-specific information in #GstDiscovererAudioInfo, #GstDiscovererVideoInfo, and #GstDiscovererContainerInfo. The #GstDiscovererStreamInfo represents the topology of the stream. Siblings can be iterated over with gst_discoverer_stream_info_get_next() and gst_discoverer_stream_info_get_previous(). Children (sub-streams) of a stream can be accessed using the #GstDiscovererContainerInfo API. As a simple example, if you run #GstDiscoverer on an AVI file with one audio and one video stream, you will get a #GstDiscovererContainerInfo corresponding to the AVI container, which in turn will have a #GstDiscovererAudioInfo sub-stream and a #GstDiscovererVideoInfo sub-stream for the audio and video streams respectively. Decrements the reference count of all contained #GstDiscovererStreamInfo and fress the #GList. a #GList of #GstDiscovererStreamInfo the #GstCaps of the stream. Unref with #gst_caps_unref after usage. a #GstDiscovererStreamInfo This functions is deprecated since version 1.4, use #gst_discoverer_info_get_missing_elements_installer_details additional information regarding the stream (for example codec version, profile, etc..). If you wish to use the #GstStructure after the life-time of @info you will need to copy it. a #GstDiscovererStreamInfo the next #GstDiscovererStreamInfo in a chain. %NULL for final streams. Unref with #gst_discoverer_stream_info_unref after usage. a #GstDiscovererStreamInfo the previous #GstDiscovererStreamInfo in a chain. %NULL for starting points. Unref with #gst_discoverer_stream_info_unref after usage. a #GstDiscovererStreamInfo the stream ID of this stream. If you wish to use the stream ID after the life-time of @info you will need to copy it. a #GstDiscovererStreamInfo the stream number, -1 if no index could be determined. This property acts as a unique identifier as a 'int' for the stream. a #GstDiscovererStreamInfo a human readable name for the stream type of the given @info (ex : "audio", "container",...). a #GstDiscovererStreamInfo the tags contained in this stream. If you wish to use the tags after the life-time of @info you will need to copy them. a #GstDiscovererStreamInfo the TOC contained in this stream. If you wish to use the TOC after the life-time of @info you will need to copy it. a #GstDiscovererStreamInfo #GstDiscovererStreamInfo specific to subtitle streams (this includes text and image based ones). the language of the stream, or NULL if unknown. a #GstDiscovererSubtitleInfo #GstDiscovererStreamInfo specific to video streams (this includes images). the average or nominal bitrate of the video stream in bits/second. a #GstDiscovererVideoInfo the depth in bits of the video stream. a #GstDiscovererVideoInfo the framerate of the video stream (denominator). a #GstDiscovererVideoInfo the framerate of the video stream (numerator). a #GstDiscovererVideoInfo the height of the video stream in pixels. a #GstDiscovererVideoInfo the maximum bitrate of the video stream in bits/second. a #GstDiscovererVideoInfo the Pixel Aspect Ratio (PAR) of the video stream (denominator). a #GstDiscovererVideoInfo the Pixel Aspect Ratio (PAR) of the video stream (numerator). a #GstDiscovererVideoInfo the width of the video stream in pixels. a #GstDiscovererVideoInfo %TRUE if the video stream corresponds to an image (i.e. only contains one frame). a #GstDiscovererVideoInfo %TRUE if the stream is interlaced, else %FALSE. a #GstDiscovererVideoInfo #GstEncodingTarget category for recording and capture. Targets within this category are optimized for low latency encoding. #GstEncodingTarget category for device-specific targets. The name of the target will usually be the constructor and model of the device, and that target will contain #GstEncodingProfiles suitable for that device. #GstEncodingTarget category for file extensions. The name of the target will be the name of the file extensions possible for a particular target. Those targets are defining like 'default' formats usually used for a particular file extension. #GstEncodingTarget category for online-services. The name of the target will usually be the name of the online service and that target will contain #GstEncodingProfiles suitable for that online service. #GstEncodingTarget category for storage, archiving and editing targets. Those targets can be lossless and/or provide very fast random access content. The name of the target will usually be the container type or editing target, and that target will contain #GstEncodingProfiles suitable for editing or storage. Variant of #GstEncodingProfile for audio streams. Creates a new #GstEncodingAudioProfile All provided allocatable arguments will be internally copied, so can be safely freed/unreferenced after calling this method. the newly created #GstEncodingAudioProfile. the #GstCaps the preset(s) to use on the encoder, can be %NULL the #GstCaps used to restrict the input to the encoder, can be NULL. See gst_encoding_profile_get_restriction() for more details. the number of time this stream must be used. 0 means any number of times (including never) Encoding profiles for containers. Keeps track of a list of #GstEncodingProfile Creates a new #GstEncodingContainerProfile. The newly created #GstEncodingContainerProfile. The name of the container profile, can be %NULL The description of the container profile, can be %NULL The format to use for this profile The preset to use for this profile. Add a #GstEncodingProfile to the list of profiles handled by @container. No copy of @profile will be made, if you wish to use it elsewhere after this method you should increment its reference count. %TRUE if the @stream was properly added, else %FALSE. the #GstEncodingContainerProfile to use the #GstEncodingProfile to add. Checks if @container contains a #GstEncodingProfile identical to @profile. %TRUE if @container contains a #GstEncodingProfile identical to @profile, else %FALSE. a #GstEncodingContainerProfile a #GstEncodingProfile the list of contained #GstEncodingProfile. a #GstEncodingContainerProfile The opaque base class object for all encoding profiles. This contains generic information like name, description, format and preset. Find the #GstEncodingProfile with the specified name and category. The matching #GstEncodingProfile or %NULL. The name of the target The name of the profile, if %NULL provided, it will default to the encoding profile called `default`. The target category. Can be %NULL Creates a #GstEncodingProfile matching the formats from the given #GstDiscovererInfo. Streams other than audio or video (eg, subtitles), are currently ignored. The new #GstEncodingProfile or %NULL. The #GstDiscovererInfo to read from Converts a string in the "encoding profile serialization format" into a GstEncodingProfile. Refer to the encoding-profile documentation for details on the format. A newly created GstEncodingProfile or NULL if the input string is not a valid encoding profile serialization format. The string to convert into a GstEncodingProfile. Makes a deep copy of @self The copy of @self The #GstEncodingProfile to copy Get whether the format that has been negotiated in at some point can be renegotiated later during the encoding. a #GstEncodingProfile the description of the profile, can be %NULL. a #GstEncodingProfile The properties that are going to be set on the underlying element a #GstEncodingProfile a suitable file extension for @profile, or NULL. a #GstEncodingProfile (nullable): the #GstCaps corresponding to the media format used in the profile. Unref after usage. a #GstEncodingProfile Computes the full output caps that this @profile will be able to consume. The full caps the given @profile can consume. Call gst_caps_unref() when you are done with the caps. a #GstEncodingProfile the name of the profile, can be %NULL. a #GstEncodingProfile The number of times the profile is used in its parent container profile. If 0, it is not a mandatory stream. a #GstEncodingProfile the name of the #GstPreset to be used in the profile. This is the name that has been set when saving the preset. a #GstEncodingProfile the name of the #GstPreset factory to be used in the profile. a #GstEncodingProfile The restriction #GstCaps 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 #GstEncodingContainerProfile (since there is no corresponding raw stream). Can be %NULL. Unref after usage. a #GstEncodingProfile #TRUE if the stream represented by @profile should use a single segment before the encoder, #FALSE otherwise. This means that buffers will be retimestamped and segments will be eat so as to appear as one segment. a #GstEncodingProfile the human-readable name of the type of @profile. a #GstEncodingProfile Checks whether the two #GstEncodingProfile are equal %TRUE if @a and @b are equal, else %FALSE. a #GstEncodingProfile a #GstEncodingProfile Sets whether the format that has been negotiated in at some point can be renegotiated later during the encoding. a #GstEncodingProfile Whether the format that has been negotiated first can be renegotiated during the encoding Set @description as the given description for the @profile. A copy of @description will be made internally. a #GstEncodingProfile the description to set on the profile This allows setting the muxing/encoding element properties. **Set properties generically** ``` properties [element-properties, boolean-prop=true, string-prop="hi"] ``` **Mapping properties with well known element factories** ``` properties element-properties-map, map = { [openh264enc, gop-size=32, ], [x264enc, key-int-max=32, tune=zerolatency], } ``` a #GstEncodingProfile A #GstStructure defining the properties to be set to the element the profile represents. Set whether the profile should be used or not. a #GstEncodingProfile %FALSE to disable @profile, %TRUE to enable it Sets the media format used in the profile. a #GstEncodingProfile the media format to use in the profile. Set @name as the given name for the @profile. A copy of @name will be made internally. a #GstEncodingProfile 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 a #GstEncodingProfile the number of time the profile can be used Sets the name of the preset to be used in the profile. This is the name that has been set when saving the preset. You can list the available presets for a specific element factory using `$ gst-inspect-1.0 element-factory-name`, for example for `x264enc`: ``` bash $ gst-inspect-1.0 x264enc ... Presets: "Profile Baseline": Baseline Profile "Profile High": High Profile "Profile Main": Main Profile "Profile YouTube": YouTube recommended settings (https://support.google.com/youtube/answer/1722171) "Quality High": High quality "Quality Low": Low quality "Quality Normal": Normal quality "Zero Latency" ``` } a #GstEncodingProfile the element preset to use Sets the name of the #GstPreset's factory to be used in the profile. This is the name of the **element factory** that implements the #GstPreset interface not the name of the preset itself (see #gst_encoding_profile_set_preset). a #GstEncodingProfile The name of the element factory to use in this @profile. Set the restriction #GstCaps to apply before the encoder that will be used in the profile. See gst_encoding_profile_get_restriction() for more about restrictions. Does not apply to #GstEncodingContainerProfile. a #GstEncodingProfile the restriction to apply If using a single segment, buffers will be retimestamped and segments will be eat so as to appear as one segment. > *NOTE*: Single segment is not property supported when using > #encodebin:avoid-reencoding a #GstEncodingProfile #TRUE if the stream represented by @profile should use a single segment before the encoder, #FALSE otherwise. Converts a GstEncodingProfile to a string in the "Encoding Profile serialization format". A string representation of the GstEncodingProfile. The GstEncodingProfile to convert. A #GstStructure defining the properties to be set to the element the profile represents. For example for `av1enc`: ``` element-properties,row-mt=true, end-usage=vbr ``` Collection of #GstEncodingProfile for a specific target or use-case. When being stored/loaded, targets come from a specific category, like #GST_ENCODING_CATEGORY_DEVICE. Creates a new #GstEncodingTarget. 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. The newly created #GstEncodingTarget or %NULL if there was an error. The name of the target. The name of the category to which this @target belongs. For example: #GST_ENCODING_CATEGORY_DEVICE. A description of #GstEncodingTarget in the current locale. A #GList of #GstEncodingProfile. Searches for the #GstEncodingTarget with the given name, loads it and returns it. If the category name is specified only targets from that category will be searched for. The #GstEncodingTarget if available, else %NULL. the name of the #GstEncodingTarget to load (automatically converted to lower case internally as capital letters are not valid for target names). the name of the target category, like #GST_ENCODING_CATEGORY_DEVICE. Can be %NULL Opens the provided file and returns the contained #GstEncodingTarget. The #GstEncodingTarget contained in the file, else %NULL The file location to load the #GstEncodingTarget from Adds the given @profile to the @target. Each added profile must have a unique name within the profile. The @target will steal a reference to the @profile. If you wish to use the profile after calling this method, you should increase its reference count. %TRUE if the profile was added, else %FALSE. the #GstEncodingTarget to add a profile to the #GstEncodingProfile to add The category of the @target. For example: #GST_ENCODING_CATEGORY_DEVICE. a #GstEncodingTarget The description of the @target. a #GstEncodingTarget The name of the @target. a #GstEncodingTarget The path to the @target file. a #GstEncodingTarget The matching #GstEncodingProfile, or %NULL. a #GstEncodingTarget the name of the profile to retrieve A list of #GstEncodingProfile(s) this @target handles. a #GstEncodingTarget Saves the @target to a default user-local directory. %TRUE if the target was correctly saved, else %FALSE. a #GstEncodingTarget Saves the @target to the provided file location. %TRUE if the target was correctly saved, else %FALSE. a #GstEncodingTarget the location to store the @target at. Variant of #GstEncodingProfile for video streams, allows specifying the @pass. Creates a new #GstEncodingVideoProfile 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 gst_encoding_video_profile_set_pass() documentation. If you wish to use/force a constant framerate please refer to the gst_encoding_video_profile_set_variableframerate() documentation. the newly created #GstEncodingVideoProfile. the #GstCaps the preset(s) to use on the encoder, can be %NULL the #GstCaps used to restrict the input to the encoder, can be NULL. See gst_encoding_profile_get_restriction() for more details. the number of time this stream must be used. 0 means any number of times (including never) Get the pass number if this is part of a multi-pass profile. The pass number. Starts at 1 for multi-pass. 0 if this is not a multi-pass profile a #GstEncodingVideoProfile > *NOTE*: Fixed framerate won't be enforced when #encodebin:avoid-reencoding > is set. Whether non-constant video framerate is allowed for encoding. a #GstEncodingVideoProfile 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). a #GstEncodingVideoProfile 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. a #GstEncodingVideoProfile a boolean Opaque context structure for the plugin installation. Use the provided API to set details on it. Creates a new #GstInstallPluginsContext. a new #GstInstallPluginsContext. Free with gst_install_plugins_context_free() when no longer needed Copies a #GstInstallPluginsContext. A copy of @ctx a #GstInstallPluginsContext Frees a #GstInstallPluginsContext. a #GstInstallPluginsContext This function is used to tell the external installer process whether it should ask for confirmation or not before searching for missing plugins. If set, this option will be passed to the installer via a --interaction=[show-confirm-search|hide-confirm-search] command line option. a #GstInstallPluginsContext whether to ask for confirmation before searching for plugins This function is used to pass the calling application's desktop file ID to the external installer process. A desktop file ID is the basename of the desktop file, including the .desktop extension. If set, the desktop file ID will be passed to the installer via a --desktop-id= command line option. a #GstInstallPluginsContext the desktop file ID of the calling application Sets the startup notification ID for the launched process. This is typically used to to pass the current X11 event timestamp to the external installer process. Startup notification IDs are defined in the [FreeDesktop.Org Startup Notifications standard](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt). If set, the ID will be passed to the installer via a --startup-notification-id= command line option. GTK+/GNOME applications should be able to create a startup notification ID like this: |[ timestamp = gtk_get_current_event_time (); startup_id = g_strdup_printf ("_TIME%u", timestamp); ... ]| a #GstInstallPluginsContext the startup notification ID This function is for X11-based applications (such as most Gtk/Qt applications on linux/unix) only. You can use it to tell the external installer the XID of your main application window. That way the installer can make its own window transient to your application window during the installation. If set, the XID will be passed to the installer via a --transient-for=XID command line option. Gtk+/Gnome application should be able to obtain the XID of the top-level window like this: |[ ##include <gtk/gtk.h> ##ifdef GDK_WINDOWING_X11 ##include <gdk/gdkx.h> ##endif ... ##ifdef GDK_WINDOWING_X11 xid = GDK_WINDOW_XWINDOW (GTK_WIDGET (application_window)->window); ##endif ... ]| a #GstInstallPluginsContext the XWindow ID (XID) of the top-level application The prototype of the callback function that will be called once the external plugin installer program has returned. You only need to provide a callback function if you are using the asynchronous interface. whether the installation of the requested plugins succeeded or not the user data passed to gst_install_plugins_async() Result codes returned by gst_install_plugins_async() and gst_install_plugins_sync(), and also the result code passed to the #GstInstallPluginsResultFunc specified with gst_install_plugins_async(). These codes indicate success or failure of starting an external installer program and to what extent the requested plugins could be installed. all of the requested plugins could be installed no appropriate installation candidate for any of the requested plugins could be found. Only return this if nothing has been installed. Return #GST_INSTALL_PLUGINS_PARTIAL_SUCCESS if some (but not all) of the requested plugins could be installed. an error occurred during the installation. If this happens, the user has already seen an error message and another one should not be displayed some of the requested plugins could be installed, but not all the user has aborted the installation the installer had an unclean exit code (ie. death by signal) the helper returned an invalid status code returned by gst_install_plugins_async() to indicate that everything went fine so far and the provided callback will be called with the result of the installation later some internal failure has occurred when trying to start the installer the helper script to call the actual installer is not installed a previously-started plugin installation is still in progress, try again later Convenience function to return the descriptive string associated with a status code. This function returns English strings and should not be used for user messages. It is here only to assist in debugging. a descriptive string for the status code in @ret the return status code The major version of GStreamer's gst-plugins-base libraries at compile time. The micro version of GStreamer's gst-plugins-base libraries at compile time. The minor version of GStreamer's gst-plugins-base libraries at compile time. The nano version of GStreamer's gst-plugins-base libraries at compile time. Actual releases have 0, GIT versions have 1, prerelease versions have 2-... Flags that are returned by gst_pb_utils_get_caps_description_flags() and describe the format of the caps. Caps describe a container format. Caps describe an audio format, or a container format that can store audio. Caps describe an video format, or a container format that can store video. Caps describe an image format, or a container format that can store image. Caps describe an subtitle format, or a container format that can store subtitles. Container format is a tags container. Container format can store any kind of stream type. Caps describe a metadata format, or a container format that can store metadata. Sets the level and profile on @caps if it can be determined from @audio_config. See gst_codec_utils_aac_get_level() and gst_codec_utils_aac_get_profile() for more details on the parameters. @caps must be audio/mpeg caps with an "mpegversion" field of either 2 or 4. If mpegversion is 4, the "base-profile" field is also set in @caps. %TRUE if the level and profile could be set, %FALSE otherwise. the #GstCaps to which level and profile fields are to be added a pointer to the AudioSpecificConfig as specified in the Elementary Stream Descriptor (esds) in ISO/IEC 14496-1. (See below for more details) Length of @audio_config in bytes Returns the channels of the given AAC stream. The channels or 0 if the channel could not be determined. a pointer to the AudioSpecificConfig as specified in the Elementary Stream Descriptor (esds) in ISO/IEC 14496-1. Length of @audio_config in bytes Translates the sample rate to the index corresponding to it in AAC spec. The AAC index for this sample rate, -1 if the rate is not a valid AAC sample rate. Sample rate Determines the level of a stream as defined in ISO/IEC 14496-3. For AAC LC streams, the constraints from the AAC audio profile are applied. For AAC Main, LTP, SSR and others, the Main profile is used. The @audio_config parameter follows the following format, starting from the most significant bit of the first byte: * Bit 0:4 contains the AudioObjectType (if this is 0x5, then the real AudioObjectType is carried after the rate and channel data) * Bit 5:8 contains the sample frequency index (if this is 0xf, then the next 24 bits define the actual sample frequency, and subsequent fields are appropriately shifted). * Bit 9:12 contains the channel configuration The level as a const string and %NULL if the level could not be determined. a pointer to the AudioSpecificConfig as specified in the Elementary Stream Descriptor (esds) in ISO/IEC 14496-1. Length of @audio_config in bytes Returns the profile of the given AAC stream as a string. The profile is normally determined using the AudioObjectType field which is in the first 5 bits of @audio_config The profile as a const string and %NULL if the profile could not be determined. a pointer to the AudioSpecificConfig as specified in the Elementary Stream Descriptor (esds) in ISO/IEC 14496-1. Length of @audio_config in bytes Translates the sample rate index found in AAC headers to the actual sample rate. The sample rate if sr_idx is valid, 0 otherwise. a pointer to the AudioSpecificConfig as specified in the Elementary Stream Descriptor (esds) in ISO/IEC 14496-1. Length of @audio_config Translates the sample rate index found in AAC headers to the actual sample rate. The sample rate if @sr_idx is valid, 0 otherwise. Sample rate index as from the AudioSpecificConfig (MPEG-4 container) or ADTS frame header Transform a seq_level_idx into the level string the level string or %NULL if the seq_level_idx is unknown A seq_level_idx Transform a level string from the caps into the seq_level_idx the seq_level_idx or 31 (max-level) if the level is unknown A level string from caps Converts a RFC 6381 compatible codec string to #GstCaps. More than one codec string can be present (separated by `,`). Registered codecs can be found at http://mp4ra.org/#/codecs The corresponding #GstCaps or %NULL A mime codec string field Converts @caps to a RFC 6381 compatible codec string if possible. Useful for providing the 'codecs' field inside the 'Content-Type' HTTP header for containerized formats, such as mp4 or matroska. Registered codecs can be found at http://mp4ra.org/#/codecs a RFC 6381 compatible codec string or %NULL A #GstCaps to convert to mime codec Sets the level and profile in @caps if it can be determined from @sps. See gst_codec_utils_h264_get_level() and gst_codec_utils_h264_get_profile() for more details on the parameters. %TRUE if the level and profile could be set, %FALSE otherwise. the #GstCaps to which the level and profile are to be added Pointer to the sequence parameter set for the stream. Length of the data available in @sps. Converts the level indication (level_idc) in the stream's sequence parameter set into a string. The SPS is expected to have the same format as for gst_codec_utils_h264_get_profile(). The level as a const string, or %NULL if there is an error. Pointer to the sequence parameter set for the stream. Length of the data available in @sps. Transform a level string from the caps into the level_idc the level_idc or 0 if the level is unknown A level string from caps Converts the profile indication (profile_idc) in the stream's sequence parameter set into a string. The SPS is expected to have the following format, as defined in the H.264 specification. The SPS is viewed as a bitstream here, with bit 0 being the most significant bit of the first byte. * Bit 0:7 - Profile indication * Bit 8 - constraint_set0_flag * Bit 9 - constraint_set1_flag * Bit 10 - constraint_set2_flag * Bit 11 - constraint_set3_flag * Bit 12 - constraint_set3_flag * Bit 13:15 - Reserved * Bit 16:24 - Level indication The profile as a const string, or %NULL if there is an error. Pointer to the sequence parameter set for the stream. Length of the data available in @sps. Parses profile, flags, and level from a H264 AVCC extradata/sequence_header. These are most commonly retrieved from a video/x-h264 caps with a codec_data buffer. The format of H264 AVCC extradata/sequence_header is documented in the ITU-T H.264 specification section 7.3.2.1.1 as well as in ISO/IEC 14496-15 section 5.3.3.1.2. %TRUE on success, %FALSE on failure H264 AVCC extradata length of @codec_data return location for h264 profile_idc or %NULL return location for h264 constraint set flags or %NULL return location h264 level_idc or %NULL Sets the level, tier and profile in @caps if it can be determined from @profile_tier_level. See gst_codec_utils_h265_get_level(), gst_codec_utils_h265_get_tier() and gst_codec_utils_h265_get_profile() for more details on the parameters. %TRUE if the level, tier, profile could be set, %FALSE otherwise. the #GstCaps to which the level, tier and profile are to be added Pointer to the profile_tier_level struct Length of the data available in @profile_tier_level. Converts the level indication (general_level_idc) in the stream's profile_tier_level structure into a string. The profiel_tier_level is expected to have the same format as for gst_codec_utils_h264_get_profile(). The level as a const string, or %NULL if there is an error. Pointer to the profile_tier_level for the stream Length of the data available in @profile_tier_level. Transform a level string from the caps into the level_idc the level_idc or 0 if the level is unknown A level string from caps Converts the profile indication (general_profile_idc) in the stream's profile_level_tier structure into a string. The profile_tier_level is expected to have the following format, as defined in the H.265 specification. The profile_tier_level is viewed as a bitstream here, with bit 0 being the most significant bit of the first byte. * Bit 0:1 - general_profile_space * Bit 2 - general_tier_flag * Bit 3:7 - general_profile_idc * Bit 8:39 - gernal_profile_compatibility_flags * Bit 40 - general_progressive_source_flag * Bit 41 - general_interlaced_source_flag * Bit 42 - general_non_packed_constraint_flag * Bit 43 - general_frame_only_constraint_flag * Bit 44:87 - See below * Bit 88:95 - general_level_idc The profile as a const string, or %NULL if there is an error. Pointer to the profile_tier_level structure for the stream. Length of the data available in @profile_tier_level Converts the tier indication (general_tier_flag) in the stream's profile_tier_level structure into a string. The profile_tier_level is expected to have the same format as for gst_codec_utils_h264_get_profile(). The tier as a const string, or %NULL if there is an error. Pointer to the profile_tier_level for the stream. Length of the data available in @profile_tier_level. Sets the level and profile in @caps if it can be determined from @vis_obj_seq. See gst_codec_utils_mpeg4video_get_level() and gst_codec_utils_mpeg4video_get_profile() for more details on the parameters. %TRUE if the level and profile could be set, %FALSE otherwise. the #GstCaps to which the level and profile are to be added Pointer to the visual object sequence for the stream. Length of the data available in @sps. Converts the level indication in the stream's visual object sequence into a string. @vis_obj_seq is expected to be the data following the visual object sequence start code. Only the first byte (profile_and_level_indication) is used. The level as a const string, or NULL if there is an error. Pointer to the visual object sequence for the stream. Length of the data available in @sps. Converts the profile indication in the stream's visual object sequence into a string. @vis_obj_seq is expected to be the data following the visual object sequence start code. Only the first byte (profile_and_level_indication) is used. The profile as a const string, or NULL if there is an error. Pointer to the visual object sequence for the stream. Length of the data available in @sps. Creates Opus caps from the given parameters. The #GstCaps, or %NULL if the parameters would lead to invalid Opus caps. the sample rate the number of channels the channel mapping family the number of independent streams the number of stereo streams the mapping between the streams Creates Opus caps from the given OpusHead @header and comment header @comments. The #GstCaps. OpusHead header Comment header or NULL Creates OpusHead header from the given parameters. The #GstBuffer containing the OpusHead. the sample rate the number of channels the channel mapping family the number of independent streams the number of stereo streams the mapping between the streams Pre-skip in 48kHz samples or 0 Output gain or 0 Parses Opus caps and fills the different fields with defaults if possible. %TRUE if parsing was successful, %FALSE otherwise. the #GstCaps to parse the data from the sample rate the number of channels the channel mapping family the number of independent streams the number of stereo streams the mapping between the streams Parses the OpusHead header. %TRUE if parsing was successful, %FALSE otherwise. the OpusHead #GstBuffer the sample rate the number of channels the channel mapping family the number of independent streams the number of stereo streams the mapping between the streams Pre-skip in 48kHz samples or 0 Output gain or 0 Increments the reference count of @info. a #GstDiscovererInfo Decrements the reference count of @info. a #GstDiscovererInfo Increments the reference count of @info. a #GstDiscovererStreamInfo Decrements the reference count of @info. a #GstDiscovererStreamInfo Functions to create and handle encoding profiles. Encoding profiles describe the media types and settings one wishes to use for an encoding process. The top-level profiles are commonly #GstEncodingContainerProfile(s) (which contains a user-readable name and description along with which container format to use). These, in turn, reference one or more #GstEncodingProfile(s) which indicate which encoding format should be used on each individual streams. #GstEncodingProfile(s) can be provided to the 'encodebin' element, which will take care of selecting and setting up the required elements to produce an output stream conforming to the specifications of the profile. The encoding profiles do not necessarily specify which #GstElement to use for the various encoding and muxing steps, as they allow to specifying the format one wishes to use. Encoding profiles can be created at runtime by the application or loaded from (and saved to) file using the #GstEncodingTarget API. ## The encoding profile serialization format Encoding profiles can be serialized to be used in the command line tools or to set it on other other #GObject-s using #gst_util_set_object_arg for example. The serialization format aims at being simple to understand although flexible enough to describe any possible encoding profile. There are several ways to describe the profile depending on the context but the general idea is that it is a colon separated list of EncodingProfiles descriptions, the first one needs to describe a #GstEncodingContainerProfile and the following ones describe elementary streams. ### Using encoders and muxer element factory name ``` muxer_factory_name:video_encoder_factory_name:audio_encoder_factory_name ``` For example to encode a stream into a WebM container, with an OGG audio stream and a VP8 video stream, the serialized #GstEncodingProfile looks like: ``` webmmux:vp8enc:vorbisenc ``` ### Define the encoding profile in a generic way using caps: ``` muxer_source_caps:video_encoder_source_caps:audio_encoder_source_caps ``` For example to encode a stream into a WebM container, with an OGG audio stream and a VP8 video stream, the serialized #GstEncodingProfile looks like: ``` video/webm:video/x-vp8:audio/x-vorbis ``` It is possible to mix caps and element type names so you can specify a specific video encoder while using caps for other encoders/muxer. ### Using preset You can also set the preset name of the encoding profile using the caps+preset_name syntax as in: ``` video/webm:video/x-vp8+youtube-preset:audio/x-vorbis ``` ### Setting properties on muxers or on the encoding profile itself Moreover, you can set the extra properties: * `|element-properties,property1=true` (See #gst_encoding_profile_set_element_properties) * `|presence=true` (See See #gst_encoding_profile_get_presence) * `|single-segment=true` (See #gst_encoding_profile_set_single_segment) * `|single-segment=true` (See #gst_encoding_video_profile_set_variableframerate) * `|factory-name=element-factory-name` (See #gst_encoding_profile_set_preset_name) for example: ``` video/webm:video/x-vp8|presence=1|element-properties,target-bitrate=500000:audio/x-vorbis ``` ### Enforcing properties to the stream itself (video size, number of audio channels, etc..) You can also use the `restriction_caps->encoded_format_caps` syntax to specify the restriction caps to be set on a #GstEncodingProfile It corresponds to the restriction #GstCaps to apply before the encoder that will be used in the profile (See #gst_encoding_profile_get_restriction). 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. This property does not make sense for muxers. See #gst_encoding_profile_get_restriction for more details. To force a video stream to be encoded with a Full HD resolution (using WebM as the container format, VP8 as the video codec and Vorbis as the audio codec), you should use: ``` "video/webm:video/x-raw,width=1920,height=1080->video/x-vp8:audio/x-vorbis" ``` > NOTE: Make sure to enclose into quotes to avoid '>' to be reinterpreted by > the shell. In the case you are specifying encoders directly, the following is also possible: ``` matroskamux:x264enc,width=1920,height=1080:audio/x-vorbis ``` ## Some serialized encoding formats examples ### MP3 audio and H264 in MP4** ``` video/quicktime,variant=iso:video/x-h264:audio/mpeg,mpegversion=1,layer=3 ``` ### Vorbis and theora in OGG ``` application/ogg:video/x-theora:audio/x-vorbis ``` ### AC3 and H264 in MPEG-TS ``` video/mpegts:video/x-h264:audio/x-ac3 ``` ## Loading a profile from encoding targets Anywhere you have to use a string to define a #GstEncodingProfile, you can use load it from a #GstEncodingTarget using the following syntaxes: ``` target_name[/profilename/category] ``` or ``` /path/to/target.gep:profilename ``` ## Examples ### Creating a profile ``` c #include <gst/pbutils/encoding-profile.h> ... GstEncodingProfile * create_ogg_theora_profile(void) { GstEncodingContainerProfile *prof; GstCaps *caps; caps = gst_caps_from_string("application/ogg"); prof = gst_encoding_container_profile_new("Ogg audio/video", "Standard OGG/THEORA/VORBIS", caps, NULL); gst_caps_unref (caps); caps = gst_caps_from_string("video/x-theora"); gst_encoding_container_profile_add_profile(prof, (GstEncodingProfile*) gst_encoding_video_profile_new(caps, NULL, NULL, 0)); gst_caps_unref (caps); caps = gst_caps_from_string("audio/x-vorbis"); gst_encoding_container_profile_add_profile(prof, (GstEncodingProfile*) gst_encoding_audio_profile_new(caps, NULL, NULL, 0)); gst_caps_unref (caps); return (GstEncodingProfile*) prof; } ``` ### Example: Using an encoder preset with a profile ``` c #include <gst/pbutils/encoding-profile.h> ... GstEncodingProfile * create_ogg_theora_profile(void) { GstEncodingVideoProfile *v; GstEncodingAudioProfile *a; GstEncodingContainerProfile *prof; GstCaps *caps; GstPreset *preset; caps = gst_caps_from_string ("application/ogg"); prof = gst_encoding_container_profile_new ("Ogg audio/video", "Standard OGG/THEORA/VORBIS", caps, NULL); gst_caps_unref (caps); preset = GST_PRESET (gst_element_factory_make ("theoraenc", "theorapreset")); g_object_set (preset, "bitrate", 1000, NULL); // The preset will be saved on the filesystem, // so try to use a descriptive name gst_preset_save_preset (preset, "theora_bitrate_preset"); gst_object_unref (preset); caps = gst_caps_from_string ("video/x-theora"); v = gst_encoding_video_profile_new (caps, "theora_bitrate_preset", NULL, 0); gst_encoding_container_profile_add_profile (prof, (GstEncodingProfile*) v); gst_caps_unref (caps); caps = gst_caps_from_string ("audio/x-vorbis"); a = gst_encoding_audio_profile_new (caps, NULL, NULL, 0); gst_encoding_container_profile_add_profile (prof, (GstEncodingProfile*) a); gst_caps_unref (caps); return (GstEncodingProfile*) prof; } ``` ### Listing categories, targets and profiles ``` c #include <gst/pbutils/encoding-profile.h> ... GstEncodingProfile *prof; GList *categories, *tmpc; GList *targets, *tmpt; ... categories = gst_encoding_list_available_categories (); ... Show available categories to user ... for (tmpc = categories; tmpc; tmpc = tmpc->next) { gchar *category = (gchar *) tmpc->data; ... and we can list all targets within that category ... targets = gst_encoding_list_all_targets (category); ... and show a list to our users ... g_list_foreach (targets, (GFunc) gst_encoding_target_unref, NULL); g_list_free (targets); } g_list_foreach (categories, (GFunc) g_free, NULL); g_list_free (categories); ... ``` On top of the notion of profiles, we implement the notion of EncodingTarget. Encoding Targets are basically a higher level of abstraction to define formats for specific target types. Those can define several GstEncodingProfiles with different names, for example one for transcoding in full HD, another one for low res, etc.. which are defined in the same encoding target. Basically if you want to encode a stream to send it to, say, youtube you should have a Youtube encoding target defined in the "online-service" category. ## Encoding target serialization format Encoding targets are serialized in a KeyFile like files. |[ [GStreamer Encoding Target] name : <name> category : <category> \description : <description> #translatable [profile-<profile1name>] name : <name> \description : <description> #optional format : <format> preset : <preset> [streamprofile-<id>] parent : <encodingprofile.name>[,<encodingprofile.name>..] \type : <type> # "audio", "video", "text" format : <format> preset : <preset> restriction : <restriction> presence : <presence> pass : <pass> variableframerate : <variableframerate> ]| ## Location of encoding target files $GST_DATADIR/gstreamer-GST_API_VERSION/encoding-profile $HOME/gstreamer-GST_API_VERSION/encoding-profile There also is a GST_ENCODING_TARGET_PATH environment variable defining a list of folder containing encoding target files. ## Naming convention |[ $(target.category)/$(target.name).gep ]| ## Naming restrictions: * lowercase ASCII letter for the first character * Same for all other characters + numerics + hyphens List all available #GstEncodingTarget for the specified category, or all categories if @categoryname is %NULL. The list of #GstEncodingTarget The category, for ex: #GST_ENCODING_CATEGORY_DEVICE. Can be %NULL. Lists all #GstEncodingTarget categories present on disk. A list of #GstEncodingTarget categories. Increases the reference count of the @profile. a #GstEncodingProfile Decreases the reference count of the @profile, possibly freeing the @profile. a #GstEncodingProfile Increases the reference count of the @target. a #GstEncodingTarget Decreases the reference count of the @target, possibly freeing it. a #GstEncodingTarget libgstpbutils is a general utility library for plugins and applications. It currently provides the following: * human-readable description strings of codecs, elements, sources, decoders, encoders, or sinks from decoder/encoder caps, element names, or protocol names. * support for applications to initiate installation of missing plugins (if this is supported by the distribution or operating system used) * API for GStreamer elements to create missing-plugin messages in order to communicate to the application that a certain type of plugin is missing (decoder, encoder, URI protocol source, URI protocol sink, named element) * API for applications to recognise and handle missing-plugin messages ## Linking to this library You should obtain the required CFLAGS and LIBS using pkg-config on the gstreamer-plugins-base-1.0 module. You will then also need to add '-lgstreamer-pbutils-1.0' manually to your LIBS line. ## Library initialisation Before using any of its functions, applications and plugins must call gst_pb_utils_init() to initialise the library. Provides codec-specific ulility functions such as functions to provide the codec profile and level in human-readable string form from header data. The above functions provide human-readable strings for media formats and decoder/demuxer/depayloader/encoder/muxer/payloader elements for use in error dialogs or other messages shown to users. gst_pb_utils_add_codec_description_to_tag_list() is a utility function for demuxer and decoder elements to add audio/video codec tags from a given (fixed) #GstCaps. ## Overview Using this API, applications can request the installation of missing GStreamer plugins. These may be missing decoders/demuxers or encoders/muxers for a certain format, sources or sinks for a certain URI protocol (e.g. 'http'), or certain elements known by their element factory name ('audioresample'). Whether plugin installation is supported or not depends on the operating system and/or distribution in question. The vendor of the operating system needs to make sure the necessary hooks and mechanisms are in place for plugin installation to work. See below for more detailed information. From the application perspective, plugin installation is usually triggered either - when the application itself has found that it wants or needs to install a certain element - when the application has been notified by an element (such as playbin or decodebin) that one or more plugins are missing *and* the application has decided that it wants to install one or more of those missing plugins The install functions in this section all take one or more 'detail strings'. These detail strings contain information about the type of plugin that needs to be installed (decoder, encoder, source, sink, or named element), and some additional information such GStreamer version used and a human-readable description of the component to install for user dialogs. Applications should not concern themselves with the composition of the string itself. They should regard the string as if it was a shared secret between GStreamer and the plugin installer application. Detail strings can be obtained using the function gst_missing_plugin_message_get_installer_detail() on a missing-plugin message. Such a message will either have been found by the application on a pipeline's #GstBus, or the application will have created it itself using gst_missing_element_message_new(), gst_missing_decoder_message_new(), gst_missing_encoder_message_new(), gst_missing_uri_sink_message_new(), or gst_missing_uri_source_message_new(). For each GStreamer element/plugin/component that should be installed, the application needs one of those 'installer detail' string mentioned in the previous section. This string can be obtained, as already mentioned above, from a missing-plugin message using the function gst_missing_plugin_message_get_installer_detail(). The missing-plugin message is either posted by another element and then found on the bus by the application, or the application has created it itself as described above. The application will then call gst_install_plugins_async(), passing a NULL-terminated array of installer detail strings, and a function that should be called when the installation of the plugins has finished (successfully or not). Optionally, a #GstInstallPluginsContext created with gst_install_plugins_context_new() may be passed as well. This way additional optional arguments like the application window's XID can be passed to the external installer application. gst_install_plugins_async() will return almost immediately, with the return code indicating whether plugin installation was started or not. If the necessary hooks for plugin installation are in place and an external installer application has in fact been called, the passed in function will be called with a result code as soon as the external installer has finished. If the result code indicates that new plugins have been installed, the application will want to call gst_update_registry() so the run-time plugin registry is updated and the new plugins are made available to the application. > A Gtk/GLib main loop must be running in order for the result function > to be called when the external installer has finished. If this is not > the case, make sure to regularly call in your code: > > g_main_context_iteration (NULL,FALSE); ## 1. Installer hook When GStreamer applications initiate plugin installation via gst_install_plugins_async() or gst_install_plugins_sync(), a pre-defined helper application will be called. The exact path of the helper application to be called is set at compile time, usually by the build system based on the install prefix. For a normal package build into the `/usr` prefix, this will usually default to `/usr/libexec/gst-install-plugins-helper` or `/usr/lib/gst-install-plugins-helper`. Vendors/distros who want to support GStreamer plugin installation should either provide such a helper script/application or use the meson option `-Dinstall_plugins_helper'=/path/to/installer` to make GStreamer call an installer of their own directly. It is strongly recommended that vendors provide a small helper application as interlocutor to the real installer though, even more so if command line argument munging is required to transform the command line arguments passed by GStreamer to the helper application into arguments that are understood by the real installer. The helper application path defined at compile time can be overridden at runtime by setting the GST_INSTALL_PLUGINS_HELPER environment variable. This can be useful for testing/debugging purposes. ## 2. Arguments passed to the install helper GStreamer will pass the following arguments to the install helper (this is in addition to the path of the executable itself, which is by convention argv[0]): - none to many optional arguments in the form of `--foo-bar=val`. Example: `--transient-for=XID` where XID is the X Window ID of the main window of the calling application (so the installer can make itself transient to that window). Unknown optional arguments should be ignored by the installer. - one 'installer detail string' argument for each plugin to be installed; these strings will have a `gstreamer` prefix; the exact format of the detail string is explained below ## 3. Detail string describing the missing plugin The string is in UTF-8 encoding and is made up of several fields, separated by '|' characters (but neither the first nor the last character is a '|'). The fields are: - plugin system identifier, ie. "gstreamer" This identifier determines the format of the rest of the detail string. Automatic plugin installers should not process detail strings with unknown identifiers. This allows other plugin-based libraries to use the same mechanism for their automatic plugin installation needs, or for the format to be changed should it turn out to be insufficient. - plugin system version, e.g. "1.0" This is required so that when there is GStreamer-2.0 at some point in future, the different major versions can still co-exist and use the same plugin install mechanism in the same way. - application identifier, e.g. "totem" This may also be in the form of "pid/12345" if the program name can't be obtained for some reason. - human-readable localised description of the required component, e.g. "Vorbis audio decoder" - identifier string for the required component (see below for details about how to map this to the package/plugin that needs installing), e.g. - urisource-$(PROTOCOL_REQUIRED), e.g. urisource-http or urisource-mms - element-$(ELEMENT_REQUIRED), e.g. element-videoconvert - decoder-$(CAPS_REQUIRED), e.g. (do read below for more details!): - decoder-audio/x-vorbis - decoder-application/ogg - decoder-audio/mpeg, mpegversion=(int)4 - decoder-video/mpeg, systemstream=(boolean)true, mpegversion=(int)2 - encoder-$(CAPS_REQUIRED), e.g. encoder-audio/x-vorbis - optional further fields not yet specified An entire ID string might then look like this, for example: ` gstreamer|1.0|totem|Vorbis audio decoder|decoder-audio/x-vorbis` Plugin installers parsing this ID string should expect further fields also separated by '|' symbols and either ignore them, warn the user, or error out when encountering them. Those unfamiliar with the GStreamer 'caps' system should note a few things about the caps string used in the above decoder/encoder case: - the first part ("video/mpeg") of the caps string is a GStreamer media type and *not* a MIME type. Wherever possible, the GStreamer media type will be the same as the corresponding MIME type, but often it is not. - a caps string may or may not have additional comma-separated fields of various types (as seen in the examples above) - the caps string of a 'required' component (as above) will always have fields with fixed values, whereas an introspected string (see below) may have fields with non-fixed values. Compare for example: - `audio/mpeg, mpegversion=(int)4` vs. `audio/mpeg, mpegversion=(int){2, 4}` - `video/mpeg, mpegversion=(int)2` vs. `video/mpeg, systemstream=(boolean){ true, false}, mpegversion=(int)[1, 2]` ## 4. Exit codes the installer should return The installer should return one of the following exit codes when it exits: - 0 if all of the requested plugins could be installed (#GST_INSTALL_PLUGINS_SUCCESS) - 1 if no appropriate installation candidate for any of the requested plugins could be found. Only return this if nothing has been installed (#GST_INSTALL_PLUGINS_NOT_FOUND) - 2 if an error occurred during the installation. The application will assume that the user will already have seen an error message by the installer in this case and will usually not show another one (#GST_INSTALL_PLUGINS_ERROR) - 3 if some of the requested plugins could be installed, but not all (#GST_INSTALL_PLUGINS_PARTIAL_SUCCESS) - 4 if the user aborted the installation (#GST_INSTALL_PLUGINS_USER_ABORT) ## 5. How to map the required detail string to packages It is up to the vendor to find mechanism to map required components from the detail string to the actual packages/plugins to install. This could be a hardcoded list of mappings, for example, or be part of the packaging system metadata. GStreamer plugin files can be introspected for this information. The `gst-inspect` utility has a special command line option that will output information similar to what is required. For example ` $ gst-inspect-1.0 --print-plugin-auto-install-info /path/to/libgstvorbis.so should output something along the lines of `decoder-audio/x-vorbis`, `element-vorbisdec` `element-vorbisenc` `element-vorbisparse`, `element-vorbistag`, `encoder-audio/x-vorbis` Note that in the encoder and decoder case the introspected caps can be more complex with additional fields, e.g. `audio/mpeg,mpegversion=(int){2,4}`, so they will not always exactly match the caps wanted by the application. It is up to the installer to deal with this (either by doing proper caps intersection using the GStreamer #GstCaps API, or by only taking into account the media type). Another potential source of problems are plugins such as ladspa or libvisual where the list of elements depends on the installed ladspa/libvisual plugins at the time. This is also up to the distribution to handle (but usually not relevant for playback applications). Functions to create, recognise and parse missing-plugins messages for applications and elements. Missing-plugin messages are posted on the bus by elements like decodebin or playbin if they can't find an appropriate source element or decoder element. The application can use these messages for two things: * concise error/problem reporting to the user mentioning what exactly is missing, see gst_missing_plugin_message_get_description() * initiate installation of missing plugins, see gst_missing_plugin_message_get_installer_detail() and gst_install_plugins_async() Applications may also create missing-plugin messages themselves to install required elements that are missing, using the install mechanism mentioned above. Use the GST_PLUGINS_BASE_VERSION_* macros e.g. to check what version of gst-plugins-base you are building against, and gst_plugins_base_version() if you need to check at runtime what version of the gst-plugins-base libraries are being used / you are currently linked against. The version macros get defined by including <gst/pbutils/pbutils.h>. Requests plugin installation without blocking. Once the plugins have been installed or installation has failed, @func will be called with the result of the installation and your provided @user_data pointer. This function requires a running GLib/Gtk main loop. If you are not running a GLib/Gtk main loop, make sure to regularly call g_main_context_iteration(NULL,FALSE). The installer strings that make up @detail are typically obtained by calling gst_missing_plugin_message_get_installer_detail() on missing-plugin messages that have been caught on a pipeline's bus or created by the application via the provided API, such as gst_missing_element_message_new(). It is possible to request the installation of multiple missing plugins in one go (as might be required if there is a demuxer for a certain format installed but no suitable video decoder and no suitable audio decoder). result code whether an external installer could be started NULL-terminated array of installer string details (see below) a #GstInstallPluginsContext, or NULL the function to call when the installer program returns the user data to pass to @func when called, or NULL Checks whether plugin installation (initiated by this application only) is currently in progress. TRUE if plugin installation is in progress, otherwise FALSE Convenience function to return the descriptive string associated with a status code. This function returns English strings and should not be used for user messages. It is here only to assist in debugging. a descriptive string for the status code in @ret the return status code Checks whether plugin installation is likely to be supported by the current environment. This currently only checks whether the helper script that is to be provided by the distribution or operating system vendor exists. TRUE if plugin installation is likely to be supported. Requests plugin installation and block until the plugins have been installed or installation has failed. This function should almost never be used, it only exists for cases where a non-GLib main loop is running and the user wants to run it in a separate thread and marshal the result back asynchronously into the main thread using the other non-GLib main loop. You should almost always use gst_install_plugins_async() instead of this function. the result of the installation. NULL-terminated array of installer string details a #GstInstallPluginsContext, or NULL Checks whether @msg is a missing plugins message. %TRUE if @msg is a missing-plugins message, otherwise %FALSE. a #GstMessage Returns an opaque string containing all the details about the missing element to be passed to an external installer called via gst_install_plugins_async() or gst_install_plugins_sync(). This function is mainly for applications that call external plugin installation mechanisms using one of the two above-mentioned functions in the case where the application knows exactly what kind of plugin it is missing. a newly-allocated detail string. Free string with g_free() when not needed any longer. the (fixed) caps for which a decoder element is needed Creates a missing-plugin message for @element to notify the application that a decoder element for a particular set of (fixed) caps is missing. This function is mainly for use in plugins. a new #GstMessage the #GstElement posting the message the (fixed) caps for which a decoder element is needed Returns an opaque string containing all the details about the missing element to be passed to an external installer called via gst_install_plugins_async() or gst_install_plugins_sync(). This function is mainly for applications that call external plugin installation mechanisms using one of the two above-mentioned functions in the case where the application knows exactly what kind of plugin it is missing. a newly-allocated detail string. Free string with g_free() when not needed any longer. the name of the missing element (element factory), e.g. "videoscale" or "cdparanoiasrc" Creates a missing-plugin message for @element to notify the application that a certain required element is missing. This function is mainly for use in plugins. a new #GstMessage the #GstElement posting the message the name of the missing element (element factory), e.g. "videoscale" or "cdparanoiasrc" Returns an opaque string containing all the details about the missing element to be passed to an external installer called via gst_install_plugins_async() or gst_install_plugins_sync(). This function is mainly for applications that call external plugin installation mechanisms using one of the two above-mentioned functions in the case where the application knows exactly what kind of plugin it is missing. a newly-allocated detail string. Free string with g_free() when not needed any longer. the (fixed) caps for which an encoder element is needed Creates a missing-plugin message for @element to notify the application that an encoder element for a particular set of (fixed) caps is missing. This function is mainly for use in plugins. a new #GstMessage the #GstElement posting the message the (fixed) caps for which an encoder element is needed Returns a localised string describing the missing feature, for use in error dialogs and the like. Should never return NULL unless @msg is not a valid missing-plugin message. This function is mainly for applications that need a human-readable string describing a missing plugin, given a previously collected missing-plugin message a newly-allocated description string. Free string with g_free() when not needed any longer. a missing-plugin #GstMessage of type #GST_MESSAGE_ELEMENT Returns an opaque string containing all the details about the missing element to be passed to an external installer called via gst_install_plugins_async() or gst_install_plugins_sync(). This function is mainly for applications that call external plugin installation mechanisms using one of the two above-mentioned functions. a newly-allocated detail string, or NULL on error. Free string with g_free() when not needed any longer. a missing-plugin #GstMessage of type #GST_MESSAGE_ELEMENT Get the stream-id of the stream for which an element is missing. The stream-id or %NULL if none is specified. A missing-plugin #GstMessage of type #GST_MESSAGE_ELEMENT Set the stream-id of the stream for which an element is missing. A missing-plugin #GstMessage of type #GST_MESSAGE_ELEMENT The stream id for which an element is missing Returns an opaque string containing all the details about the missing element to be passed to an external installer called via gst_install_plugins_async() or gst_install_plugins_sync(). This function is mainly for applications that call external plugin installation mechanisms using one of the two above-mentioned functions in the case where the application knows exactly what kind of plugin it is missing. a newly-allocated detail string. Free string with g_free() when not needed any longer. the URI protocol the missing source needs to implement, e.g. "http" or "mms" Creates a missing-plugin message for @element to notify the application that a sink element for a particular URI protocol is missing. This function is mainly for use in plugins. a new #GstMessage the #GstElement posting the message the URI protocol the missing sink needs to implement, e.g. "http" or "smb" Returns an opaque string containing all the details about the missing element to be passed to an external installer called via gst_install_plugins_async() or gst_install_plugins_sync(). This function is mainly for applications that call external plugin installation mechanisms using one of the two above-mentioned functions in the case where the application knows exactly what kind of plugin it is missing. a newly-allocated detail string. Free string with g_free() when not needed any longer. the URI protocol the missing source needs to implement, e.g. "http" or "mms" Creates a missing-plugin message for @element to notify the application that a source element for a particular URI protocol is missing. This function is mainly for use in plugins. a new #GstMessage the #GstElement posting the message the URI protocol the missing source needs to implement, e.g. "http" or "mms" Adds a codec tag describing the format specified by @caps to @taglist. TRUE if a codec tag was added, FALSE otherwise. a #GstTagList a GStreamer codec tag such as #GST_TAG_AUDIO_CODEC, #GST_TAG_VIDEO_CODEC or #GST_TAG_CODEC. If none is specified, the function will attempt to detect the appropriate category. the (fixed) #GstCaps for which a codec tag should be added. Returns flags that describe the format of the caps if known. No flags are set for unknown caps. #GstPbUtilsCapsDescriptionFlags that describe @caps, or no flags if the caps are unknown. the (fixed) #GstCaps for which flags are requested Returns a localised (as far as this is possible) string describing the media format specified in @caps, for use in error dialogs or other messages to be seen by the user. Should never return NULL unless @caps is invalid. Also see the convenience function gst_pb_utils_add_codec_description_to_tag_list(). a newly-allocated description string, or NULL on error. Free string with g_free() when not needed any longer. the (fixed) #GstCaps for which an format description is needed Returns a localised string describing an decoder for the format specified in @caps, for use in error dialogs or other messages to be seen by the user. This function is mainly for internal use, applications would typically use gst_missing_plugin_message_get_description() to get a description of a missing feature from a missing-plugin message. a newly-allocated description string. Free string with g_free() when not needed any longer. the (fixed) #GstCaps for which an decoder description is needed Returns a localised string describing the given element, for use in error dialogs or other messages to be seen by the user. This function is mainly for internal use, applications would typically use gst_missing_plugin_message_get_description() to get a description of a missing feature from a missing-plugin message. a newly-allocated description string. Free string with g_free() when not needed any longer. the name of the element, e.g. "giosrc" Returns a localised string describing an encoder for the format specified in @caps, for use in error dialogs or other messages to be seen by the user. This function is mainly for internal use, applications would typically use gst_missing_plugin_message_get_description() to get a description of a missing feature from a missing-plugin message. a newly-allocated description string. Free string with g_free() when not needed any longer. the (fixed) #GstCaps for which an encoder description is needed Returns a possible file extension for the given caps, if known. a newly-allocated file extension string, or NULL on error. Free string with g_free() when not needed any longer. the (fixed) #GstCaps for which a file extension is needed Returns a localised string describing a sink element handling the protocol specified in @protocol, for use in error dialogs or other messages to be seen by the user. This function is mainly for internal use, applications would typically use gst_missing_plugin_message_get_description() to get a description of a missing feature from a missing-plugin message. a newly-allocated description string. Free string with g_free() when not needed any longer. the protocol the sink element needs to handle, e.g. "http" Returns a localised string describing a source element handling the protocol specified in @protocol, for use in error dialogs or other messages to be seen by the user. This function is mainly for internal use, applications would typically use gst_missing_plugin_message_get_description() to get a description of a missing feature from a missing-plugin message. a newly-allocated description string. Free string with g_free() when not needed any longer. the protocol the source element needs to handle, e.g. "http" Initialises the base utils support library. This function is not thread-safe. Applications should call it after calling gst_init(), plugins should call it from their plugin_init function. This function may be called multiple times. It will do nothing if the library has already been initialised. Gets the version number of the GStreamer Plugins Base libraries. pointer to a guint to store the major version number, or %NULL pointer to a guint to store the minor version number, or %NULL pointer to a guint to store the micro version number, or %NULL pointer to a guint to store the nano version number, or %NULL This function returns a string that is useful for describing this version of GStreamer's gst-plugins-base libraries to the outside world: user agent strings, logging, about dialogs ... a newly allocated string describing this version of gst-plugins-base