gi-gst-1.0.15: GStreamer bindings

CopyrightWill Thompson Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria (garetxe@gmail.com)
Safe HaskellNone
LanguageHaskell2010

GI.Gst.Functions

Contents

Description

 
Synopsis

Methods

debugAddLogFunction

debugAddLogFunction Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> LogFunction

func: the function to use

-> m () 

Adds the logging function to the list of logging functions. Be sure to use G_GNUC_NO_INSTRUMENT on that function, it is needed.

debugAddRingBufferLogger

debugAddRingBufferLogger Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word32

maxSizePerThread: Maximum size of log per thread in bytes

-> Word32

threadTimeout: Timeout for threads in seconds

-> m () 

Adds a memory ringbuffer based debug logger that stores up to maxSizePerThread bytes of logs per thread and times out threads after threadTimeout seconds of inactivity.

Logs can be fetched with debugRingBufferLoggerGetLogs and the logger can be removed again with debugRemoveRingBufferLogger. Only one logger at a time is possible.

Since: 1.14

debugBinToDotData

debugBinToDotData Source #

Arguments

:: (HasCallStack, MonadIO m, IsBin a) 
=> a

bin: the top-level pipeline that should be analyzed

-> [DebugGraphDetails] 
-> m Text

Returns: a string containing the pipeline in graphviz dot format.

To aid debugging applications one can use this method to obtain the whole network of gstreamer elements that form the pipeline into an dot file. This data can be processed with graphviz to get an image.

debugBinToDotFile

debugBinToDotFile Source #

Arguments

:: (HasCallStack, MonadIO m, IsBin a) 
=> a

bin: the top-level pipeline that should be analyzed

-> [DebugGraphDetails] 
-> [Char]

fileName: output base filename (e.g. "myplayer")

-> m () 

To aid debugging applications one can use this method to write out the whole network of gstreamer elements that form the pipeline into an dot file. This file can be processed with graphviz to get an image. <informalexample><programlisting> dot -Tpng -oimage.png graph_lowlevel.dot </programlisting></informalexample>

debugBinToDotFileWithTs

debugBinToDotFileWithTs Source #

Arguments

:: (HasCallStack, MonadIO m, IsBin a) 
=> a

bin: the top-level pipeline that should be analyzed

-> [DebugGraphDetails] 
-> [Char]

fileName: output base filename (e.g. "myplayer")

-> m () 

This works like debugBinToDotFile, but adds the current timestamp to the filename, so that it can be used to take multiple snapshots.

debugConstructTermColor

debugConstructTermColor Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word32

colorinfo: the color info

-> m Text

Returns: a string containing the color definition

Constructs a string that can be used for getting the desired color in color terminals. You need to free the string after use.

debugConstructWinColor

debugConstructWinColor Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word32

colorinfo: the color info

-> m Int32

Returns: an integer containing the color definition

Constructs an integer that can be used for getting the desired color in windows' terminals (cmd.exe). As there is no mean to underline, we simply ignore this attribute.

This function returns 0 on non-windows machines.

debugGetAllCategories

debugGetAllCategories Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m [DebugCategory]

Returns: the list of debug categories

Returns a snapshot of a all categories that are currently in use . This list may change anytime. The caller has to free the list after use.

debugGetColorMode

debugGetColorMode Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m DebugColorMode

Returns: see gstDebugColorMode for possible values.

Changes the coloring mode for debug output.

Since: 1.2

debugGetDefaultThreshold

debugGetDefaultThreshold Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m DebugLevel

Returns: the default threshold level

Returns the default threshold that is used for new categories.

debugGetStackTrace

debugGetStackTrace Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> [StackTraceFlags]

flags: A set of StackTraceFlags to determine how the stack trace should look like. Pass 0 to retrieve a minimal backtrace.

-> m (Maybe Text)

Returns: a stack trace, if libunwind or glibc backtrace are present, else Nothing.

No description available in the introspection data.

Since: 1.12

debugIsActive

debugIsActive Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Bool

Returns: True, if debugging is activated

Checks if debugging output is activated.

debugIsColored

debugIsColored Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Bool

Returns: True, if the debug output should be colored.

Checks if the debugging output should be colored.

debugLogDefault

debugLogDefault Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) 
=> DebugCategory

category: category to log

-> DebugLevel

level: level of the message

-> Text

file: the file that emitted the message, usually the "GIGstFunctions.hs" identifier

-> Text

function: the function that emitted the message

-> Int32

line: the line from that the message was emitted, usually 5210

-> Maybe a

object: the object this message relates to, or Nothing if none

-> DebugMessage

message: the actual message

-> Ptr ()

userData: the FILE* to log to

-> m () 

The default logging handler used by GStreamer. Logging functions get called whenever a macro like GST_DEBUG or similar is used. By default this function is setup to output the message and additional info to stderr (or the log file specified via the GST_DEBUG_FILE environment variable) as received via userData.

You can add other handlers by using debugAddLogFunction. And you can remove this handler by calling gst_debug_remove_log_function(gst_debug_log_default);

debugPrintStackTrace

debugPrintStackTrace :: (HasCallStack, MonadIO m) => m () Source #

If libunwind or glibc backtrace are present a stack trace is printed.

debugRemoveLogFunction

debugRemoveLogFunction Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Maybe LogFunction

func: the log function to remove, or Nothing to remove the default log function

-> m Word32

Returns: How many instances of the function were removed

Removes all registered instances of the given logging functions.

debugRemoveLogFunctionByData

debugRemoveLogFunctionByData Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Ptr ()

data: user data of the log function to remove

-> m Word32

Returns: How many instances of the function were removed

Removes all registered instances of log functions with the given user data.

debugRemoveRingBufferLogger

debugRemoveRingBufferLogger :: (HasCallStack, MonadIO m) => m () Source #

Removes any previously added ring buffer logger with debugAddRingBufferLogger.

Since: 1.14

debugRingBufferLoggerGetLogs

debugRingBufferLoggerGetLogs Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m [Text]

Returns: NULL-terminated array of strings with the debug output per thread

Fetches the current logs per thread from the ring buffer logger. See debugAddRingBufferLogger for details.

Since: 1.14

debugSetActive

debugSetActive Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bool

active: Whether to use debugging output or not

-> m () 

If activated, debugging messages are sent to the debugging handlers. It makes sense to deactivate it for speed issues. > This function is not threadsafe. It makes sense to only call it during initialization.

debugSetColorMode

debugSetColorMode Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> DebugColorMode

mode: The coloring mode for debug output. See gstDebugColorMode.

-> m () 

Changes the coloring mode for debug output.

This function may be called before init.

Since: 1.2

debugSetColorModeFromString

debugSetColorModeFromString Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

mode: The coloring mode for debug output. One of the following: "on", "auto", "off", "disable", "unix".

-> m () 

Changes the coloring mode for debug output.

This function may be called before init.

Since: 1.2

debugSetColored

debugSetColored Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bool

colored: Whether to use colored output or not

-> m () 

Sets or unsets the use of coloured debugging output. Same as gst_debug_set_color_mode () with the argument being being GST_DEBUG_COLOR_MODE_ON or GST_DEBUG_COLOR_MODE_OFF.

This function may be called before init.

debugSetDefaultThreshold

debugSetDefaultThreshold Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> DebugLevel

level: level to set

-> m () 

Sets the default threshold to the given level and updates all categories to use this threshold.

This function may be called before init.

debugSetThresholdForName

debugSetThresholdForName Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

name: name of the categories to set

-> DebugLevel

level: level to set them to

-> m () 

Sets all categories which match the given glob style pattern to the given level.

debugSetThresholdFromString

debugSetThresholdFromString Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

list: comma-separated list of "category:level" pairs to be used as debug logging levels

-> Bool

reset: True to clear all previously-set debug levels before setting new thresholds False if adding the threshold described by list to the one already set.

-> m () 

Sets the debug logging wanted in the same form as with the GST_DEBUG environment variable. You can use wildcards such as '*', but note that the order matters when you use wild cards, e.g. "foosrc:6,*src:3,*:2" sets everything to log level 2.

Since: 1.2

debugUnsetThresholdForName

debugUnsetThresholdForName Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

name: name of the categories to set

-> m () 

Resets all categories with the given name back to the default level.

deinit

deinit :: (HasCallStack, MonadIO m) => m () Source #

Clean up any resources created by GStreamer in init.

It is normally not needed to call this function in a normal application as the resources will automatically be freed when the program terminates. This function is therefore mostly used by testsuites and other memory profiling tools.

After this call GStreamer (including this method) should not be used anymore.

dynamicTypeRegister

dynamicTypeRegister :: (HasCallStack, MonadIO m, IsPlugin a) => a -> GType -> m Bool Source #

No description available in the introspection data.

errorGetMessage

errorGetMessage Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word32

domain: the GStreamer error domain this error belongs to.

-> Int32

code: the error code belonging to the domain.

-> m Text

Returns: a newly allocated string describing the error message (in UTF-8 encoding)

Get a string describing the error message in the current locale.

filenameToUri

filenameToUri Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> [Char]

filename: absolute or relative file name path

-> m Text

Returns: newly-allocated URI string, or NULL on error. The caller must free the URI string with free when no longer needed. (Can throw GError)

Similar to filenameToUri, but attempts to handle relative file paths as well. Before converting filename into an URI, it will be prefixed by the current working directory if it is a relative path, and then the path will be canonicalised so that it doesn't contain any './' or '../' segments.

On Windows filename should be in UTF-8 encoding.

flowGetName

flowGetName Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> FlowReturn

ret: a FlowReturn to get the name of.

-> m Text

Returns: a static string with the name of the flow return.

Gets a string representing the given flow return.

flowToQuark

flowToQuark Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> FlowReturn

ret: a FlowReturn to get the quark of.

-> m Word32

Returns: the quark associated with the flow return or 0 if an invalid return was specified.

Get the unique quark for the given GstFlowReturn.

formatsContains

formatsContains Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> [Format]

formats: The format array to search

-> Format

format: the format to find

-> m Bool

Returns: True if the format is found inside the array

See if the given format is inside the format array.

getMainExecutablePath

getMainExecutablePath Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m (Maybe Text)

Returns: The path of the executable that initialized GStreamer, or Nothing if it could not be determined.

This helper is mostly helpful for plugins that need to inspect the folder of the main executable to determine their set of features.

When a plugin is initialized from the gst-plugin-scanner external process, the returned path will be the same as from the parent process.

Since: 1.14

init

init Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Maybe [Text]

argv: pointer to application's argv

-> m (Maybe [Text]) 

Initializes the GStreamer library, setting up internal path lists, registering built-in elements, and loading standard plugins.

Unless the plugin registry is disabled at compile time, the registry will be loaded. By default this will also check if the registry cache needs to be updated and rescan all plugins if needed. See updateRegistry for details and section <link linkend="gst-running">Running GStreamer Applications</link> for how to disable automatic registry updates.

This function will terminate your program if it was unable to initialize
GStreamer for some reason.  If you want your program to fall back,
use 'GI.Gst.Functions.initCheck' instead.

WARNING: This function does not work in the same way as corresponding functions in other glib-style libraries, such as gtk_init\(\). In particular, unknown command line options cause this function to abort program execution.

initCheck

initCheck Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Maybe [Text]

argv: pointer to application's argv

-> m (Maybe [Text])

(Can throw GError)

Initializes the GStreamer library, setting up internal path lists, registering built-in elements, and loading standard plugins.

This function will return False if GStreamer could not be initialized for some reason. If you want your program to fail fatally, use init instead.

isCapsFeatures

isCapsFeatures :: (HasCallStack, MonadIO m) => Ptr () -> m Bool Source #

No description available in the introspection data.

isInitialized

isInitialized Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Bool

Returns: True if initialization has been done, False otherwise.

Use this function to check if GStreamer has been initialized with init or initCheck.

paramSpecArray

paramSpecArray Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

name: canonical name of the property specified

-> Text

nick: nick name for the property specified

-> Text

blurb: description of the property specified

-> GParamSpec

elementSpec: GParamSpec of the array

-> [ParamFlags]

flags: flags for the property specified

-> m GParamSpec

Returns: a newly created parameter specification

This function creates a GstArray GParamSpec for use by objects/elements that want to expose properties of GstArray type. This function is typically * used in connection with objectClassInstallProperty in a GObjects's instance_init function.

Since: 1.14

paramSpecFraction

paramSpecFraction Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

name: canonical name of the property specified

-> Text

nick: nick name for the property specified

-> Text

blurb: description of the property specified

-> Int32

minNum: minimum value (fraction numerator)

-> Int32

minDenom: minimum value (fraction denominator)

-> Int32

maxNum: maximum value (fraction numerator)

-> Int32

maxDenom: maximum value (fraction denominator)

-> Int32

defaultNum: default value (fraction numerator)

-> Int32

defaultDenom: default value (fraction denominator)

-> [ParamFlags]

flags: flags for the property specified

-> m (Maybe GParamSpec)

Returns: a newly created parameter specification

This function creates a fraction GParamSpec for use by objects/elements that want to expose properties of fraction type. This function is typically used in connection with objectClassInstallProperty in a GObjects's instance_init function.

parentBufferMetaApiGetType

parentBufferMetaApiGetType :: (HasCallStack, MonadIO m) => m GType Source #

No description available in the introspection data.

parseBinFromDescription

parseBinFromDescription Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

binDescription: command line describing the bin

-> Bool

ghostUnlinkedPads: whether to automatically create ghost pads for unlinked source or sink pads within the bin

-> m (Maybe Bin)

Returns: a newly-created bin, or Nothing if an error occurred. (Can throw GError)

This is a convenience wrapper around parseLaunch to create a Bin from a gst-launch-style pipeline description. See parseLaunch and the gst-launch man page for details about the syntax. Ghost pads on the bin for unlinked source or sink pads within the bin can automatically be created (but only a maximum of one ghost pad for each direction will be created; if you expect multiple unlinked source pads or multiple unlinked sink pads and want them all ghosted, you will have to create the ghost pads yourself).

parseBinFromDescriptionFull

parseBinFromDescriptionFull Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

binDescription: command line describing the bin

-> Bool

ghostUnlinkedPads: whether to automatically create ghost pads for unlinked source or sink pads within the bin

-> Maybe ParseContext

context: a parse context allocated with parseContextNew, or Nothing

-> [ParseFlags]

flags: parsing options, or GST_PARSE_FLAG_NONE

-> m (Maybe Element)

Returns: a newly-created element, which is guaranteed to be a bin unless GST_FLAG_NO_SINGLE_ELEMENT_BINS was passed, or Nothing if an error occurred. (Can throw GError)

This is a convenience wrapper around parseLaunch to create a Bin from a gst-launch-style pipeline description. See parseLaunch and the gst-launch man page for details about the syntax. Ghost pads on the bin for unlinked source or sink pads within the bin can automatically be created (but only a maximum of one ghost pad for each direction will be created; if you expect multiple unlinked source pads or multiple unlinked sink pads and want them all ghosted, you will have to create the ghost pads yourself).

parseLaunch

parseLaunch Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

pipelineDescription: the command line describing the pipeline

-> m (Maybe Element)

Returns: a new element on success, Nothing on failure. If more than one toplevel element is specified by the pipelineDescription, all elements are put into a Pipeline, which than is returned. (Can throw GError)

Create a new pipeline based on command line syntax. Please note that you might get a return value that is not Nothing even though the error is set. In this case there was a recoverable parsing error and you can try to play the pipeline.

parseLaunchFull

parseLaunchFull Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

pipelineDescription: the command line describing the pipeline

-> Maybe ParseContext

context: a parse context allocated with parseContextNew, or Nothing

-> [ParseFlags]

flags: parsing options, or GST_PARSE_FLAG_NONE

-> m (Maybe Element)

Returns: a new element on success, Nothing on failure. If more than one toplevel element is specified by the pipelineDescription, all elements are put into a Pipeline, which then is returned (unless the GST_PARSE_FLAG_PLACE_IN_BIN flag is set, in which case they are put in a Bin instead). (Can throw GError)

Create a new pipeline based on command line syntax. Please note that you might get a return value that is not Nothing even though the error is set. In this case there was a recoverable parsing error and you can try to play the pipeline.

parseLaunchv

parseLaunchv Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> [Text]

argv: null-terminated array of arguments

-> m (Maybe Element)

Returns: a new element on success and Nothing on failure. (Can throw GError)

Create a new element based on command line syntax. error will contain an error message if an erroneous pipeline is specified. An error does not mean that the pipeline could not be constructed.

parseLaunchvFull

parseLaunchvFull Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> [Text]

argv: null-terminated array of arguments

-> Maybe ParseContext

context: a parse context allocated with parseContextNew, or Nothing

-> [ParseFlags]

flags: parsing options, or GST_PARSE_FLAG_NONE

-> m (Maybe Element)

Returns: a new element on success; on failure, either Nothing or a partially-constructed bin or element will be returned and error will be set (unless you passed GST_PARSE_FLAG_FATAL_ERRORS in flags, then Nothing will always be returned on failure) (Can throw GError)

Create a new element based on command line syntax. error will contain an error message if an erroneous pipeline is specified. An error does not mean that the pipeline could not be constructed.

protectionFilterSystemsByAvailableDecryptors

protectionFilterSystemsByAvailableDecryptors Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

systemIdentifiers: A null terminated array of strings that contains the UUID values of each protection system that is to be checked.

-> m (Maybe [Text])

Returns: A null terminated array containing all the systemIdentifiers supported by the set of available decryptors, or Nothing if no matches were found.

Iterates the supplied list of UUIDs and checks the GstRegistry for all the decryptors supporting one of the supplied UUIDs.

Since: 1.14

protectionMetaApiGetType

protectionMetaApiGetType :: (HasCallStack, MonadIO m) => m GType Source #

No description available in the introspection data.

protectionSelectSystem

protectionSelectSystem Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> [Text]

systemIdentifiers: A null terminated array of strings that contains the UUID values of each protection system that is to be checked.

-> m (Maybe Text)

Returns: One of the strings from systemIdentifiers that indicates the highest ranked element that implements the protection system indicated by that system ID, or Nothing if no element has been found.

Iterates the supplied list of UUIDs and checks the GstRegistry for an element that supports one of the supplied UUIDs. If more than one element matches, the system ID of the highest ranked element is selected.

Since: 1.6

referenceTimestampMetaApiGetType

referenceTimestampMetaApiGetType :: (HasCallStack, MonadIO m) => m GType Source #

No description available in the introspection data.

segtrapIsEnabled

segtrapIsEnabled Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Bool

Returns: True if GStreamer is allowed to install a custom SIGSEGV handler.

Some functions in the GStreamer core might install a custom SIGSEGV handler to better catch and report errors to the application. Currently this feature is enabled by default when loading plugins.

Applications might want to disable this behaviour with the segtrapSetEnabled function. This is typically done if the application wants to install its own handler without GStreamer interfering.

segtrapSetEnabled

segtrapSetEnabled Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bool

enabled: whether a custom SIGSEGV handler should be installed.

-> m () 

Applications might want to disable/enable the SIGSEGV handling of the GStreamer core. See segtrapIsEnabled for more information.

staticCapsGetType

staticCapsGetType :: (HasCallStack, MonadIO m) => m GType Source #

No description available in the introspection data.

staticPadTemplateGetType

staticPadTemplateGetType :: (HasCallStack, MonadIO m) => m GType Source #

No description available in the introspection data.

tagExists

tagExists Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

tag: name of the tag

-> m Bool

Returns: True if the type is already registered

Checks if the given type is already registered.

tagGetDescription

tagGetDescription Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

tag: the tag

-> m (Maybe Text)

Returns: the human-readable description of this tag

Returns the human-readable description of this tag, You must not change or free this string.

tagGetFlag

tagGetFlag Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

tag: the tag

-> m TagFlag

Returns: the flag of this tag.

Gets the flag of tag.

tagGetNick

tagGetNick Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

tag: the tag

-> m (Maybe Text)

Returns: the human-readable name of this tag

Returns the human-readable name of this tag, You must not change or free this string.

tagGetType

tagGetType Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

tag: the tag

-> m GType

Returns: the GType of this tag

Gets the GType used for this tag.

tagIsFixed

tagIsFixed Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

tag: tag to check

-> m Bool

Returns: True, if the given tag is fixed.

Checks if the given tag is fixed. A fixed tag can only contain one value. Unfixed tags can contain lists of values.

tagMergeStringsWithComma

tagMergeStringsWithComma Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

src: GValue to copy from

-> m GValue 

This is a convenience function for the func argument of tagRegister. It concatenates all given strings using a comma. The tag must be registered as a G_TYPE_STRING or this function will fail.

tagMergeUseFirst

tagMergeUseFirst Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

src: GValue to copy from

-> m GValue 

This is a convenience function for the func argument of tagRegister. It creates a copy of the first value from the list.

tagRegister

tagRegister Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

name: the name or identifier string

-> TagFlag

flag: a flag describing the type of tag info

-> GType

type: the type this data is in

-> Text

nick: human-readable name

-> Text

blurb: a human-readable description about this tag

-> Maybe TagMergeFunc

func: function for merging multiple values of this tag, or Nothing

-> m () 

Registers a new tag type for the use with GStreamer's type system. If a type with that name is already registered, that one is used. The old registration may have used a different type however. So don't rely on your supplied values.

Important: if you do not supply a merge function the implication will be that there can only be one single value for this tag in a tag list and any additional values will silently be discarded when being added (unless GST_TAG_MERGE_REPLACE, GST_TAG_MERGE_REPLACE_ALL, or GST_TAG_MERGE_PREPEND is used as merge mode, in which case the new value will replace the old one in the list).

The merge function will be called from tagListCopyValue when it is required that one or more values for a tag be condensed into one single value. This may happen from tagListGetString, tagListGetInt, tagListGetDouble etc. What will happen exactly in that case depends on how the tag was registered and if a merge function was supplied and if so which one.

Two default merge functions are provided: tagMergeUseFirst and tagMergeStringsWithComma.

tagRegisterStatic

tagRegisterStatic Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

name: the name or identifier string (string constant)

-> TagFlag

flag: a flag describing the type of tag info

-> GType

type: the type this data is in

-> Text

nick: human-readable name or short description (string constant)

-> Text

blurb: a human-readable description for this tag (string constant)

-> Maybe TagMergeFunc

func: function for merging multiple values of this tag, or Nothing

-> m () 

Registers a new tag type for the use with GStreamer's type system.

Same as tagRegister, but name, nick, and blurb must be static strings or inlined strings, as they will not be copied. (GStreamer plugins will be made resident once loaded, so this function can be used even from dynamically loaded plugins.)

typeFindGetType

typeFindGetType :: (HasCallStack, MonadIO m) => m GType Source #

No description available in the introspection data.

updateRegistry

updateRegistry Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Bool

Returns: True if the registry has been updated successfully (does not imply that there were changes), otherwise False.

Forces GStreamer to re-scan its plugin paths and update the default plugin registry.

Applications will almost never need to call this function, it is only useful if the application knows new plugins have been installed (or old ones removed) since the start of the application (or, to be precise, the first call to init) and the application wants to make use of any newly-installed plugins without restarting the application.

Applications should assume that the registry update is neither atomic nor thread-safe and should therefore not have any dynamic pipelines running (including the playbin and decodebin elements) and should also not create any elements or access the GStreamer registry while the update is in progress.

Note that this function may block for a significant amount of time.

utilArrayBinarySearch

utilArrayBinarySearch Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Ptr ()

array: the sorted input array

-> Word32

numElements: number of elements in the array

-> Word64

elementSize: size of every element in bytes

-> CompareDataFunc

searchFunc: function to compare two elements, searchData will always be passed as second argument

-> SearchMode

mode: search mode that should be used

-> Ptr ()

searchData: element that should be found

-> m (Ptr ())

Returns: The address of the found element or Nothing if nothing was found

Searches inside array for searchData by using the comparison function searchFunc. array must be sorted ascending.

As searchData is always passed as second argument to searchFunc it's not required that searchData has the same type as the array elements.

The complexity of this search function is O(log (num_elements)).

utilDoubleToFraction

utilDoubleToFraction Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Double

src: gdouble to transform

-> m (Int32, Int32) 

Transforms a gdouble to a fraction and simplifies the result.

utilDumpBuffer

utilDumpBuffer Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Buffer

buf: a Buffer whose memory to dump

-> m () 

Dumps the buffer memory into a hex representation. Useful for debugging.

Since: 1.14

utilDumpMem

utilDumpMem Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> ByteString

mem: a pointer to the memory to dump

-> m () 

Dumps the memory block into a hex representation. Useful for debugging.

utilFractionAdd

utilFractionAdd Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Int32

aN: Numerator of first value

-> Int32

aD: Denominator of first value

-> Int32

bN: Numerator of second value

-> Int32

bD: Denominator of second value

-> m (Bool, Int32, Int32)

Returns: False on overflow, True otherwise.

Adds the fractions aN/aD and bN/bD and stores the result in resN and resD.

utilFractionCompare

utilFractionCompare Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Int32

aN: Numerator of first value

-> Int32

aD: Denominator of first value

-> Int32

bN: Numerator of second value

-> Int32

bD: Denominator of second value

-> m Int32

Returns: -1 if a < b; 0 if a = b; 1 if a > b.

Compares the fractions aN/aD and bN/bD and returns -1 if a < b, 0 if a = b and 1 if a > b.

utilFractionMultiply

utilFractionMultiply Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Int32

aN: Numerator of first value

-> Int32

aD: Denominator of first value

-> Int32

bN: Numerator of second value

-> Int32

bD: Denominator of second value

-> m (Bool, Int32, Int32)

Returns: False on overflow, True otherwise.

Multiplies the fractions aN/aD and bN/bD and stores the result in resN and resD.

utilFractionToDouble

utilFractionToDouble Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Int32

srcN: Fraction numerator as gint

-> Int32

srcD: Fraction denominator gint

-> m Double 

Transforms a fraction to a gdouble.

utilGdoubleToGuint64

utilGdoubleToGuint64 :: (HasCallStack, MonadIO m) => Double -> m Word64 Source #

No description available in the introspection data.

utilGetObjectArray

utilGetObjectArray Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) 
=> a

object: the object to set the array to

-> Text

name: the name of the property to set

-> m (Bool, ValueArray) 

Get a property of type GST_TYPE_ARRAY and transform it into a ValueArray. This allow language bindings to get GST_TYPE_ARRAY properties which are otherwise not an accessible type.

Since: 1.12

utilGetTimestamp

utilGetTimestamp Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Word64

Returns: the timestamp

Get a timestamp as GstClockTime to be used for interval measurements. The timestamp should not be interpreted in any other way.

utilGreatestCommonDivisor

utilGreatestCommonDivisor Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Int32

a: First value as gint

-> Int32

b: Second value as gint

-> m Int32

Returns: Greatest common divisor of a and b

Calculates the greatest common divisor of a and b.

utilGreatestCommonDivisorInt64

utilGreatestCommonDivisorInt64 Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Int64

a: First value as gint64

-> Int64

b: Second value as gint64

-> m Int64

Returns: Greatest common divisor of a and b

Calculates the greatest common divisor of a and b.

utilGroupIdNext

utilGroupIdNext Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Word32

Returns: A constantly incrementing unsigned integer, which might overflow back to 0 at some point.

Return a constantly incrementing group id.

This function is used to generate a new group-id for the stream-start event.

This function never returns GROUP_ID_INVALID (which is 0)

utilGuint64ToGdouble

utilGuint64ToGdouble :: (HasCallStack, MonadIO m) => Word64 -> m Double Source #

No description available in the introspection data.

utilSeqnumCompare

utilSeqnumCompare Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word32

s1: A sequence number.

-> Word32

s2: Another sequence number.

-> m Int32

Returns: A negative number if s1 is before s2, 0 if they are equal, or a positive number if s1 is after s2.

Compare two sequence numbers, handling wraparound.

The current implementation just returns (gint32)(s1 - s2).

utilSeqnumNext

utilSeqnumNext Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Word32

Returns: A constantly incrementing 32-bit unsigned integer, which might overflow at some point. Use utilSeqnumCompare to make sure you handle wraparound correctly.

Return a constantly incrementing sequence number.

This function is used internally to GStreamer to be able to determine which events and messages are "the same". For example, elements may set the seqnum on a segment-done message to be the same as that of the last seek event, to indicate that event and the message correspond to the same segment.

This function never returns SEQNUM_INVALID (which is 0).

utilSetObjectArg

utilSetObjectArg Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) 
=> a

object: the object to set the argument of

-> Text

name: the name of the argument to set

-> Text

value: the string value to set

-> m () 

Converts the string value to the type of the objects argument and sets the argument with it.

Note that this function silently returns if object has no property named name or when value cannot be converted to the type of the property.

utilSetObjectArray

utilSetObjectArray Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) 
=> a

object: the object to set the array to

-> Text

name: the name of the property to set

-> ValueArray

array: a ValueArray containing the values

-> m Bool 

Transfer a ValueArray to GST_TYPE_ARRAY and set this value on the specified property name. This allow language bindings to set GST_TYPE_ARRAY properties which are otherwise not an accessible type.

Since: 1.12

utilSetValueFromString

utilSetValueFromString Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

valueStr: the string to get the value from

-> m GValue 

Converts the string to the type of the value and sets the value with it.

Note that this function is dangerous as it does not return any indication if the conversion worked or not.

utilUint64Scale

utilUint64Scale Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word64

val: the number to scale

-> Word64

num: the numerator of the scale ratio

-> Word64

denom: the denominator of the scale ratio

-> m Word64

Returns: val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer it is truncated. See also utilUint64ScaleRound, utilUint64ScaleCeil, utilUint64ScaleInt, utilUint64ScaleIntRound, utilUint64ScaleIntCeil.

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision.

This function can potentially be very slow if val and num are both greater than G_MAXUINT32.

utilUint64ScaleCeil

utilUint64ScaleCeil Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word64

val: the number to scale

-> Word64

num: the numerator of the scale ratio

-> Word64

denom: the denominator of the scale ratio

-> m Word64

Returns: val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also utilUint64Scale, utilUint64ScaleRound, utilUint64ScaleInt, utilUint64ScaleIntRound, utilUint64ScaleIntCeil.

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision.

This function can potentially be very slow if val and num are both greater than G_MAXUINT32.

utilUint64ScaleInt

utilUint64ScaleInt Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word64

val: guint64 (such as a GstClockTime) to scale.

-> Int32

num: numerator of the scale factor.

-> Int32

denom: denominator of the scale factor.

-> m Word64

Returns: val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is truncated. See also utilUint64ScaleIntRound, utilUint64ScaleIntCeil, utilUint64Scale, utilUint64ScaleRound, utilUint64ScaleCeil.

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and denom must be positive.

utilUint64ScaleIntCeil

utilUint64ScaleIntCeil Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word64

val: guint64 (such as a GstClockTime) to scale.

-> Int32

num: numerator of the scale factor.

-> Int32

denom: denominator of the scale factor.

-> m Word64

Returns: val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also utilUint64ScaleInt, utilUint64ScaleIntRound, utilUint64Scale, utilUint64ScaleRound, utilUint64ScaleCeil.

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and denom must be positive.

utilUint64ScaleIntRound

utilUint64ScaleIntRound Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word64

val: guint64 (such as a GstClockTime) to scale.

-> Int32

num: numerator of the scale factor.

-> Int32

denom: denominator of the scale factor.

-> m Word64

Returns: val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also utilUint64ScaleInt, utilUint64ScaleIntCeil, utilUint64Scale, utilUint64ScaleRound, utilUint64ScaleCeil.

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and denom must be positive.

utilUint64ScaleRound

utilUint64ScaleRound Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Word64

val: the number to scale

-> Word64

num: the numerator of the scale ratio

-> Word64

denom: the denominator of the scale ratio

-> m Word64

Returns: val * num / denom. In the case of an overflow, this function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also utilUint64Scale, utilUint64ScaleCeil, utilUint64ScaleInt, utilUint64ScaleIntRound, utilUint64ScaleIntCeil.

Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision.

This function can potentially be very slow if val and num are both greater than G_MAXUINT32.

valueCanCompare

valueCanCompare Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value1: a value to compare

-> GValue

value2: another value to compare

-> m Bool

Returns: True if the values can be compared

Determines if value1 and value2 can be compared.

valueCanIntersect

valueCanIntersect Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value1: a value to intersect

-> GValue

value2: another value to intersect

-> m Bool

Returns: True if the values can intersect

Determines if intersecting two values will produce a valid result. Two values will produce a valid intersection if they have the same type.

valueCanSubtract

valueCanSubtract Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

minuend: the value to subtract from

-> GValue

subtrahend: the value to subtract

-> m Bool

Returns: True if a subtraction is possible

Checks if it's possible to subtract subtrahend from minuend.

valueCanUnion

valueCanUnion Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value1: a value to union

-> GValue

value2: another value to union

-> m Bool

Returns: True if there is a function allowing the two values to be unioned.

Determines if value1 and value2 can be non-trivially unioned. Any two values can be trivially unioned by adding both of them to a GstValueList. However, certain types have the possibility to be unioned in a simpler way. For example, an integer range and an integer can be unioned if the integer is a subset of the integer range. If there is the possibility that two values can be unioned, this function returns True.

valueCompare

valueCompare Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value1: a value to compare

-> GValue

value2: another value to compare

-> m Int32

Returns: comparison result

Compares value1 and value2. If value1 and value2 cannot be compared, the function returns GST_VALUE_UNORDERED. Otherwise, if value1 is greater than value2, GST_VALUE_GREATER_THAN is returned. If value1 is less than value2, GST_VALUE_LESS_THAN is returned. If the values are equal, GST_VALUE_EQUAL is returned.

valueDeserialize

valueDeserialize Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Text

src: string to deserialize

-> m (Bool, GValue)

Returns: True on success

Tries to deserialize a string into the type specified by the given GValue. If the operation succeeds, True is returned, False otherwise.

valueFixate

valueFixate Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

dest: the Value destination

-> GValue

src: the Value to fixate

-> m Bool

Returns: True if dest contains a fixated version of src.

Fixate src into a new value dest. For ranges, the first element is taken. For lists and arrays, the first item is fixated and returned. If src is already fixed, this function returns False.

valueFractionMultiply

valueFractionMultiply Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

product: a GValue initialized to GST_TYPE_FRACTION

-> GValue

factor1: a GValue initialized to GST_TYPE_FRACTION

-> GValue

factor2: a GValue initialized to GST_TYPE_FRACTION

-> m Bool

Returns: False in case of an error (like integer overflow), True otherwise.

Multiplies the two Value items containing a GST_TYPE_FRACTION and sets product to the product of the two fractions.

valueFractionSubtract

valueFractionSubtract Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

dest: a GValue initialized to GST_TYPE_FRACTION

-> GValue

minuend: a GValue initialized to GST_TYPE_FRACTION

-> GValue

subtrahend: a GValue initialized to GST_TYPE_FRACTION

-> m Bool

Returns: False in case of an error (like integer overflow), True otherwise.

Subtracts the subtrahend from the minuend and sets dest to the result.

valueGetBitmask

valueGetBitmask Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_BITMASK

-> m Word64

Returns: the bitmask.

Gets the bitmask specified by value.

valueGetCaps

valueGetCaps Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_CAPS

-> m Caps

Returns: the contents of value

Gets the contents of value. The reference count of the returned Caps will not be modified, therefore the caller must take one before getting rid of the value.

valueGetCapsFeatures

valueGetCapsFeatures Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_CAPS_FEATURES

-> m CapsFeatures

Returns: the contents of value

Gets the contents of value.

valueGetDoubleRangeMax

valueGetDoubleRangeMax Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_DOUBLE_RANGE

-> m Double

Returns: the maximum of the range

Gets the maximum of the range specified by value.

valueGetDoubleRangeMin

valueGetDoubleRangeMin Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_DOUBLE_RANGE

-> m Double

Returns: the minimum of the range

Gets the minimum of the range specified by value.

valueGetFlagsetFlags

valueGetFlagsetFlags Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FLAG_SET

-> m Word32

Returns: the flags field of the flagset instance.

Retrieve the flags field of a GstFlagSet value.

Since: 1.6

valueGetFlagsetMask

valueGetFlagsetMask Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FLAG_SET

-> m Word32

Returns: the mask field of the flagset instance.

Retrieve the mask field of a GstFlagSet value.

Since: 1.6

valueGetFractionDenominator

valueGetFractionDenominator Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FRACTION

-> m Int32

Returns: the denominator of the fraction.

Gets the denominator of the fraction specified by value.

valueGetFractionNumerator

valueGetFractionNumerator Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FRACTION

-> m Int32

Returns: the numerator of the fraction.

Gets the numerator of the fraction specified by value.

valueGetFractionRangeMax

valueGetFractionRangeMax Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FRACTION_RANGE

-> m (Maybe GValue)

Returns: the maximum of the range

Gets the maximum of the range specified by value.

valueGetFractionRangeMin

valueGetFractionRangeMin Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FRACTION_RANGE

-> m (Maybe GValue)

Returns: the minimum of the range

Gets the minimum of the range specified by value.

valueGetInt64RangeMax

valueGetInt64RangeMax Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT64_RANGE

-> m Int64

Returns: the maximum of the range

Gets the maximum of the range specified by value.

valueGetInt64RangeMin

valueGetInt64RangeMin Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT64_RANGE

-> m Int64

Returns: the minimum of the range

Gets the minimum of the range specified by value.

valueGetInt64RangeStep

valueGetInt64RangeStep Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT64_RANGE

-> m Int64

Returns: the step of the range

Gets the step of the range specified by value.

valueGetIntRangeMax

valueGetIntRangeMax Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT_RANGE

-> m Int32

Returns: the maximum of the range

Gets the maximum of the range specified by value.

valueGetIntRangeMin

valueGetIntRangeMin Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT_RANGE

-> m Int32

Returns: the minimum of the range

Gets the minimum of the range specified by value.

valueGetIntRangeStep

valueGetIntRangeStep Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT_RANGE

-> m Int32

Returns: the step of the range

Gets the step of the range specified by value.

valueGetStructure

valueGetStructure Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_STRUCTURE

-> m Structure

Returns: the contents of value

Gets the contents of value.

valueInitAndCopy

valueInitAndCopy Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

src: the source value

-> m GValue 

Initialises the target value to be of the same type as source and then copies the contents from source to target.

valueIntersect

valueIntersect Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value1: a value to intersect

-> GValue

value2: another value to intersect

-> m (Bool, GValue)

Returns: True if the intersection is non-empty

Calculates the intersection of two values. If the values have a non-empty intersection, the value representing the intersection is placed in dest, unless Nothing. If the intersection is non-empty, dest is not modified.

valueIsFixed

valueIsFixed Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: the Value to check

-> m Bool

Returns: true if the value is "fixed".

Tests if the given GValue, if available in a GstStructure (or any other container) contains a "fixed" (which means: one value) or an "unfixed" (which means: multiple possible values, such as data lists or data ranges) value.

valueIsSubset

valueIsSubset Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value1: a Value

-> GValue

value2: a Value

-> m Bool

Returns: True is value1 is a subset of value2

Check that value1 is a subset of value2.

valueRegister

valueRegister Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> ValueTable

table: structure containing functions to register

-> m () 

Registers functions to perform calculations on Value items of a given type. Each type can only be added once.

valueSerialize

valueSerialize Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a Value to serialize

-> m (Maybe Text)

Returns: the serialization for value or Nothing if none exists

tries to transform the given value into a string representation that allows getting back this string later on using valueDeserialize.

Free-function: g_free

valueSetBitmask

valueSetBitmask Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_BITMASK

-> Word64

bitmask: the bitmask

-> m () 

Sets value to the bitmask specified by bitmask.

valueSetCaps

valueSetCaps Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_CAPS

-> Caps

caps: the caps to set the value to

-> m () 

Sets the contents of value to caps. A reference to the provided caps will be taken by the value.

valueSetCapsFeatures

valueSetCapsFeatures Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_CAPS_FEATURES

-> CapsFeatures

features: the features to set the value to

-> m () 

Sets the contents of value to features.

valueSetDoubleRange

valueSetDoubleRange Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_DOUBLE_RANGE

-> Double

start: the start of the range

-> Double

end: the end of the range

-> m () 

Sets value to the range specified by start and end.

valueSetFlagset

valueSetFlagset Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FLAG_SET

-> Word32

flags: The value of the flags set or unset

-> Word32

mask: The mask indicate which flags bits must match for comparisons

-> m () 

Sets value to the flags and mask values provided in flags and mask. The flags value indicates the values of flags, the mask represents which bits in the flag value have been set, and which are "don't care"

Since: 1.6

valueSetFraction

valueSetFraction Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FRACTION

-> Int32

numerator: the numerator of the fraction

-> Int32

denominator: the denominator of the fraction

-> m () 

Sets value to the fraction specified by numerator over denominator. The fraction gets reduced to the smallest numerator and denominator, and if necessary the sign is moved to the numerator.

valueSetFractionRange

valueSetFractionRange Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FRACTION_RANGE

-> GValue

start: the start of the range (a GST_TYPE_FRACTION GValue)

-> GValue

end: the end of the range (a GST_TYPE_FRACTION GValue)

-> m () 

Sets value to the range specified by start and end.

valueSetFractionRangeFull

valueSetFractionRangeFull Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_FRACTION_RANGE

-> Int32

numeratorStart: the numerator start of the range

-> Int32

denominatorStart: the denominator start of the range

-> Int32

numeratorEnd: the numerator end of the range

-> Int32

denominatorEnd: the denominator end of the range

-> m () 

Sets value to the range specified by numeratorStart/denominatorStart and numeratorEnd/denominatorEnd.

valueSetInt64Range

valueSetInt64Range Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT64_RANGE

-> Int64

start: the start of the range

-> Int64

end: the end of the range

-> m () 

Sets value to the range specified by start and end.

valueSetInt64RangeStep

valueSetInt64RangeStep Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT64_RANGE

-> Int64

start: the start of the range

-> Int64

end: the end of the range

-> Int64

step: the step of the range

-> m () 

Sets value to the range specified by start, end and step.

valueSetIntRange

valueSetIntRange Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT_RANGE

-> Int32

start: the start of the range

-> Int32

end: the end of the range

-> m () 

Sets value to the range specified by start and end.

valueSetIntRangeStep

valueSetIntRangeStep Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_INT_RANGE

-> Int32

start: the start of the range

-> Int32

end: the end of the range

-> Int32

step: the step of the range

-> m () 

Sets value to the range specified by start, end and step.

valueSetStructure

valueSetStructure Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value: a GValue initialized to GST_TYPE_STRUCTURE

-> Structure

structure: the structure to set the value to

-> m () 

Sets the contents of value to structure.

valueSubtract

valueSubtract Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

minuend: the value to subtract from

-> GValue

subtrahend: the value to subtract

-> m (Bool, GValue)

Returns: True if the subtraction is not empty

Subtracts subtrahend from minuend and stores the result in dest. Note that this means subtraction as in sets, not as in mathematics.

valueUnion

valueUnion Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> GValue

value1: a value to union

-> GValue

value2: another value to union

-> m (Bool, GValue)

Returns: True if the union succeeded.

Creates a GValue corresponding to the union of value1 and value2.

version

version :: (HasCallStack, MonadIO m) => m (Word32, Word32, Word32, Word32) Source #

Gets the version number of the GStreamer library.

versionString

versionString Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> m Text

Returns: a newly allocated string describing this version of GStreamer.

This function returns a string that is useful for describing this version of GStreamer to the outside world: user agent strings, logging, ...