gi-gst-1.0.18: GI/Gst/Structs/Query.hs
{- |
Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
Queries can be performed on pads ('GI.Gst.Objects.Pad.padQuery') and elements
('GI.Gst.Objects.Element.elementQuery'). Please note that some queries might need a running
pipeline to work.
Queries can be created using the gst_query_new_*() functions.
Query values can be set using gst_query_set_*(), and parsed using
gst_query_parse_*() helpers.
The following example shows how to query the duration of a pipeline:
=== /C code/
>
> GstQuery *query;
> gboolean res;
> query = gst_query_new_duration (GST_FORMAT_TIME);
> res = gst_element_query (pipeline, query);
> if (res) {
> gint64 duration;
> gst_query_parse_duration (query, NULL, &duration);
> g_print ("duration = %"GST_TIME_FORMAT, GST_TIME_ARGS (duration));
> } else {
> g_print ("duration query failed...");
> }
> gst_query_unref (query);
-}
#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Gst.Structs.Query
(
-- * Exported types
Query(..) ,
newZeroQuery ,
noQuery ,
-- * Methods
-- ** addAllocationMeta #method:addAllocationMeta#
#if ENABLE_OVERLOADING
QueryAddAllocationMetaMethodInfo ,
#endif
queryAddAllocationMeta ,
-- ** addAllocationParam #method:addAllocationParam#
#if ENABLE_OVERLOADING
QueryAddAllocationParamMethodInfo ,
#endif
queryAddAllocationParam ,
-- ** addAllocationPool #method:addAllocationPool#
#if ENABLE_OVERLOADING
QueryAddAllocationPoolMethodInfo ,
#endif
queryAddAllocationPool ,
-- ** addBufferingRange #method:addBufferingRange#
#if ENABLE_OVERLOADING
QueryAddBufferingRangeMethodInfo ,
#endif
queryAddBufferingRange ,
-- ** addSchedulingMode #method:addSchedulingMode#
#if ENABLE_OVERLOADING
QueryAddSchedulingModeMethodInfo ,
#endif
queryAddSchedulingMode ,
-- ** findAllocationMeta #method:findAllocationMeta#
#if ENABLE_OVERLOADING
QueryFindAllocationMetaMethodInfo ,
#endif
queryFindAllocationMeta ,
-- ** getNAllocationMetas #method:getNAllocationMetas#
#if ENABLE_OVERLOADING
QueryGetNAllocationMetasMethodInfo ,
#endif
queryGetNAllocationMetas ,
-- ** getNAllocationParams #method:getNAllocationParams#
#if ENABLE_OVERLOADING
QueryGetNAllocationParamsMethodInfo ,
#endif
queryGetNAllocationParams ,
-- ** getNAllocationPools #method:getNAllocationPools#
#if ENABLE_OVERLOADING
QueryGetNAllocationPoolsMethodInfo ,
#endif
queryGetNAllocationPools ,
-- ** getNBufferingRanges #method:getNBufferingRanges#
#if ENABLE_OVERLOADING
QueryGetNBufferingRangesMethodInfo ,
#endif
queryGetNBufferingRanges ,
-- ** getNSchedulingModes #method:getNSchedulingModes#
#if ENABLE_OVERLOADING
QueryGetNSchedulingModesMethodInfo ,
#endif
queryGetNSchedulingModes ,
-- ** getStructure #method:getStructure#
#if ENABLE_OVERLOADING
QueryGetStructureMethodInfo ,
#endif
queryGetStructure ,
-- ** hasSchedulingMode #method:hasSchedulingMode#
#if ENABLE_OVERLOADING
QueryHasSchedulingModeMethodInfo ,
#endif
queryHasSchedulingMode ,
-- ** hasSchedulingModeWithFlags #method:hasSchedulingModeWithFlags#
#if ENABLE_OVERLOADING
QueryHasSchedulingModeWithFlagsMethodInfo,
#endif
queryHasSchedulingModeWithFlags ,
-- ** newAcceptCaps #method:newAcceptCaps#
queryNewAcceptCaps ,
-- ** newAllocation #method:newAllocation#
queryNewAllocation ,
-- ** newBitrate #method:newBitrate#
queryNewBitrate ,
-- ** newBuffering #method:newBuffering#
queryNewBuffering ,
-- ** newCaps #method:newCaps#
queryNewCaps ,
-- ** newContext #method:newContext#
queryNewContext ,
-- ** newConvert #method:newConvert#
queryNewConvert ,
-- ** newCustom #method:newCustom#
queryNewCustom ,
-- ** newDrain #method:newDrain#
queryNewDrain ,
-- ** newDuration #method:newDuration#
queryNewDuration ,
-- ** newFormats #method:newFormats#
queryNewFormats ,
-- ** newLatency #method:newLatency#
queryNewLatency ,
-- ** newPosition #method:newPosition#
queryNewPosition ,
-- ** newScheduling #method:newScheduling#
queryNewScheduling ,
-- ** newSeeking #method:newSeeking#
queryNewSeeking ,
-- ** newSegment #method:newSegment#
queryNewSegment ,
-- ** newUri #method:newUri#
queryNewUri ,
-- ** parseAcceptCaps #method:parseAcceptCaps#
#if ENABLE_OVERLOADING
QueryParseAcceptCapsMethodInfo ,
#endif
queryParseAcceptCaps ,
-- ** parseAcceptCapsResult #method:parseAcceptCapsResult#
#if ENABLE_OVERLOADING
QueryParseAcceptCapsResultMethodInfo ,
#endif
queryParseAcceptCapsResult ,
-- ** parseAllocation #method:parseAllocation#
#if ENABLE_OVERLOADING
QueryParseAllocationMethodInfo ,
#endif
queryParseAllocation ,
-- ** parseBitrate #method:parseBitrate#
#if ENABLE_OVERLOADING
QueryParseBitrateMethodInfo ,
#endif
queryParseBitrate ,
-- ** parseBufferingPercent #method:parseBufferingPercent#
#if ENABLE_OVERLOADING
QueryParseBufferingPercentMethodInfo ,
#endif
queryParseBufferingPercent ,
-- ** parseBufferingRange #method:parseBufferingRange#
#if ENABLE_OVERLOADING
QueryParseBufferingRangeMethodInfo ,
#endif
queryParseBufferingRange ,
-- ** parseBufferingStats #method:parseBufferingStats#
#if ENABLE_OVERLOADING
QueryParseBufferingStatsMethodInfo ,
#endif
queryParseBufferingStats ,
-- ** parseCaps #method:parseCaps#
#if ENABLE_OVERLOADING
QueryParseCapsMethodInfo ,
#endif
queryParseCaps ,
-- ** parseCapsResult #method:parseCapsResult#
#if ENABLE_OVERLOADING
QueryParseCapsResultMethodInfo ,
#endif
queryParseCapsResult ,
-- ** parseContext #method:parseContext#
#if ENABLE_OVERLOADING
QueryParseContextMethodInfo ,
#endif
queryParseContext ,
-- ** parseContextType #method:parseContextType#
#if ENABLE_OVERLOADING
QueryParseContextTypeMethodInfo ,
#endif
queryParseContextType ,
-- ** parseConvert #method:parseConvert#
#if ENABLE_OVERLOADING
QueryParseConvertMethodInfo ,
#endif
queryParseConvert ,
-- ** parseDuration #method:parseDuration#
#if ENABLE_OVERLOADING
QueryParseDurationMethodInfo ,
#endif
queryParseDuration ,
-- ** parseLatency #method:parseLatency#
#if ENABLE_OVERLOADING
QueryParseLatencyMethodInfo ,
#endif
queryParseLatency ,
-- ** parseNFormats #method:parseNFormats#
#if ENABLE_OVERLOADING
QueryParseNFormatsMethodInfo ,
#endif
queryParseNFormats ,
-- ** parseNthAllocationMeta #method:parseNthAllocationMeta#
#if ENABLE_OVERLOADING
QueryParseNthAllocationMetaMethodInfo ,
#endif
queryParseNthAllocationMeta ,
-- ** parseNthAllocationParam #method:parseNthAllocationParam#
#if ENABLE_OVERLOADING
QueryParseNthAllocationParamMethodInfo ,
#endif
queryParseNthAllocationParam ,
-- ** parseNthAllocationPool #method:parseNthAllocationPool#
#if ENABLE_OVERLOADING
QueryParseNthAllocationPoolMethodInfo ,
#endif
queryParseNthAllocationPool ,
-- ** parseNthBufferingRange #method:parseNthBufferingRange#
#if ENABLE_OVERLOADING
QueryParseNthBufferingRangeMethodInfo ,
#endif
queryParseNthBufferingRange ,
-- ** parseNthFormat #method:parseNthFormat#
#if ENABLE_OVERLOADING
QueryParseNthFormatMethodInfo ,
#endif
queryParseNthFormat ,
-- ** parseNthSchedulingMode #method:parseNthSchedulingMode#
#if ENABLE_OVERLOADING
QueryParseNthSchedulingModeMethodInfo ,
#endif
queryParseNthSchedulingMode ,
-- ** parsePosition #method:parsePosition#
#if ENABLE_OVERLOADING
QueryParsePositionMethodInfo ,
#endif
queryParsePosition ,
-- ** parseScheduling #method:parseScheduling#
#if ENABLE_OVERLOADING
QueryParseSchedulingMethodInfo ,
#endif
queryParseScheduling ,
-- ** parseSeeking #method:parseSeeking#
#if ENABLE_OVERLOADING
QueryParseSeekingMethodInfo ,
#endif
queryParseSeeking ,
-- ** parseSegment #method:parseSegment#
#if ENABLE_OVERLOADING
QueryParseSegmentMethodInfo ,
#endif
queryParseSegment ,
-- ** parseUri #method:parseUri#
#if ENABLE_OVERLOADING
QueryParseUriMethodInfo ,
#endif
queryParseUri ,
-- ** parseUriRedirection #method:parseUriRedirection#
#if ENABLE_OVERLOADING
QueryParseUriRedirectionMethodInfo ,
#endif
queryParseUriRedirection ,
-- ** parseUriRedirectionPermanent #method:parseUriRedirectionPermanent#
#if ENABLE_OVERLOADING
QueryParseUriRedirectionPermanentMethodInfo,
#endif
queryParseUriRedirectionPermanent ,
-- ** removeNthAllocationMeta #method:removeNthAllocationMeta#
#if ENABLE_OVERLOADING
QueryRemoveNthAllocationMetaMethodInfo ,
#endif
queryRemoveNthAllocationMeta ,
-- ** removeNthAllocationParam #method:removeNthAllocationParam#
#if ENABLE_OVERLOADING
QueryRemoveNthAllocationParamMethodInfo ,
#endif
queryRemoveNthAllocationParam ,
-- ** removeNthAllocationPool #method:removeNthAllocationPool#
#if ENABLE_OVERLOADING
QueryRemoveNthAllocationPoolMethodInfo ,
#endif
queryRemoveNthAllocationPool ,
-- ** setAcceptCapsResult #method:setAcceptCapsResult#
#if ENABLE_OVERLOADING
QuerySetAcceptCapsResultMethodInfo ,
#endif
querySetAcceptCapsResult ,
-- ** setBitrate #method:setBitrate#
#if ENABLE_OVERLOADING
QuerySetBitrateMethodInfo ,
#endif
querySetBitrate ,
-- ** setBufferingPercent #method:setBufferingPercent#
#if ENABLE_OVERLOADING
QuerySetBufferingPercentMethodInfo ,
#endif
querySetBufferingPercent ,
-- ** setBufferingRange #method:setBufferingRange#
#if ENABLE_OVERLOADING
QuerySetBufferingRangeMethodInfo ,
#endif
querySetBufferingRange ,
-- ** setBufferingStats #method:setBufferingStats#
#if ENABLE_OVERLOADING
QuerySetBufferingStatsMethodInfo ,
#endif
querySetBufferingStats ,
-- ** setCapsResult #method:setCapsResult#
#if ENABLE_OVERLOADING
QuerySetCapsResultMethodInfo ,
#endif
querySetCapsResult ,
-- ** setContext #method:setContext#
#if ENABLE_OVERLOADING
QuerySetContextMethodInfo ,
#endif
querySetContext ,
-- ** setConvert #method:setConvert#
#if ENABLE_OVERLOADING
QuerySetConvertMethodInfo ,
#endif
querySetConvert ,
-- ** setDuration #method:setDuration#
#if ENABLE_OVERLOADING
QuerySetDurationMethodInfo ,
#endif
querySetDuration ,
-- ** setFormatsv #method:setFormatsv#
#if ENABLE_OVERLOADING
QuerySetFormatsvMethodInfo ,
#endif
querySetFormatsv ,
-- ** setLatency #method:setLatency#
#if ENABLE_OVERLOADING
QuerySetLatencyMethodInfo ,
#endif
querySetLatency ,
-- ** setNthAllocationParam #method:setNthAllocationParam#
#if ENABLE_OVERLOADING
QuerySetNthAllocationParamMethodInfo ,
#endif
querySetNthAllocationParam ,
-- ** setNthAllocationPool #method:setNthAllocationPool#
#if ENABLE_OVERLOADING
QuerySetNthAllocationPoolMethodInfo ,
#endif
querySetNthAllocationPool ,
-- ** setPosition #method:setPosition#
#if ENABLE_OVERLOADING
QuerySetPositionMethodInfo ,
#endif
querySetPosition ,
-- ** setScheduling #method:setScheduling#
#if ENABLE_OVERLOADING
QuerySetSchedulingMethodInfo ,
#endif
querySetScheduling ,
-- ** setSeeking #method:setSeeking#
#if ENABLE_OVERLOADING
QuerySetSeekingMethodInfo ,
#endif
querySetSeeking ,
-- ** setSegment #method:setSegment#
#if ENABLE_OVERLOADING
QuerySetSegmentMethodInfo ,
#endif
querySetSegment ,
-- ** setUri #method:setUri#
#if ENABLE_OVERLOADING
QuerySetUriMethodInfo ,
#endif
querySetUri ,
-- ** setUriRedirection #method:setUriRedirection#
#if ENABLE_OVERLOADING
QuerySetUriRedirectionMethodInfo ,
#endif
querySetUriRedirection ,
-- ** setUriRedirectionPermanent #method:setUriRedirectionPermanent#
#if ENABLE_OVERLOADING
QuerySetUriRedirectionPermanentMethodInfo,
#endif
querySetUriRedirectionPermanent ,
-- ** writableStructure #method:writableStructure#
#if ENABLE_OVERLOADING
QueryWritableStructureMethodInfo ,
#endif
queryWritableStructure ,
-- * Properties
-- ** miniObject #attr:miniObject#
{- | The parent 'GI.Gst.Structs.MiniObject.MiniObject' type
-}
getQueryMiniObject ,
#if ENABLE_OVERLOADING
query_miniObject ,
#endif
-- ** type #attr:type#
{- | the 'GI.Gst.Enums.QueryType'
-}
getQueryType ,
#if ENABLE_OVERLOADING
query_type ,
#endif
setQueryType ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Allocator as Gst.Allocator
import {-# SOURCE #-} qualified GI.Gst.Objects.BufferPool as Gst.BufferPool
import {-# SOURCE #-} qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.Context as Gst.Context
import {-# SOURCE #-} qualified GI.Gst.Structs.MiniObject as Gst.MiniObject
import {-# SOURCE #-} qualified GI.Gst.Structs.Structure as Gst.Structure
-- | Memory-managed wrapper type.
newtype Query = Query (ManagedPtr Query)
foreign import ccall "gst_query_get_type" c_gst_query_get_type ::
IO GType
instance BoxedObject Query where
boxedType _ = c_gst_query_get_type
-- | Construct a `Query` struct initialized to zero.
newZeroQuery :: MonadIO m => m Query
newZeroQuery = liftIO $ callocBoxedBytes 72 >>= wrapBoxed Query
instance tag ~ 'AttrSet => Constructible Query tag where
new _ attrs = do
o <- newZeroQuery
GI.Attributes.set o attrs
return o
-- | A convenience alias for `Nothing` :: `Maybe` `Query`.
noQuery :: Maybe Query
noQuery = Nothing
{- |
Get the value of the “@mini_object@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' query #miniObject
@
-}
getQueryMiniObject :: MonadIO m => Query -> m Gst.MiniObject.MiniObject
getQueryMiniObject s = liftIO $ withManagedPtr s $ \ptr -> do
let val = ptr `plusPtr` 0 :: (Ptr Gst.MiniObject.MiniObject)
val' <- (newPtr Gst.MiniObject.MiniObject) val
return val'
#if ENABLE_OVERLOADING
data QueryMiniObjectFieldInfo
instance AttrInfo QueryMiniObjectFieldInfo where
type AttrAllowedOps QueryMiniObjectFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint QueryMiniObjectFieldInfo = (~) (Ptr Gst.MiniObject.MiniObject)
type AttrBaseTypeConstraint QueryMiniObjectFieldInfo = (~) Query
type AttrGetType QueryMiniObjectFieldInfo = Gst.MiniObject.MiniObject
type AttrLabel QueryMiniObjectFieldInfo = "mini_object"
type AttrOrigin QueryMiniObjectFieldInfo = Query
attrGet _ = getQueryMiniObject
attrSet _ = undefined
attrConstruct = undefined
attrClear _ = undefined
query_miniObject :: AttrLabelProxy "miniObject"
query_miniObject = AttrLabelProxy
#endif
{- |
Get the value of the “@type@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' query #type
@
-}
getQueryType :: MonadIO m => Query -> m Gst.Enums.QueryType
getQueryType s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 64) :: IO CUInt
let val' = (toEnum . fromIntegral) val
return val'
{- |
Set the value of the “@type@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' query [ #type 'Data.GI.Base.Attributes.:=' value ]
@
-}
setQueryType :: MonadIO m => Query -> Gst.Enums.QueryType -> m ()
setQueryType s val = liftIO $ withManagedPtr s $ \ptr -> do
let val' = (fromIntegral . fromEnum) val
poke (ptr `plusPtr` 64) (val' :: CUInt)
#if ENABLE_OVERLOADING
data QueryTypeFieldInfo
instance AttrInfo QueryTypeFieldInfo where
type AttrAllowedOps QueryTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint QueryTypeFieldInfo = (~) Gst.Enums.QueryType
type AttrBaseTypeConstraint QueryTypeFieldInfo = (~) Query
type AttrGetType QueryTypeFieldInfo = Gst.Enums.QueryType
type AttrLabel QueryTypeFieldInfo = "type"
type AttrOrigin QueryTypeFieldInfo = Query
attrGet _ = getQueryType
attrSet _ = setQueryType
attrConstruct = undefined
attrClear _ = undefined
query_type :: AttrLabelProxy "type"
query_type = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Query
type instance O.AttributeList Query = QueryAttributeList
type QueryAttributeList = ('[ '("miniObject", QueryMiniObjectFieldInfo), '("type", QueryTypeFieldInfo)] :: [(Symbol, *)])
#endif
-- method Query::new_accept_caps
-- method type : Constructor
-- Args : [Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a fixed #GstCaps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_accept_caps" gst_query_new_accept_caps ::
Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
IO (Ptr Query)
{- |
Constructs a new query object for querying if /@caps@/ are accepted.
Free-function: @/gst_query_unref()/@
-}
queryNewAcceptCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Caps.Caps
{- ^ /@caps@/: a fixed 'GI.Gst.Structs.Caps.Caps' -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewAcceptCaps caps = liftIO $ do
caps' <- unsafeManagedPtrGetPtr caps
result <- gst_query_new_accept_caps caps'
checkUnexpectedReturnNULL "queryNewAcceptCaps" result
result' <- (wrapBoxed Query) result
touchManagedPtr caps
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_allocation
-- method type : Constructor
-- Args : [Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the negotiated caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "need_pool", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return a pool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_allocation" gst_query_new_allocation ::
Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
CInt -> -- need_pool : TBasicType TBoolean
IO (Ptr Query)
{- |
Constructs a new query object for querying the allocation properties.
Free-function: @/gst_query_unref()/@
-}
queryNewAllocation ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Caps.Caps
{- ^ /@caps@/: the negotiated caps -}
-> Bool
{- ^ /@needPool@/: return a pool -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewAllocation caps needPool = liftIO $ do
caps' <- unsafeManagedPtrGetPtr caps
let needPool' = (fromIntegral . fromEnum) needPool
result <- gst_query_new_allocation caps' needPool'
checkUnexpectedReturnNULL "queryNewAllocation" result
result' <- (wrapBoxed Query) result
touchManagedPtr caps
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_bitrate
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_bitrate" gst_query_new_bitrate ::
IO (Ptr Query)
{- |
Constructs a new query object for querying the bitrate.
Free-function: @/gst_query_unref()/@
/Since: 1.16/
-}
queryNewBitrate ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewBitrate = liftIO $ do
result <- gst_query_new_bitrate
checkUnexpectedReturnNULL "queryNewBitrate" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_buffering
-- method type : Constructor
-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the default #GstFormat for the new query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_buffering" gst_query_new_buffering ::
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
IO (Ptr Query)
{- |
Constructs a new query object for querying the buffering status of
a stream.
Free-function: @/gst_query_unref()/@
-}
queryNewBuffering ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
{- ^ /@format@/: the default 'GI.Gst.Enums.Format' for the new query -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewBuffering format = liftIO $ do
let format' = (fromIntegral . fromEnum) format
result <- gst_query_new_buffering format'
checkUnexpectedReturnNULL "queryNewBuffering" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_caps
-- method type : Constructor
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a filter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_caps" gst_query_new_caps ::
Ptr Gst.Caps.Caps -> -- filter : TInterface (Name {namespace = "Gst", name = "Caps"})
IO (Ptr Query)
{- |
Constructs a new query object for querying the caps.
The CAPS query should return the allowable caps for a pad in the context
of the element\'s state, its link to other elements, and the devices or files
it has opened. These caps must be a subset of the pad template caps. In the
NULL state with no links, the CAPS query should ideally return the same caps
as the pad template. In rare circumstances, an object property can affect
the caps returned by the CAPS query, but this is discouraged.
For most filters, the caps returned by CAPS query is directly affected by the
allowed caps on other pads. For demuxers and decoders, the caps returned by
the srcpad\'s getcaps function is directly related to the stream data. Again,
the CAPS query should return the most specific caps it reasonably can, since this
helps with autoplugging.
The /@filter@/ is used to restrict the result caps, only the caps matching
/@filter@/ should be returned from the CAPS query. Specifying a filter might
greatly reduce the amount of processing an element needs to do.
Free-function: @/gst_query_unref()/@
-}
queryNewCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Caps.Caps
{- ^ /@filter@/: a filter -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewCaps filter = liftIO $ do
filter' <- unsafeManagedPtrGetPtr filter
result <- gst_query_new_caps filter'
checkUnexpectedReturnNULL "queryNewCaps" result
result' <- (wrapBoxed Query) result
touchManagedPtr filter
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_context
-- method type : Constructor
-- Args : [Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Context type to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_context" gst_query_new_context ::
CString -> -- context_type : TBasicType TUTF8
IO (Ptr Query)
{- |
Constructs a new query object for querying the pipeline-local context.
Free-function: @/gst_query_unref()/@
/Since: 1.2/
-}
queryNewContext ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
{- ^ /@contextType@/: Context type to query -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewContext contextType = liftIO $ do
contextType' <- textToCString contextType
result <- gst_query_new_context contextType'
checkUnexpectedReturnNULL "queryNewContext" result
result' <- (wrapBoxed Query) result
freeMem contextType'
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_convert
-- method type : Constructor
-- Args : [Arg {argCName = "src_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source #GstFormat for the new query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the target #GstFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_convert" gst_query_new_convert ::
CUInt -> -- src_format : TInterface (Name {namespace = "Gst", name = "Format"})
Int64 -> -- value : TBasicType TInt64
CUInt -> -- dest_format : TInterface (Name {namespace = "Gst", name = "Format"})
IO (Ptr Query)
{- |
Constructs a new convert query object. Use @/gst_query_unref()/@
when done with it. A convert query is used to ask for a conversion between
one format and another.
Free-function: @/gst_query_unref()/@
-}
queryNewConvert ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
{- ^ /@srcFormat@/: the source 'GI.Gst.Enums.Format' for the new query -}
-> Int64
{- ^ /@value@/: the value to convert -}
-> Gst.Enums.Format
{- ^ /@destFormat@/: the target 'GI.Gst.Enums.Format' -}
-> m Query
{- ^ __Returns:__ a 'GI.Gst.Structs.Query.Query' -}
queryNewConvert srcFormat value destFormat = liftIO $ do
let srcFormat' = (fromIntegral . fromEnum) srcFormat
let destFormat' = (fromIntegral . fromEnum) destFormat
result <- gst_query_new_convert srcFormat' value destFormat'
checkUnexpectedReturnNULL "queryNewConvert" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_custom
-- method type : Constructor
-- Args : [Arg {argCName = "type", argType = TInterface (Name {namespace = "Gst", name = "QueryType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the query type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a structure for the query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_custom" gst_query_new_custom ::
CUInt -> -- type : TInterface (Name {namespace = "Gst", name = "QueryType"})
Ptr Gst.Structure.Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"})
IO (Ptr Query)
{- |
Constructs a new custom query object. Use @/gst_query_unref()/@
when done with it.
Free-function: @/gst_query_unref()/@
-}
queryNewCustom ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.QueryType
{- ^ /@type@/: the query type -}
-> Maybe (Gst.Structure.Structure)
{- ^ /@structure@/: a structure for the query -}
-> m (Maybe Query)
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewCustom type_ structure = liftIO $ do
let type_' = (fromIntegral . fromEnum) type_
maybeStructure <- case structure of
Nothing -> return nullPtr
Just jStructure -> do
jStructure' <- B.ManagedPtr.disownBoxed jStructure
return jStructure'
result <- gst_query_new_custom type_' maybeStructure
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Query) result'
return result''
whenJust structure touchManagedPtr
return maybeResult
#if ENABLE_OVERLOADING
#endif
-- method Query::new_drain
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_drain" gst_query_new_drain ::
IO (Ptr Query)
{- |
Constructs a new query object for querying the drain state.
Free-function: @/gst_query_unref()/@
-}
queryNewDrain ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewDrain = liftIO $ do
result <- gst_query_new_drain
checkUnexpectedReturnNULL "queryNewDrain" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_duration
-- method type : Constructor
-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat for this duration query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_duration" gst_query_new_duration ::
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
IO (Ptr Query)
{- |
Constructs a new stream duration query object to query in the given format.
Use @/gst_query_unref()/@ when done with it. A duration query will give the
total length of the stream.
Free-function: @/gst_query_unref()/@
-}
queryNewDuration ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
{- ^ /@format@/: the 'GI.Gst.Enums.Format' for this duration query -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewDuration format = liftIO $ do
let format' = (fromIntegral . fromEnum) format
result <- gst_query_new_duration format'
checkUnexpectedReturnNULL "queryNewDuration" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_formats
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_formats" gst_query_new_formats ::
IO (Ptr Query)
{- |
Constructs a new query object for querying formats of
the stream.
Free-function: @/gst_query_unref()/@
-}
queryNewFormats ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewFormats = liftIO $ do
result <- gst_query_new_formats
checkUnexpectedReturnNULL "queryNewFormats" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_latency
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_latency" gst_query_new_latency ::
IO (Ptr Query)
{- |
Constructs a new latency query object.
Use @/gst_query_unref()/@ when done with it. A latency query is usually performed
by sinks to compensate for additional latency introduced by elements in the
pipeline.
Free-function: @/gst_query_unref()/@
-}
queryNewLatency ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Query
{- ^ __Returns:__ a 'GI.Gst.Structs.Query.Query' -}
queryNewLatency = liftIO $ do
result <- gst_query_new_latency
checkUnexpectedReturnNULL "queryNewLatency" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_position
-- method type : Constructor
-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the default #GstFormat for the new query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_position" gst_query_new_position ::
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
IO (Ptr Query)
{- |
Constructs a new query stream position query object. Use @/gst_query_unref()/@
when done with it. A position query is used to query the current position
of playback in the streams, in some format.
Free-function: @/gst_query_unref()/@
-}
queryNewPosition ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
{- ^ /@format@/: the default 'GI.Gst.Enums.Format' for the new query -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewPosition format = liftIO $ do
let format' = (fromIntegral . fromEnum) format
result <- gst_query_new_position format'
checkUnexpectedReturnNULL "queryNewPosition" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_scheduling
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_scheduling" gst_query_new_scheduling ::
IO (Ptr Query)
{- |
Constructs a new query object for querying the scheduling properties.
Free-function: @/gst_query_unref()/@
-}
queryNewScheduling ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewScheduling = liftIO $ do
result <- gst_query_new_scheduling
checkUnexpectedReturnNULL "queryNewScheduling" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_seeking
-- method type : Constructor
-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the default #GstFormat for the new query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_seeking" gst_query_new_seeking ::
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
IO (Ptr Query)
{- |
Constructs a new query object for querying seeking properties of
the stream.
Free-function: @/gst_query_unref()/@
-}
queryNewSeeking ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
{- ^ /@format@/: the default 'GI.Gst.Enums.Format' for the new query -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewSeeking format = liftIO $ do
let format' = (fromIntegral . fromEnum) format
result <- gst_query_new_seeking format'
checkUnexpectedReturnNULL "queryNewSeeking" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_segment
-- method type : Constructor
-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat for the new query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_segment" gst_query_new_segment ::
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
IO (Ptr Query)
{- |
Constructs a new segment query object. Use @/gst_query_unref()/@
when done with it. A segment query is used to discover information about the
currently configured segment for playback.
Free-function: @/gst_query_unref()/@
-}
queryNewSegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
{- ^ /@format@/: the 'GI.Gst.Enums.Format' for the new query -}
-> m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewSegment format = liftIO $ do
let format' = (fromIntegral . fromEnum) format
result <- gst_query_new_segment format'
checkUnexpectedReturnNULL "queryNewSegment" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::new_uri
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_new_uri" gst_query_new_uri ::
IO (Ptr Query)
{- |
Constructs a new query URI query object. Use @/gst_query_unref()/@
when done with it. An URI query is used to query the current URI
that is used by the source or sink.
Free-function: @/gst_query_unref()/@
-}
queryNewUri ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Query
{- ^ __Returns:__ a new 'GI.Gst.Structs.Query.Query' -}
queryNewUri = liftIO $ do
result <- gst_query_new_uri
checkUnexpectedReturnNULL "queryNewUri" result
result' <- (wrapBoxed Query) result
return result'
#if ENABLE_OVERLOADING
#endif
-- method Query::add_allocation_meta
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the metadata API", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "API specific parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_add_allocation_meta" gst_query_add_allocation_meta ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CGType -> -- api : TBasicType TGType
Ptr Gst.Structure.Structure -> -- params : TInterface (Name {namespace = "Gst", name = "Structure"})
IO ()
{- |
Add /@api@/ with /@params@/ as one of the supported metadata API to /@query@/.
-}
queryAddAllocationMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> GType
{- ^ /@api@/: the metadata API -}
-> Maybe (Gst.Structure.Structure)
{- ^ /@params@/: API specific parameters -}
-> m ()
queryAddAllocationMeta query api params = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let api' = gtypeToCGType api
maybeParams <- case params of
Nothing -> return nullPtr
Just jParams -> do
jParams' <- unsafeManagedPtrGetPtr jParams
return jParams'
gst_query_add_allocation_meta query' api' maybeParams
touchManagedPtr query
whenJust params touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data QueryAddAllocationMetaMethodInfo
instance (signature ~ (GType -> Maybe (Gst.Structure.Structure) -> m ()), MonadIO m) => O.MethodInfo QueryAddAllocationMetaMethodInfo Query signature where
overloadedMethod _ = queryAddAllocationMeta
#endif
-- method Query::add_allocation_param
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the memory allocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstAllocationParams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_add_allocation_param" gst_query_add_allocation_param ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr Gst.Allocator.Allocator -> -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"})
Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"})
IO ()
{- |
Add /@allocator@/ and its /@params@/ as a supported memory allocator.
-}
queryAddAllocationParam ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Allocator.IsAllocator a) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> Maybe (a)
{- ^ /@allocator@/: the memory allocator -}
-> Maybe (Gst.AllocationParams.AllocationParams)
{- ^ /@params@/: a 'GI.Gst.Structs.AllocationParams.AllocationParams' -}
-> m ()
queryAddAllocationParam query allocator params = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
maybeAllocator <- case allocator of
Nothing -> return nullPtr
Just jAllocator -> do
jAllocator' <- unsafeManagedPtrCastPtr jAllocator
return jAllocator'
maybeParams <- case params of
Nothing -> return nullPtr
Just jParams -> do
jParams' <- unsafeManagedPtrGetPtr jParams
return jParams'
gst_query_add_allocation_param query' maybeAllocator maybeParams
touchManagedPtr query
whenJust allocator touchManagedPtr
whenJust params touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data QueryAddAllocationParamMethodInfo
instance (signature ~ (Maybe (a) -> Maybe (Gst.AllocationParams.AllocationParams) -> m ()), MonadIO m, Gst.Allocator.IsAllocator a) => O.MethodInfo QueryAddAllocationParamMethodInfo Query signature where
overloadedMethod _ = queryAddAllocationParam
#endif
-- method Query::add_allocation_pool
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_ALLOCATION.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the min buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the max buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_add_allocation_pool" gst_query_add_allocation_pool ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr Gst.BufferPool.BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"})
Word32 -> -- size : TBasicType TUInt
Word32 -> -- min_buffers : TBasicType TUInt
Word32 -> -- max_buffers : TBasicType TUInt
IO ()
{- |
Set the pool parameters in /@query@/.
-}
queryAddAllocationPool ::
(B.CallStack.HasCallStack, MonadIO m, Gst.BufferPool.IsBufferPool a) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_ALLOCATION. -}
-> Maybe (a)
{- ^ /@pool@/: the 'GI.Gst.Objects.BufferPool.BufferPool' -}
-> Word32
{- ^ /@size@/: the buffer size -}
-> Word32
{- ^ /@minBuffers@/: the min buffers -}
-> Word32
{- ^ /@maxBuffers@/: the max buffers -}
-> m ()
queryAddAllocationPool query pool size minBuffers maxBuffers = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
maybePool <- case pool of
Nothing -> return nullPtr
Just jPool -> do
jPool' <- unsafeManagedPtrCastPtr jPool
return jPool'
gst_query_add_allocation_pool query' maybePool size minBuffers maxBuffers
touchManagedPtr query
whenJust pool touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data QueryAddAllocationPoolMethodInfo
instance (signature ~ (Maybe (a) -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m, Gst.BufferPool.IsBufferPool a) => O.MethodInfo QueryAddAllocationPoolMethodInfo Query signature where
overloadedMethod _ = queryAddAllocationPool
#endif
-- method Query::add_buffering_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_BUFFERING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start position of the range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "stop position of the range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_add_buffering_range" gst_query_add_buffering_range ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Int64 -> -- start : TBasicType TInt64
Int64 -> -- stop : TBasicType TInt64
IO CInt
{- |
Set the buffering-ranges array field in /@query@/. The current last
start position of the array should be inferior to /@start@/.
-}
queryAddBufferingRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_BUFFERING type query 'GI.Gst.Structs.Query.Query' -}
-> Int64
{- ^ /@start@/: start position of the range -}
-> Int64
{- ^ /@stop@/: stop position of the range -}
-> m Bool
{- ^ __Returns:__ a 'Bool' indicating if the range was added or not. -}
queryAddBufferingRange query start stop = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_add_buffering_range query' start stop
let result' = (/= 0) result
touchManagedPtr query
return result'
#if ENABLE_OVERLOADING
data QueryAddBufferingRangeMethodInfo
instance (signature ~ (Int64 -> Int64 -> m Bool), MonadIO m) => O.MethodInfo QueryAddBufferingRangeMethodInfo Query signature where
overloadedMethod _ = queryAddBufferingRange
#endif
-- method Query::add_scheduling_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_SCHEDULING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "PadMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPadMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_add_scheduling_mode" gst_query_add_scheduling_mode ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- mode : TInterface (Name {namespace = "Gst", name = "PadMode"})
IO ()
{- |
Add /@mode@/ as one of the supported scheduling modes to /@query@/.
-}
queryAddSchedulingMode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_SCHEDULING type query 'GI.Gst.Structs.Query.Query' -}
-> Gst.Enums.PadMode
{- ^ /@mode@/: a 'GI.Gst.Enums.PadMode' -}
-> m ()
queryAddSchedulingMode query mode = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let mode' = (fromIntegral . fromEnum) mode
gst_query_add_scheduling_mode query' mode'
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QueryAddSchedulingModeMethodInfo
instance (signature ~ (Gst.Enums.PadMode -> m ()), MonadIO m) => O.MethodInfo QueryAddSchedulingModeMethodInfo Query signature where
overloadedMethod _ = queryAddSchedulingMode
#endif
-- method Query::find_allocation_meta
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the metadata API", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_find_allocation_meta" gst_query_find_allocation_meta ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CGType -> -- api : TBasicType TGType
Ptr Word32 -> -- index : TBasicType TUInt
IO CInt
{- |
Check if /@query@/ has metadata /@api@/ set. When this function returns 'True',
/@index@/ will contain the index where the requested API and the parameters
can be found.
-}
queryFindAllocationMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> GType
{- ^ /@api@/: the metadata API -}
-> m ((Bool, Word32))
{- ^ __Returns:__ 'True' when /@api@/ is in the list of metadata. -}
queryFindAllocationMeta query api = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let api' = gtypeToCGType api
index <- allocMem :: IO (Ptr Word32)
result <- gst_query_find_allocation_meta query' api' index
let result' = (/= 0) result
index' <- peek index
touchManagedPtr query
freeMem index
return (result', index')
#if ENABLE_OVERLOADING
data QueryFindAllocationMetaMethodInfo
instance (signature ~ (GType -> m ((Bool, Word32))), MonadIO m) => O.MethodInfo QueryFindAllocationMetaMethodInfo Query signature where
overloadedMethod _ = queryFindAllocationMeta
#endif
-- method Query::get_n_allocation_metas
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_get_n_allocation_metas" gst_query_get_n_allocation_metas ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
IO Word32
{- |
Retrieve the number of values currently stored in the
meta API array of the query\'s structure.
-}
queryGetNAllocationMetas ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> m Word32
{- ^ __Returns:__ the metadata API array size as a @/guint/@. -}
queryGetNAllocationMetas query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_get_n_allocation_metas query'
touchManagedPtr query
return result
#if ENABLE_OVERLOADING
data QueryGetNAllocationMetasMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo QueryGetNAllocationMetasMethodInfo Query signature where
overloadedMethod _ = queryGetNAllocationMetas
#endif
-- method Query::get_n_allocation_params
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_get_n_allocation_params" gst_query_get_n_allocation_params ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
IO Word32
{- |
Retrieve the number of values currently stored in the
allocator params array of the query\'s structure.
If no memory allocator is specified, the downstream element can handle
the default memory allocator. The first memory allocator in the query
should be generic and allow mapping to system memory, all following
allocators should be ordered by preference with the preferred one first.
-}
queryGetNAllocationParams ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> m Word32
{- ^ __Returns:__ the allocator array size as a @/guint/@. -}
queryGetNAllocationParams query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_get_n_allocation_params query'
touchManagedPtr query
return result
#if ENABLE_OVERLOADING
data QueryGetNAllocationParamsMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo QueryGetNAllocationParamsMethodInfo Query signature where
overloadedMethod _ = queryGetNAllocationParams
#endif
-- method Query::get_n_allocation_pools
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_get_n_allocation_pools" gst_query_get_n_allocation_pools ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
IO Word32
{- |
Retrieve the number of values currently stored in the
pool array of the query\'s structure.
-}
queryGetNAllocationPools ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> m Word32
{- ^ __Returns:__ the pool array size as a @/guint/@. -}
queryGetNAllocationPools query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_get_n_allocation_pools query'
touchManagedPtr query
return result
#if ENABLE_OVERLOADING
data QueryGetNAllocationPoolsMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo QueryGetNAllocationPoolsMethodInfo Query signature where
overloadedMethod _ = queryGetNAllocationPools
#endif
-- method Query::get_n_buffering_ranges
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_BUFFERING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_get_n_buffering_ranges" gst_query_get_n_buffering_ranges ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
IO Word32
{- |
Retrieve the number of values currently stored in the
buffered-ranges array of the query\'s structure.
-}
queryGetNBufferingRanges ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_BUFFERING type query 'GI.Gst.Structs.Query.Query' -}
-> m Word32
{- ^ __Returns:__ the range array size as a @/guint/@. -}
queryGetNBufferingRanges query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_get_n_buffering_ranges query'
touchManagedPtr query
return result
#if ENABLE_OVERLOADING
data QueryGetNBufferingRangesMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo QueryGetNBufferingRangesMethodInfo Query signature where
overloadedMethod _ = queryGetNBufferingRanges
#endif
-- method Query::get_n_scheduling_modes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_SCHEDULING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_get_n_scheduling_modes" gst_query_get_n_scheduling_modes ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
IO Word32
{- |
Retrieve the number of values currently stored in the
scheduling mode array of the query\'s structure.
-}
queryGetNSchedulingModes ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_SCHEDULING type query 'GI.Gst.Structs.Query.Query' -}
-> m Word32
{- ^ __Returns:__ the scheduling mode array size as a @/guint/@. -}
queryGetNSchedulingModes query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_get_n_scheduling_modes query'
touchManagedPtr query
return result
#if ENABLE_OVERLOADING
data QueryGetNSchedulingModesMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo QueryGetNSchedulingModesMethodInfo Query signature where
overloadedMethod _ = queryGetNSchedulingModes
#endif
-- method Query::get_structure
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_get_structure" gst_query_get_structure ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
IO (Ptr Gst.Structure.Structure)
{- |
Get the structure of a query.
-}
queryGetStructure ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m (Maybe Gst.Structure.Structure)
{- ^ __Returns:__ the 'GI.Gst.Structs.Structure.Structure' of the query. The
structure is still owned by the query and will therefore be freed when the
query is unreffed. -}
queryGetStructure query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_get_structure query'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newBoxed Gst.Structure.Structure) result'
return result''
touchManagedPtr query
return maybeResult
#if ENABLE_OVERLOADING
data QueryGetStructureMethodInfo
instance (signature ~ (m (Maybe Gst.Structure.Structure)), MonadIO m) => O.MethodInfo QueryGetStructureMethodInfo Query signature where
overloadedMethod _ = queryGetStructure
#endif
-- method Query::has_scheduling_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_SCHEDULING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "PadMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scheduling mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_has_scheduling_mode" gst_query_has_scheduling_mode ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- mode : TInterface (Name {namespace = "Gst", name = "PadMode"})
IO CInt
{- |
Check if /@query@/ has scheduling mode set.
> When checking if upstream supports pull mode, it is usually not
> enough to just check for GST_PAD_MODE_PULL with this function, you
> also want to check whether the scheduling flags returned by
> 'GI.Gst.Structs.Query.queryParseScheduling' have the seeking flag set (meaning
> random access is supported, not only sequential pulls).
-}
queryHasSchedulingMode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_SCHEDULING type query 'GI.Gst.Structs.Query.Query' -}
-> Gst.Enums.PadMode
{- ^ /@mode@/: the scheduling mode -}
-> m Bool
{- ^ __Returns:__ 'True' when /@mode@/ is in the list of scheduling modes. -}
queryHasSchedulingMode query mode = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let mode' = (fromIntegral . fromEnum) mode
result <- gst_query_has_scheduling_mode query' mode'
let result' = (/= 0) result
touchManagedPtr query
return result'
#if ENABLE_OVERLOADING
data QueryHasSchedulingModeMethodInfo
instance (signature ~ (Gst.Enums.PadMode -> m Bool), MonadIO m) => O.MethodInfo QueryHasSchedulingModeMethodInfo Query signature where
overloadedMethod _ = queryHasSchedulingMode
#endif
-- method Query::has_scheduling_mode_with_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_SCHEDULING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "PadMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scheduling mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "SchedulingFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstSchedulingFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_has_scheduling_mode_with_flags" gst_query_has_scheduling_mode_with_flags ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- mode : TInterface (Name {namespace = "Gst", name = "PadMode"})
CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "SchedulingFlags"})
IO CInt
{- |
Check if /@query@/ has scheduling mode set and /@flags@/ is set in
query scheduling flags.
-}
queryHasSchedulingModeWithFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_SCHEDULING type query 'GI.Gst.Structs.Query.Query' -}
-> Gst.Enums.PadMode
{- ^ /@mode@/: the scheduling mode -}
-> [Gst.Flags.SchedulingFlags]
{- ^ /@flags@/: 'GI.Gst.Flags.SchedulingFlags' -}
-> m Bool
{- ^ __Returns:__ 'True' when /@mode@/ is in the list of scheduling modes
and /@flags@/ are compatible with query flags. -}
queryHasSchedulingModeWithFlags query mode flags = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let mode' = (fromIntegral . fromEnum) mode
let flags' = gflagsToWord flags
result <- gst_query_has_scheduling_mode_with_flags query' mode' flags'
let result' = (/= 0) result
touchManagedPtr query
return result'
#if ENABLE_OVERLOADING
data QueryHasSchedulingModeWithFlagsMethodInfo
instance (signature ~ (Gst.Enums.PadMode -> [Gst.Flags.SchedulingFlags] -> m Bool), MonadIO m) => O.MethodInfo QueryHasSchedulingModeWithFlagsMethodInfo Query signature where
overloadedMethod _ = queryHasSchedulingModeWithFlags
#endif
-- method Query::parse_accept_caps
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The query to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_accept_caps" gst_query_parse_accept_caps ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr (Ptr Gst.Caps.Caps) -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
IO ()
{- |
Get the caps from /@query@/. The caps remains valid as long as /@query@/ remains
valid.
-}
queryParseAcceptCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: The query to parse -}
-> m (Gst.Caps.Caps)
queryParseAcceptCaps query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
caps <- allocMem :: IO (Ptr (Ptr Gst.Caps.Caps))
gst_query_parse_accept_caps query' caps
caps' <- peek caps
caps'' <- (newBoxed Gst.Caps.Caps) caps'
touchManagedPtr query
freeMem caps
return caps''
#if ENABLE_OVERLOADING
data QueryParseAcceptCapsMethodInfo
instance (signature ~ (m (Gst.Caps.Caps)), MonadIO m) => O.MethodInfo QueryParseAcceptCapsMethodInfo Query signature where
overloadedMethod _ = queryParseAcceptCaps
#endif
-- method Query::parse_accept_caps_result
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ACCEPT_CAPS type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_accept_caps_result" gst_query_parse_accept_caps_result ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CInt -> -- result : TBasicType TBoolean
IO ()
{- |
Parse the result from /@query@/ and store in /@result@/.
-}
queryParseAcceptCapsResult ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ACCEPT_CAPS type query 'GI.Gst.Structs.Query.Query' -}
-> m (Bool)
queryParseAcceptCapsResult query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result_ <- allocMem :: IO (Ptr CInt)
gst_query_parse_accept_caps_result query' result_
result_' <- peek result_
let result_'' = (/= 0) result_'
touchManagedPtr query
freeMem result_
return result_''
#if ENABLE_OVERLOADING
data QueryParseAcceptCapsResultMethodInfo
instance (signature ~ (m (Bool)), MonadIO m) => O.MethodInfo QueryParseAcceptCapsResultMethodInfo Query signature where
overloadedMethod _ = queryParseAcceptCapsResult
#endif
-- method Query::parse_allocation
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GstCaps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "need_pool", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether a #GstBufferPool is needed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_allocation" gst_query_parse_allocation ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr (Ptr Gst.Caps.Caps) -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
Ptr CInt -> -- need_pool : TBasicType TBoolean
IO ()
{- |
Parse an allocation query, writing the requested caps in /@caps@/ and
whether a pool is needed in /@needPool@/, if the respective parameters
are non-'Nothing'.
Pool details can be retrieved using 'GI.Gst.Structs.Query.queryGetNAllocationPools' and
'GI.Gst.Structs.Query.queryParseNthAllocationPool'.
-}
queryParseAllocation ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m ((Gst.Caps.Caps, Bool))
queryParseAllocation query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
caps <- allocMem :: IO (Ptr (Ptr Gst.Caps.Caps))
needPool <- allocMem :: IO (Ptr CInt)
gst_query_parse_allocation query' caps needPool
caps' <- peek caps
caps'' <- (newBoxed Gst.Caps.Caps) caps'
needPool' <- peek needPool
let needPool'' = (/= 0) needPool'
touchManagedPtr query
freeMem caps
freeMem needPool
return (caps'', needPool'')
#if ENABLE_OVERLOADING
data QueryParseAllocationMethodInfo
instance (signature ~ (m ((Gst.Caps.Caps, Bool))), MonadIO m) => O.MethodInfo QueryParseAllocationMethodInfo Query signature where
overloadedMethod _ = queryParseAllocation
#endif
-- method Query::parse_bitrate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_BITRATE type #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nominal_bitrate", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The resulting bitrate in bits per second", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_bitrate" gst_query_parse_bitrate ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr Word32 -> -- nominal_bitrate : TBasicType TUInt
IO ()
{- |
Get the results of a bitrate query. See also 'GI.Gst.Structs.Query.querySetBitrate'.
/Since: 1.16/
-}
queryParseBitrate ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_BITRATE type 'GI.Gst.Structs.Query.Query' -}
-> m (Word32)
queryParseBitrate query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
nominalBitrate <- allocMem :: IO (Ptr Word32)
gst_query_parse_bitrate query' nominalBitrate
nominalBitrate' <- peek nominalBitrate
touchManagedPtr query
freeMem nominalBitrate
return nominalBitrate'
#if ENABLE_OVERLOADING
data QueryParseBitrateMethodInfo
instance (signature ~ (m (Word32)), MonadIO m) => O.MethodInfo QueryParseBitrateMethodInfo Query signature where
overloadedMethod _ = queryParseBitrate
#endif
-- method Query::parse_buffering_percent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_BUFFERING.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if buffering is busy, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "percent", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffering percent, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_buffering_percent" gst_query_parse_buffering_percent ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CInt -> -- busy : TBasicType TBoolean
Ptr Int32 -> -- percent : TBasicType TInt
IO ()
{- |
Get the percentage of buffered data. This is a value between 0 and 100.
The /@busy@/ indicator is 'True' when the buffering is in progress.
-}
queryParseBufferingPercent ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_BUFFERING. -}
-> m ((Bool, Int32))
queryParseBufferingPercent query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
busy <- allocMem :: IO (Ptr CInt)
percent <- allocMem :: IO (Ptr Int32)
gst_query_parse_buffering_percent query' busy percent
busy' <- peek busy
let busy'' = (/= 0) busy'
percent' <- peek percent
touchManagedPtr query
freeMem busy
freeMem percent
return (busy'', percent')
#if ENABLE_OVERLOADING
data QueryParseBufferingPercentMethodInfo
instance (signature ~ (m ((Bool, Int32))), MonadIO m) => O.MethodInfo QueryParseBufferingPercentMethodInfo Query signature where
overloadedMethod _ = queryParseBufferingPercent
#endif
-- method Query::parse_buffering_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_BUFFERING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the format to set for the @segment_start\n and @segment_end values, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start to set, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stop to set, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "estimated_total", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "estimated total amount of download\n time remaining in milliseconds, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_buffering_range" gst_query_parse_buffering_range ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Ptr Int64 -> -- start : TBasicType TInt64
Ptr Int64 -> -- stop : TBasicType TInt64
Ptr Int64 -> -- estimated_total : TBasicType TInt64
IO ()
{- |
Parse an available query, writing the format into /@format@/, and
other results into the passed parameters, if the respective parameters
are non-'Nothing'
-}
queryParseBufferingRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_BUFFERING type query 'GI.Gst.Structs.Query.Query' -}
-> m ((Gst.Enums.Format, Int64, Int64, Int64))
queryParseBufferingRange query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
format <- allocMem :: IO (Ptr CUInt)
start <- allocMem :: IO (Ptr Int64)
stop <- allocMem :: IO (Ptr Int64)
estimatedTotal <- allocMem :: IO (Ptr Int64)
gst_query_parse_buffering_range query' format start stop estimatedTotal
format' <- peek format
let format'' = (toEnum . fromIntegral) format'
start' <- peek start
stop' <- peek stop
estimatedTotal' <- peek estimatedTotal
touchManagedPtr query
freeMem format
freeMem start
freeMem stop
freeMem estimatedTotal
return (format'', start', stop', estimatedTotal')
#if ENABLE_OVERLOADING
data QueryParseBufferingRangeMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Int64, Int64, Int64))), MonadIO m) => O.MethodInfo QueryParseBufferingRangeMethodInfo Query signature where
overloadedMethod _ = queryParseBufferingRange
#endif
-- method Query::parse_buffering_stats
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_BUFFERING.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "BufferingMode"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffering mode, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_in", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the average input rate, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_out", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the average output rat, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "amount of buffering time left in\n milliseconds, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_buffering_stats" gst_query_parse_buffering_stats ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CUInt -> -- mode : TInterface (Name {namespace = "Gst", name = "BufferingMode"})
Ptr Int32 -> -- avg_in : TBasicType TInt
Ptr Int32 -> -- avg_out : TBasicType TInt
Ptr Int64 -> -- buffering_left : TBasicType TInt64
IO ()
{- |
Extracts the buffering stats values from /@query@/.
-}
queryParseBufferingStats ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_BUFFERING. -}
-> m ((Gst.Enums.BufferingMode, Int32, Int32, Int64))
queryParseBufferingStats query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
mode <- allocMem :: IO (Ptr CUInt)
avgIn <- allocMem :: IO (Ptr Int32)
avgOut <- allocMem :: IO (Ptr Int32)
bufferingLeft <- allocMem :: IO (Ptr Int64)
gst_query_parse_buffering_stats query' mode avgIn avgOut bufferingLeft
mode' <- peek mode
let mode'' = (toEnum . fromIntegral) mode'
avgIn' <- peek avgIn
avgOut' <- peek avgOut
bufferingLeft' <- peek bufferingLeft
touchManagedPtr query
freeMem mode
freeMem avgIn
freeMem avgOut
freeMem bufferingLeft
return (mode'', avgIn', avgOut', bufferingLeft')
#if ENABLE_OVERLOADING
data QueryParseBufferingStatsMethodInfo
instance (signature ~ (m ((Gst.Enums.BufferingMode, Int32, Int32, Int64))), MonadIO m) => O.MethodInfo QueryParseBufferingStatsMethodInfo Query signature where
overloadedMethod _ = queryParseBufferingStats
#endif
-- method Query::parse_caps
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The query to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the caps filter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_caps" gst_query_parse_caps ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr (Ptr Gst.Caps.Caps) -> -- filter : TInterface (Name {namespace = "Gst", name = "Caps"})
IO ()
{- |
Get the filter from the caps /@query@/. The caps remains valid as long as
/@query@/ remains valid.
-}
queryParseCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: The query to parse -}
-> m (Gst.Caps.Caps)
queryParseCaps query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
filter <- allocMem :: IO (Ptr (Ptr Gst.Caps.Caps))
gst_query_parse_caps query' filter
filter' <- peek filter
filter'' <- (newBoxed Gst.Caps.Caps) filter'
touchManagedPtr query
freeMem filter
return filter''
#if ENABLE_OVERLOADING
data QueryParseCapsMethodInfo
instance (signature ~ (m (Gst.Caps.Caps)), MonadIO m) => O.MethodInfo QueryParseCapsMethodInfo Query signature where
overloadedMethod _ = queryParseCaps
#endif
-- method Query::parse_caps_result
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The query to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_caps_result" gst_query_parse_caps_result ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr (Ptr Gst.Caps.Caps) -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
IO ()
{- |
Get the caps result from /@query@/. The caps remains valid as long as
/@query@/ remains valid.
-}
queryParseCapsResult ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: The query to parse -}
-> m (Gst.Caps.Caps)
queryParseCapsResult query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
caps <- allocMem :: IO (Ptr (Ptr Gst.Caps.Caps))
gst_query_parse_caps_result query' caps
caps' <- peek caps
caps'' <- (newBoxed Gst.Caps.Caps) caps'
touchManagedPtr query
freeMem caps
return caps''
#if ENABLE_OVERLOADING
data QueryParseCapsResultMethodInfo
instance (signature ~ (m (Gst.Caps.Caps)), MonadIO m) => O.MethodInfo QueryParseCapsResultMethodInfo Query signature where
overloadedMethod _ = queryParseCapsResult
#endif
-- method Query::parse_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The query to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "Gst", name = "Context"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to store the #GstContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_context" gst_query_parse_context ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr (Ptr Gst.Context.Context) -> -- context : TInterface (Name {namespace = "Gst", name = "Context"})
IO ()
{- |
Get the context from the context /@query@/. The context remains valid as long as
/@query@/ remains valid.
/Since: 1.2/
-}
queryParseContext ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: The query to parse -}
-> m (Gst.Context.Context)
queryParseContext query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
context <- allocMem :: IO (Ptr (Ptr Gst.Context.Context))
gst_query_parse_context query' context
context' <- peek context
context'' <- (newBoxed Gst.Context.Context) context'
touchManagedPtr query
freeMem context
return context''
#if ENABLE_OVERLOADING
data QueryParseContextMethodInfo
instance (signature ~ (m (Gst.Context.Context)), MonadIO m) => O.MethodInfo QueryParseContextMethodInfo Query signature where
overloadedMethod _ = queryParseContext
#endif
-- method Query::parse_context_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_CONTEXT type query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the context type, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_context_type" gst_query_parse_context_type ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CString -> -- context_type : TBasicType TUTF8
IO CInt
{- |
Parse a context type from an existing GST_QUERY_CONTEXT query.
/Since: 1.2/
-}
queryParseContextType ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_CONTEXT type query -}
-> m ((Bool, T.Text))
{- ^ __Returns:__ a 'Bool' indicating if the parsing succeeded. -}
queryParseContextType query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
contextType <- allocMem :: IO (Ptr CString)
result <- gst_query_parse_context_type query' contextType
let result' = (/= 0) result
contextType' <- peek contextType
contextType'' <- cstringToText contextType'
touchManagedPtr query
freeMem contextType
return (result', contextType'')
#if ENABLE_OVERLOADING
data QueryParseContextTypeMethodInfo
instance (signature ~ (m ((Bool, T.Text))), MonadIO m) => O.MethodInfo QueryParseContextTypeMethodInfo Query signature where
overloadedMethod _ = queryParseContextType
#endif
-- method Query::parse_convert
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the #GstFormat of the\n source value, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the source value, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the #GstFormat of the\n destination value, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the destination value,\n or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_convert" gst_query_parse_convert ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CUInt -> -- src_format : TInterface (Name {namespace = "Gst", name = "Format"})
Ptr Int64 -> -- src_value : TBasicType TInt64
Ptr CUInt -> -- dest_format : TInterface (Name {namespace = "Gst", name = "Format"})
Ptr Int64 -> -- dest_value : TBasicType TInt64
IO ()
{- |
Parse a convert query answer. Any of /@srcFormat@/, /@srcValue@/, /@destFormat@/,
and /@destValue@/ may be 'Nothing', in which case that value is omitted.
-}
queryParseConvert ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m ((Gst.Enums.Format, Int64, Gst.Enums.Format, Int64))
queryParseConvert query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
srcFormat <- allocMem :: IO (Ptr CUInt)
srcValue <- allocMem :: IO (Ptr Int64)
destFormat <- allocMem :: IO (Ptr CUInt)
destValue <- allocMem :: IO (Ptr Int64)
gst_query_parse_convert query' srcFormat srcValue destFormat destValue
srcFormat' <- peek srcFormat
let srcFormat'' = (toEnum . fromIntegral) srcFormat'
srcValue' <- peek srcValue
destFormat' <- peek destFormat
let destFormat'' = (toEnum . fromIntegral) destFormat'
destValue' <- peek destValue
touchManagedPtr query
freeMem srcFormat
freeMem srcValue
freeMem destFormat
freeMem destValue
return (srcFormat'', srcValue', destFormat'', destValue')
#if ENABLE_OVERLOADING
data QueryParseConvertMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Int64, Gst.Enums.Format, Int64))), MonadIO m) => O.MethodInfo QueryParseConvertMethodInfo Query signature where
overloadedMethod _ = queryParseConvert
#endif
-- method Query::parse_duration
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the #GstFormat of the duration\n value, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the total duration, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_duration" gst_query_parse_duration ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Ptr Int64 -> -- duration : TBasicType TInt64
IO ()
{- |
Parse a duration query answer. Write the format of the duration into /@format@/,
and the value into /@duration@/, if the respective variables are non-'Nothing'.
-}
queryParseDuration ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m ((Gst.Enums.Format, Int64))
queryParseDuration query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
format <- allocMem :: IO (Ptr CUInt)
duration <- allocMem :: IO (Ptr Int64)
gst_query_parse_duration query' format duration
format' <- peek format
let format'' = (toEnum . fromIntegral) format'
duration' <- peek duration
touchManagedPtr query
freeMem format
freeMem duration
return (format'', duration')
#if ENABLE_OVERLOADING
data QueryParseDurationMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Int64))), MonadIO m) => O.MethodInfo QueryParseDurationMethodInfo Query signature where
overloadedMethod _ = queryParseDuration
#endif
-- method Query::parse_latency
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "storage for live or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the min latency or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the max latency or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_latency" gst_query_parse_latency ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CInt -> -- live : TBasicType TBoolean
Ptr Word64 -> -- min_latency : TBasicType TUInt64
Ptr Word64 -> -- max_latency : TBasicType TUInt64
IO ()
{- |
Parse a latency query answer.
-}
queryParseLatency ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m ((Bool, Word64, Word64))
queryParseLatency query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
live <- allocMem :: IO (Ptr CInt)
minLatency <- allocMem :: IO (Ptr Word64)
maxLatency <- allocMem :: IO (Ptr Word64)
gst_query_parse_latency query' live minLatency maxLatency
live' <- peek live
let live'' = (/= 0) live'
minLatency' <- peek minLatency
maxLatency' <- peek maxLatency
touchManagedPtr query
freeMem live
freeMem minLatency
freeMem maxLatency
return (live'', minLatency', maxLatency')
#if ENABLE_OVERLOADING
data QueryParseLatencyMethodInfo
instance (signature ~ (m ((Bool, Word64, Word64))), MonadIO m) => O.MethodInfo QueryParseLatencyMethodInfo Query signature where
overloadedMethod _ = queryParseLatency
#endif
-- method Query::parse_n_formats
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_formats", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of formats in this query.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_n_formats" gst_query_parse_n_formats ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr Word32 -> -- n_formats : TBasicType TUInt
IO ()
{- |
Parse the number of formats in the formats /@query@/.
-}
queryParseNFormats ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m (Word32)
queryParseNFormats query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
nFormats <- allocMem :: IO (Ptr Word32)
gst_query_parse_n_formats query' nFormats
nFormats' <- peek nFormats
touchManagedPtr query
freeMem nFormats
return nFormats'
#if ENABLE_OVERLOADING
data QueryParseNFormatsMethodInfo
instance (signature ~ (m (Word32)), MonadIO m) => O.MethodInfo QueryParseNFormatsMethodInfo Query signature where
overloadedMethod _ = queryParseNFormats
#endif
-- method Query::parse_nth_allocation_meta
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the metadata API array to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "API specific parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TGType)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_nth_allocation_meta" gst_query_parse_nth_allocation_meta ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
Ptr (Ptr Gst.Structure.Structure) -> -- params : TInterface (Name {namespace = "Gst", name = "Structure"})
IO CGType
{- |
Parse an available query and get the metadata API
at /@index@/ of the metadata API array.
-}
queryParseNthAllocationMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@index@/: position in the metadata API array to read -}
-> m ((GType, Gst.Structure.Structure))
{- ^ __Returns:__ a 'GType' of the metadata API at /@index@/. -}
queryParseNthAllocationMeta query index = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
params <- allocMem :: IO (Ptr (Ptr Gst.Structure.Structure))
result <- gst_query_parse_nth_allocation_meta query' index params
let result' = GType result
params' <- peek params
params'' <- (newBoxed Gst.Structure.Structure) params'
touchManagedPtr query
freeMem params
return (result', params'')
#if ENABLE_OVERLOADING
data QueryParseNthAllocationMetaMethodInfo
instance (signature ~ (Word32 -> m ((GType, Gst.Structure.Structure))), MonadIO m) => O.MethodInfo QueryParseNthAllocationMetaMethodInfo Query signature where
overloadedMethod _ = queryParseNthAllocationMeta
#endif
-- method Query::parse_nth_allocation_param
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the allocator array to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "variable to hold the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "parameters for the allocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_nth_allocation_param" gst_query_parse_nth_allocation_param ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
Ptr (Ptr Gst.Allocator.Allocator) -> -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"})
Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"})
IO ()
{- |
Parse an available query and get the allocator and its params
at /@index@/ of the allocator array.
-}
queryParseNthAllocationParam ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@index@/: position in the allocator array to read -}
-> m ((Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams))
queryParseNthAllocationParam query index = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator.Allocator))
params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams.AllocationParams)
gst_query_parse_nth_allocation_param query' index allocator params
allocator' <- peek allocator
allocator'' <- (wrapObject Gst.Allocator.Allocator) allocator'
params' <- (wrapBoxed Gst.AllocationParams.AllocationParams) params
touchManagedPtr query
freeMem allocator
return (allocator'', params')
#if ENABLE_OVERLOADING
data QueryParseNthAllocationParamMethodInfo
instance (signature ~ (Word32 -> m ((Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams))), MonadIO m) => O.MethodInfo QueryParseNthAllocationParamMethodInfo Query signature where
overloadedMethod _ = queryParseNthAllocationParam
#endif
-- method Query::parse_nth_allocation_pool
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_ALLOCATION.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_buffers", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the min buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_buffers", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the max buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_nth_allocation_pool" gst_query_parse_nth_allocation_pool ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
Ptr (Ptr Gst.BufferPool.BufferPool) -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"})
Ptr Word32 -> -- size : TBasicType TUInt
Ptr Word32 -> -- min_buffers : TBasicType TUInt
Ptr Word32 -> -- max_buffers : TBasicType TUInt
IO ()
{- |
Get the pool parameters in /@query@/.
Unref /@pool@/ with 'GI.Gst.Objects.Object.objectUnref' when it\'s not needed any more.
-}
queryParseNthAllocationPool ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_ALLOCATION. -}
-> Word32
{- ^ /@index@/: index to parse -}
-> m ((Gst.BufferPool.BufferPool, Word32, Word32, Word32))
queryParseNthAllocationPool query index = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
pool <- allocMem :: IO (Ptr (Ptr Gst.BufferPool.BufferPool))
size <- allocMem :: IO (Ptr Word32)
minBuffers <- allocMem :: IO (Ptr Word32)
maxBuffers <- allocMem :: IO (Ptr Word32)
gst_query_parse_nth_allocation_pool query' index pool size minBuffers maxBuffers
pool' <- peek pool
pool'' <- (wrapObject Gst.BufferPool.BufferPool) pool'
size' <- peek size
minBuffers' <- peek minBuffers
maxBuffers' <- peek maxBuffers
touchManagedPtr query
freeMem pool
freeMem size
freeMem minBuffers
freeMem maxBuffers
return (pool'', size', minBuffers', maxBuffers')
#if ENABLE_OVERLOADING
data QueryParseNthAllocationPoolMethodInfo
instance (signature ~ (Word32 -> m ((Gst.BufferPool.BufferPool, Word32, Word32, Word32))), MonadIO m) => O.MethodInfo QueryParseNthAllocationPoolMethodInfo Query signature where
overloadedMethod _ = queryParseNthAllocationPool
#endif
-- method Query::parse_nth_buffering_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_BUFFERING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the buffered-ranges array to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start position to set, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stop position to set, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_nth_buffering_range" gst_query_parse_nth_buffering_range ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
Ptr Int64 -> -- start : TBasicType TInt64
Ptr Int64 -> -- stop : TBasicType TInt64
IO CInt
{- |
Parse an available query and get the start and stop values stored
at the /@index@/ of the buffered ranges array.
-}
queryParseNthBufferingRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_BUFFERING type query 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@index@/: position in the buffered-ranges array to read -}
-> m ((Bool, Int64, Int64))
{- ^ __Returns:__ a 'Bool' indicating if the parsing succeeded. -}
queryParseNthBufferingRange query index = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
start <- allocMem :: IO (Ptr Int64)
stop <- allocMem :: IO (Ptr Int64)
result <- gst_query_parse_nth_buffering_range query' index start stop
let result' = (/= 0) result
start' <- peek start
stop' <- peek stop
touchManagedPtr query
freeMem start
freeMem stop
return (result', start', stop')
#if ENABLE_OVERLOADING
data QueryParseNthBufferingRangeMethodInfo
instance (signature ~ (Word32 -> m ((Bool, Int64, Int64))), MonadIO m) => O.MethodInfo QueryParseNthBufferingRangeMethodInfo Query signature where
overloadedMethod _ = queryParseNthBufferingRange
#endif
-- method Query::parse_nth_format
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nth", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the nth format to retrieve.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to store the nth format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_nth_format" gst_query_parse_nth_format ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- nth : TBasicType TUInt
Ptr CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
IO ()
{- |
Parse the format query and retrieve the /@nth@/ format from it into
/@format@/. If the list contains less elements than /@nth@/, /@format@/ will be
set to GST_FORMAT_UNDEFINED.
-}
queryParseNthFormat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@nth@/: the nth format to retrieve. -}
-> m (Gst.Enums.Format)
queryParseNthFormat query nth = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
format <- allocMem :: IO (Ptr CUInt)
gst_query_parse_nth_format query' nth format
format' <- peek format
let format'' = (toEnum . fromIntegral) format'
touchManagedPtr query
freeMem format
return format''
#if ENABLE_OVERLOADING
data QueryParseNthFormatMethodInfo
instance (signature ~ (Word32 -> m (Gst.Enums.Format)), MonadIO m) => O.MethodInfo QueryParseNthFormatMethodInfo Query signature where
overloadedMethod _ = queryParseNthFormat
#endif
-- method Query::parse_nth_scheduling_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_SCHEDULING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the scheduling modes array to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "PadMode"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_nth_scheduling_mode" gst_query_parse_nth_scheduling_mode ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
IO CUInt
{- |
Parse an available query and get the scheduling mode
at /@index@/ of the scheduling modes array.
-}
queryParseNthSchedulingMode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_SCHEDULING type query 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@index@/: position in the scheduling modes array to read -}
-> m Gst.Enums.PadMode
{- ^ __Returns:__ a 'GI.Gst.Enums.PadMode' of the scheduling mode at /@index@/. -}
queryParseNthSchedulingMode query index = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_parse_nth_scheduling_mode query' index
let result' = (toEnum . fromIntegral) result
touchManagedPtr query
return result'
#if ENABLE_OVERLOADING
data QueryParseNthSchedulingModeMethodInfo
instance (signature ~ (Word32 -> m Gst.Enums.PadMode), MonadIO m) => O.MethodInfo QueryParseNthSchedulingModeMethodInfo Query signature where
overloadedMethod _ = queryParseNthSchedulingMode
#endif
-- method Query::parse_position
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the #GstFormat of the\n position values (may be %NULL)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the current position (may be %NULL)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_position" gst_query_parse_position ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Ptr Int64 -> -- cur : TBasicType TInt64
IO ()
{- |
Parse a position query, writing the format into /@format@/, and the position
into /@cur@/, if the respective parameters are non-'Nothing'.
-}
queryParsePosition ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m ((Gst.Enums.Format, Int64))
queryParsePosition query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
format <- allocMem :: IO (Ptr CUInt)
cur <- allocMem :: IO (Ptr Int64)
gst_query_parse_position query' format cur
format' <- peek format
let format'' = (toEnum . fromIntegral) format'
cur' <- peek cur
touchManagedPtr query
freeMem format
freeMem cur
return (format'', cur')
#if ENABLE_OVERLOADING
data QueryParsePositionMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Int64))), MonadIO m) => O.MethodInfo QueryParsePositionMethodInfo Query signature where
overloadedMethod _ = queryParsePosition
#endif
-- method Query::parse_scheduling
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_SCHEDULING.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "SchedulingFlags"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstSchedulingFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minsize", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the suggested minimum size of pull requests", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the suggested maximum size of pull requests:", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "align", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the suggested alignment of pull requests", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_scheduling" gst_query_parse_scheduling ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "SchedulingFlags"})
Ptr Int32 -> -- minsize : TBasicType TInt
Ptr Int32 -> -- maxsize : TBasicType TInt
Ptr Int32 -> -- align : TBasicType TInt
IO ()
{- |
Set the scheduling properties.
-}
queryParseScheduling ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_SCHEDULING. -}
-> m (([Gst.Flags.SchedulingFlags], Int32, Int32, Int32))
queryParseScheduling query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
flags <- allocMem :: IO (Ptr CUInt)
minsize <- allocMem :: IO (Ptr Int32)
maxsize <- allocMem :: IO (Ptr Int32)
align <- allocMem :: IO (Ptr Int32)
gst_query_parse_scheduling query' flags minsize maxsize align
flags' <- peek flags
let flags'' = wordToGFlags flags'
minsize' <- peek minsize
maxsize' <- peek maxsize
align' <- peek align
touchManagedPtr query
freeMem flags
freeMem minsize
freeMem maxsize
freeMem align
return (flags'', minsize', maxsize', align')
#if ENABLE_OVERLOADING
data QueryParseSchedulingMethodInfo
instance (signature ~ (m (([Gst.Flags.SchedulingFlags], Int32, Int32, Int32))), MonadIO m) => O.MethodInfo QueryParseSchedulingMethodInfo Query signature where
overloadedMethod _ = queryParseScheduling
#endif
-- method Query::parse_seeking
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_SEEKING type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the format to set for the @segment_start\n and @segment_end values, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "seekable", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the seekable flag to set, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "segment_start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the segment_start to set, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "segment_end", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the segment_end to set, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_seeking" gst_query_parse_seeking ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Ptr CInt -> -- seekable : TBasicType TBoolean
Ptr Int64 -> -- segment_start : TBasicType TInt64
Ptr Int64 -> -- segment_end : TBasicType TInt64
IO ()
{- |
Parse a seeking query, writing the format into /@format@/, and
other results into the passed parameters, if the respective parameters
are non-'Nothing'
-}
queryParseSeeking ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_SEEKING type query 'GI.Gst.Structs.Query.Query' -}
-> m ((Gst.Enums.Format, Bool, Int64, Int64))
queryParseSeeking query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
format <- allocMem :: IO (Ptr CUInt)
seekable <- allocMem :: IO (Ptr CInt)
segmentStart <- allocMem :: IO (Ptr Int64)
segmentEnd <- allocMem :: IO (Ptr Int64)
gst_query_parse_seeking query' format seekable segmentStart segmentEnd
format' <- peek format
let format'' = (toEnum . fromIntegral) format'
seekable' <- peek seekable
let seekable'' = (/= 0) seekable'
segmentStart' <- peek segmentStart
segmentEnd' <- peek segmentEnd
touchManagedPtr query
freeMem format
freeMem seekable
freeMem segmentStart
freeMem segmentEnd
return (format'', seekable'', segmentStart', segmentEnd')
#if ENABLE_OVERLOADING
data QueryParseSeekingMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Bool, Int64, Int64))), MonadIO m) => O.MethodInfo QueryParseSeekingMethodInfo Query signature where
overloadedMethod _ = queryParseSeeking
#endif
-- method Query::parse_segment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the rate of the segment, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the #GstFormat of the values,\n or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the start value, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the stop value, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_segment" gst_query_parse_segment ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CDouble -> -- rate : TBasicType TDouble
Ptr CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Ptr Int64 -> -- start_value : TBasicType TInt64
Ptr Int64 -> -- stop_value : TBasicType TInt64
IO ()
{- |
Parse a segment query answer. Any of /@rate@/, /@format@/, /@startValue@/, and
/@stopValue@/ may be 'Nothing', which will cause this value to be omitted.
See 'GI.Gst.Structs.Query.querySetSegment' for an explanation of the function arguments.
-}
queryParseSegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m ((Double, Gst.Enums.Format, Int64, Int64))
queryParseSegment query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
rate <- allocMem :: IO (Ptr CDouble)
format <- allocMem :: IO (Ptr CUInt)
startValue <- allocMem :: IO (Ptr Int64)
stopValue <- allocMem :: IO (Ptr Int64)
gst_query_parse_segment query' rate format startValue stopValue
rate' <- peek rate
let rate'' = realToFrac rate'
format' <- peek format
let format'' = (toEnum . fromIntegral) format'
startValue' <- peek startValue
stopValue' <- peek stopValue
touchManagedPtr query
freeMem rate
freeMem format
freeMem startValue
freeMem stopValue
return (rate'', format'', startValue', stopValue')
#if ENABLE_OVERLOADING
data QueryParseSegmentMethodInfo
instance (signature ~ (m ((Double, Gst.Enums.Format, Int64, Int64))), MonadIO m) => O.MethodInfo QueryParseSegmentMethodInfo Query signature where
overloadedMethod _ = queryParseSegment
#endif
-- method Query::parse_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the current URI\n (may be %NULL)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_uri" gst_query_parse_uri ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CString -> -- uri : TBasicType TUTF8
IO ()
{- |
Parse an URI query, writing the URI into /@uri@/ as a newly
allocated string, if the respective parameters are non-'Nothing'.
Free the string with 'GI.GLib.Functions.free' after usage.
-}
queryParseUri ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m (T.Text)
queryParseUri query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
uri <- allocMem :: IO (Ptr CString)
gst_query_parse_uri query' uri
uri' <- peek uri
uri'' <- cstringToText uri'
freeMem uri'
touchManagedPtr query
freeMem uri
return uri''
#if ENABLE_OVERLOADING
data QueryParseUriMethodInfo
instance (signature ~ (m (T.Text)), MonadIO m) => O.MethodInfo QueryParseUriMethodInfo Query signature where
overloadedMethod _ = queryParseUri
#endif
-- method Query::parse_uri_redirection
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the storage for the redirect URI\n (may be %NULL)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_uri_redirection" gst_query_parse_uri_redirection ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CString -> -- uri : TBasicType TUTF8
IO ()
{- |
Parse an URI query, writing the URI into /@uri@/ as a newly
allocated string, if the respective parameters are non-'Nothing'.
Free the string with 'GI.GLib.Functions.free' after usage.
/Since: 1.2/
-}
queryParseUriRedirection ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m (T.Text)
queryParseUriRedirection query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
uri <- allocMem :: IO (Ptr CString)
gst_query_parse_uri_redirection query' uri
uri' <- peek uri
uri'' <- cstringToText uri'
freeMem uri'
touchManagedPtr query
freeMem uri
return uri''
#if ENABLE_OVERLOADING
data QueryParseUriRedirectionMethodInfo
instance (signature ~ (m (T.Text)), MonadIO m) => O.MethodInfo QueryParseUriRedirectionMethodInfo Query signature where
overloadedMethod _ = queryParseUriRedirection
#endif
-- method Query::parse_uri_redirection_permanent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "permanent", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if the URI redirection is permanent\n (may be %NULL)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_parse_uri_redirection_permanent" gst_query_parse_uri_redirection_permanent ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr CInt -> -- permanent : TBasicType TBoolean
IO ()
{- |
Parse an URI query, and set /@permanent@/ to 'True' if there is a redirection
and it should be considered permanent. If a redirection is permanent,
applications should update their internal storage of the URI, otherwise
they should make all future requests to the original URI.
/Since: 1.4/
-}
queryParseUriRedirectionPermanent ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m (Bool)
queryParseUriRedirectionPermanent query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
permanent <- allocMem :: IO (Ptr CInt)
gst_query_parse_uri_redirection_permanent query' permanent
permanent' <- peek permanent
let permanent'' = (/= 0) permanent'
touchManagedPtr query
freeMem permanent
return permanent''
#if ENABLE_OVERLOADING
data QueryParseUriRedirectionPermanentMethodInfo
instance (signature ~ (m (Bool)), MonadIO m) => O.MethodInfo QueryParseUriRedirectionPermanentMethodInfo Query signature where
overloadedMethod _ = queryParseUriRedirectionPermanent
#endif
-- method Query::remove_nth_allocation_meta
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the metadata API array to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_remove_nth_allocation_meta" gst_query_remove_nth_allocation_meta ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
IO ()
{- |
Remove the metadata API at /@index@/ of the metadata API array.
-}
queryRemoveNthAllocationMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@index@/: position in the metadata API array to remove -}
-> m ()
queryRemoveNthAllocationMeta query index = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
gst_query_remove_nth_allocation_meta query' index
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QueryRemoveNthAllocationMetaMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo QueryRemoveNthAllocationMetaMethodInfo Query signature where
overloadedMethod _ = queryRemoveNthAllocationMeta
#endif
-- method Query::remove_nth_allocation_param
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the allocation param array to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_remove_nth_allocation_param" gst_query_remove_nth_allocation_param ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
IO ()
{- |
Remove the allocation param at /@index@/ of the allocation param array.
/Since: 1.2/
-}
queryRemoveNthAllocationParam ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@index@/: position in the allocation param array to remove -}
-> m ()
queryRemoveNthAllocationParam query index = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
gst_query_remove_nth_allocation_param query' index
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QueryRemoveNthAllocationParamMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo QueryRemoveNthAllocationParamMethodInfo Query signature where
overloadedMethod _ = queryRemoveNthAllocationParam
#endif
-- method Query::remove_nth_allocation_pool
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the allocation pool array to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_remove_nth_allocation_pool" gst_query_remove_nth_allocation_pool ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
IO ()
{- |
Remove the allocation pool at /@index@/ of the allocation pool array.
/Since: 1.2/
-}
queryRemoveNthAllocationPool ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@index@/: position in the allocation pool array to remove -}
-> m ()
queryRemoveNthAllocationPool query index = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
gst_query_remove_nth_allocation_pool query' index
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QueryRemoveNthAllocationPoolMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo QueryRemoveNthAllocationPoolMethodInfo Query signature where
overloadedMethod _ = queryRemoveNthAllocationPool
#endif
-- method Query::set_accept_caps_result
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ACCEPT_CAPS type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the result to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_accept_caps_result" gst_query_set_accept_caps_result ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CInt -> -- result : TBasicType TBoolean
IO ()
{- |
Set /@result@/ as the result for the /@query@/.
-}
querySetAcceptCapsResult ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_ACCEPT_CAPS type query 'GI.Gst.Structs.Query.Query' -}
-> Bool
{- ^ /@result@/: the result to set -}
-> m ()
querySetAcceptCapsResult query result_ = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let result_' = (fromIntegral . fromEnum) result_
gst_query_set_accept_caps_result query' result_'
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetAcceptCapsResultMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo QuerySetAcceptCapsResultMethodInfo Query signature where
overloadedMethod _ = querySetAcceptCapsResult
#endif
-- method Query::set_bitrate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_BITRATE type #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nominal_bitrate", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the nominal bitrate in bits per second", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_bitrate" gst_query_set_bitrate ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- nominal_bitrate : TBasicType TUInt
IO ()
{- |
Set the results of a bitrate query. The nominal bitrate is the average
bitrate expected over the length of the stream as advertised in file
headers (or similar).
/Since: 1.16/
-}
querySetBitrate ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a GST_QUERY_BITRATE type 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@nominalBitrate@/: the nominal bitrate in bits per second -}
-> m ()
querySetBitrate query nominalBitrate = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
gst_query_set_bitrate query' nominalBitrate
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetBitrateMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo QuerySetBitrateMethodInfo Query signature where
overloadedMethod _ = querySetBitrate
#endif
-- method Query::set_buffering_percent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_BUFFERING.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if buffering is busy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "percent", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffering percent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_buffering_percent" gst_query_set_buffering_percent ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CInt -> -- busy : TBasicType TBoolean
Int32 -> -- percent : TBasicType TInt
IO ()
{- |
Set the percentage of buffered data. This is a value between 0 and 100.
The /@busy@/ indicator is 'True' when the buffering is in progress.
-}
querySetBufferingPercent ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_BUFFERING. -}
-> Bool
{- ^ /@busy@/: if buffering is busy -}
-> Int32
{- ^ /@percent@/: a buffering percent -}
-> m ()
querySetBufferingPercent query busy percent = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let busy' = (fromIntegral . fromEnum) busy
gst_query_set_buffering_percent query' busy' percent
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetBufferingPercentMethodInfo
instance (signature ~ (Bool -> Int32 -> m ()), MonadIO m) => O.MethodInfo QuerySetBufferingPercentMethodInfo Query signature where
overloadedMethod _ = querySetBufferingPercent
#endif
-- method Query::set_buffering_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the format to set for the @start and @stop values", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stop to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "estimated_total", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "estimated total amount of download time remaining in\n milliseconds", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_buffering_range" gst_query_set_buffering_range ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Int64 -> -- start : TBasicType TInt64
Int64 -> -- stop : TBasicType TInt64
Int64 -> -- estimated_total : TBasicType TInt64
IO ()
{- |
Set the available query result fields in /@query@/.
-}
querySetBufferingRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> Gst.Enums.Format
{- ^ /@format@/: the format to set for the /@start@/ and /@stop@/ values -}
-> Int64
{- ^ /@start@/: the start to set -}
-> Int64
{- ^ /@stop@/: the stop to set -}
-> Int64
{- ^ /@estimatedTotal@/: estimated total amount of download time remaining in
milliseconds -}
-> m ()
querySetBufferingRange query format start stop estimatedTotal = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let format' = (fromIntegral . fromEnum) format
gst_query_set_buffering_range query' format' start stop estimatedTotal
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetBufferingRangeMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo QuerySetBufferingRangeMethodInfo Query signature where
overloadedMethod _ = querySetBufferingRange
#endif
-- method Query::set_buffering_stats
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_BUFFERING.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "BufferingMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffering mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_in", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the average input rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_out", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the average output rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "amount of buffering time left in milliseconds", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_buffering_stats" gst_query_set_buffering_stats ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- mode : TInterface (Name {namespace = "Gst", name = "BufferingMode"})
Int32 -> -- avg_in : TBasicType TInt
Int32 -> -- avg_out : TBasicType TInt
Int64 -> -- buffering_left : TBasicType TInt64
IO ()
{- |
Configures the buffering stats values in /@query@/.
-}
querySetBufferingStats ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_BUFFERING. -}
-> Gst.Enums.BufferingMode
{- ^ /@mode@/: a buffering mode -}
-> Int32
{- ^ /@avgIn@/: the average input rate -}
-> Int32
{- ^ /@avgOut@/: the average output rate -}
-> Int64
{- ^ /@bufferingLeft@/: amount of buffering time left in milliseconds -}
-> m ()
querySetBufferingStats query mode avgIn avgOut bufferingLeft = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let mode' = (fromIntegral . fromEnum) mode
gst_query_set_buffering_stats query' mode' avgIn avgOut bufferingLeft
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetBufferingStatsMethodInfo
instance (signature ~ (Gst.Enums.BufferingMode -> Int32 -> Int32 -> Int64 -> m ()), MonadIO m) => O.MethodInfo QuerySetBufferingStatsMethodInfo Query signature where
overloadedMethod _ = querySetBufferingStats
#endif
-- method Query::set_caps_result
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The query to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_caps_result" gst_query_set_caps_result ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
IO ()
{- |
Set the /@caps@/ result in /@query@/.
-}
querySetCapsResult ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: The query to use -}
-> Gst.Caps.Caps
{- ^ /@caps@/: A pointer to the caps -}
-> m ()
querySetCapsResult query caps = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
caps' <- unsafeManagedPtrGetPtr caps
gst_query_set_caps_result query' caps'
touchManagedPtr query
touchManagedPtr caps
return ()
#if ENABLE_OVERLOADING
data QuerySetCapsResultMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m ()), MonadIO m) => O.MethodInfo QuerySetCapsResultMethodInfo Query signature where
overloadedMethod _ = querySetCapsResult
#endif
-- method Query::set_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery with query type GST_QUERY_CONTEXT", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "Gst", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the requested #GstContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_context" gst_query_set_context ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Ptr Gst.Context.Context -> -- context : TInterface (Name {namespace = "Gst", name = "Context"})
IO ()
{- |
Answer a context query by setting the requested context.
/Since: 1.2/
-}
querySetContext ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' with query type GST_QUERY_CONTEXT -}
-> Gst.Context.Context
{- ^ /@context@/: the requested 'GI.Gst.Structs.Context.Context' -}
-> m ()
querySetContext query context = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
context' <- unsafeManagedPtrGetPtr context
gst_query_set_context query' context'
touchManagedPtr query
touchManagedPtr context
return ()
#if ENABLE_OVERLOADING
data QuerySetContextMethodInfo
instance (signature ~ (Gst.Context.Context -> m ()), MonadIO m) => O.MethodInfo QuerySetContextMethodInfo Query signature where
overloadedMethod _ = querySetContext
#endif
-- method Query::set_convert
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source #GstFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the destination #GstFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the destination value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_convert" gst_query_set_convert ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- src_format : TInterface (Name {namespace = "Gst", name = "Format"})
Int64 -> -- src_value : TBasicType TInt64
CUInt -> -- dest_format : TInterface (Name {namespace = "Gst", name = "Format"})
Int64 -> -- dest_value : TBasicType TInt64
IO ()
{- |
Answer a convert query by setting the requested values.
-}
querySetConvert ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> Gst.Enums.Format
{- ^ /@srcFormat@/: the source 'GI.Gst.Enums.Format' -}
-> Int64
{- ^ /@srcValue@/: the source value -}
-> Gst.Enums.Format
{- ^ /@destFormat@/: the destination 'GI.Gst.Enums.Format' -}
-> Int64
{- ^ /@destValue@/: the destination value -}
-> m ()
querySetConvert query srcFormat srcValue destFormat destValue = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let srcFormat' = (fromIntegral . fromEnum) srcFormat
let destFormat' = (fromIntegral . fromEnum) destFormat
gst_query_set_convert query' srcFormat' srcValue destFormat' destValue
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetConvertMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> Gst.Enums.Format -> Int64 -> m ()), MonadIO m) => O.MethodInfo QuerySetConvertMethodInfo Query signature where
overloadedMethod _ = querySetConvert
#endif
-- method Query::set_duration
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat for the duration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the duration of the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_duration" gst_query_set_duration ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Int64 -> -- duration : TBasicType TInt64
IO ()
{- |
Answer a duration query by setting the requested value in the given format.
-}
querySetDuration ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> Gst.Enums.Format
{- ^ /@format@/: the 'GI.Gst.Enums.Format' for the duration -}
-> Int64
{- ^ /@duration@/: the duration of the stream -}
-> m ()
querySetDuration query format duration = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let format' = (fromIntegral . fromEnum) format
gst_query_set_duration query' format' duration
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetDurationMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> m ()), MonadIO m) => O.MethodInfo QuerySetDurationMethodInfo Query signature where
overloadedMethod _ = querySetDuration
#endif
-- method Query::set_formatsv
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_formats", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of formats to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "formats", argType = TCArray False (-1) 1 (TInterface (Name {namespace = "Gst", name = "Format"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an array containing @n_formats\n @GstFormat values.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "n_formats", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of formats to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_formatsv" gst_query_set_formatsv ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Int32 -> -- n_formats : TBasicType TInt
Ptr CUInt -> -- formats : TCArray False (-1) 1 (TInterface (Name {namespace = "Gst", name = "Format"}))
IO ()
{- |
Set the formats query result fields in /@query@/. The number of formats passed
in the /@formats@/ array must be equal to /@nFormats@/.
-}
querySetFormatsv ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> [Gst.Enums.Format]
{- ^ /@formats@/: an array containing /@nFormats@/
/@gstFormat@/ values. -}
-> m ()
querySetFormatsv query formats = liftIO $ do
let nFormats = fromIntegral $ length formats
query' <- unsafeManagedPtrGetPtr query
let formats' = map (fromIntegral . fromEnum) formats
formats'' <- packStorableArray formats'
gst_query_set_formatsv query' nFormats formats''
touchManagedPtr query
freeMem formats''
return ()
#if ENABLE_OVERLOADING
data QuerySetFormatsvMethodInfo
instance (signature ~ ([Gst.Enums.Format] -> m ()), MonadIO m) => O.MethodInfo QuerySetFormatsvMethodInfo Query signature where
overloadedMethod _ = querySetFormatsv
#endif
-- method Query::set_latency
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if there is a live element upstream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimal latency of the upstream elements", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximal latency of the upstream elements", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_latency" gst_query_set_latency ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CInt -> -- live : TBasicType TBoolean
Word64 -> -- min_latency : TBasicType TUInt64
Word64 -> -- max_latency : TBasicType TUInt64
IO ()
{- |
Answer a latency query by setting the requested values in the given format.
-}
querySetLatency ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> Bool
{- ^ /@live@/: if there is a live element upstream -}
-> Word64
{- ^ /@minLatency@/: the minimal latency of the upstream elements -}
-> Word64
{- ^ /@maxLatency@/: the maximal latency of the upstream elements -}
-> m ()
querySetLatency query live minLatency maxLatency = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let live' = (fromIntegral . fromEnum) live
gst_query_set_latency query' live' minLatency maxLatency
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetLatencyMethodInfo
instance (signature ~ (Bool -> Word64 -> Word64 -> m ()), MonadIO m) => O.MethodInfo QuerySetLatencyMethodInfo Query signature where
overloadedMethod _ = querySetLatency
#endif
-- method Query::set_nth_allocation_param
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GST_QUERY_ALLOCATION type query #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the allocator array to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "new allocator to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "parameters for the allocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_nth_allocation_param" gst_query_set_nth_allocation_param ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
Ptr Gst.Allocator.Allocator -> -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"})
Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"})
IO ()
{- |
Parse an available query and get the allocator and its params
at /@index@/ of the allocator array.
-}
querySetNthAllocationParam ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Allocator.IsAllocator a) =>
Query
{- ^ /@query@/: a GST_QUERY_ALLOCATION type query 'GI.Gst.Structs.Query.Query' -}
-> Word32
{- ^ /@index@/: position in the allocator array to set -}
-> Maybe (a)
{- ^ /@allocator@/: new allocator to set -}
-> Maybe (Gst.AllocationParams.AllocationParams)
{- ^ /@params@/: parameters for the allocator -}
-> m ()
querySetNthAllocationParam query index allocator params = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
maybeAllocator <- case allocator of
Nothing -> return nullPtr
Just jAllocator -> do
jAllocator' <- unsafeManagedPtrCastPtr jAllocator
return jAllocator'
maybeParams <- case params of
Nothing -> return nullPtr
Just jParams -> do
jParams' <- unsafeManagedPtrGetPtr jParams
return jParams'
gst_query_set_nth_allocation_param query' index maybeAllocator maybeParams
touchManagedPtr query
whenJust allocator touchManagedPtr
whenJust params touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data QuerySetNthAllocationParamMethodInfo
instance (signature ~ (Word32 -> Maybe (a) -> Maybe (Gst.AllocationParams.AllocationParams) -> m ()), MonadIO m, Gst.Allocator.IsAllocator a) => O.MethodInfo QuerySetNthAllocationParamMethodInfo Query signature where
overloadedMethod _ = querySetNthAllocationParam
#endif
-- method Query::set_nth_allocation_pool
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_ALLOCATION.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index to modify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the min buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the max buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_nth_allocation_pool" gst_query_set_nth_allocation_pool ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
Word32 -> -- index : TBasicType TUInt
Ptr Gst.BufferPool.BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"})
Word32 -> -- size : TBasicType TUInt
Word32 -> -- min_buffers : TBasicType TUInt
Word32 -> -- max_buffers : TBasicType TUInt
IO ()
{- |
Set the pool parameters in /@query@/.
-}
querySetNthAllocationPool ::
(B.CallStack.HasCallStack, MonadIO m, Gst.BufferPool.IsBufferPool a) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_ALLOCATION. -}
-> Word32
{- ^ /@index@/: index to modify -}
-> Maybe (a)
{- ^ /@pool@/: the 'GI.Gst.Objects.BufferPool.BufferPool' -}
-> Word32
{- ^ /@size@/: the buffer size -}
-> Word32
{- ^ /@minBuffers@/: the min buffers -}
-> Word32
{- ^ /@maxBuffers@/: the max buffers -}
-> m ()
querySetNthAllocationPool query index pool size minBuffers maxBuffers = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
maybePool <- case pool of
Nothing -> return nullPtr
Just jPool -> do
jPool' <- unsafeManagedPtrCastPtr jPool
return jPool'
gst_query_set_nth_allocation_pool query' index maybePool size minBuffers maxBuffers
touchManagedPtr query
whenJust pool touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data QuerySetNthAllocationPoolMethodInfo
instance (signature ~ (Word32 -> Maybe (a) -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m, Gst.BufferPool.IsBufferPool a) => O.MethodInfo QuerySetNthAllocationPoolMethodInfo Query signature where
overloadedMethod _ = querySetNthAllocationPool
#endif
-- method Query::set_position
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery with query type GST_QUERY_POSITION", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the requested #GstFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_position" gst_query_set_position ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Int64 -> -- cur : TBasicType TInt64
IO ()
{- |
Answer a position query by setting the requested value in the given format.
-}
querySetPosition ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' with query type GST_QUERY_POSITION -}
-> Gst.Enums.Format
{- ^ /@format@/: the requested 'GI.Gst.Enums.Format' -}
-> Int64
{- ^ /@cur@/: the position to set -}
-> m ()
querySetPosition query format cur = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let format' = (fromIntegral . fromEnum) format
gst_query_set_position query' format' cur
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetPositionMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> m ()), MonadIO m) => O.MethodInfo QuerySetPositionMethodInfo Query signature where
overloadedMethod _ = querySetPosition
#endif
-- method Query::set_scheduling
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstQuery of type GST_QUERY_SCHEDULING.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "SchedulingFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstSchedulingFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minsize", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the suggested minimum size of pull requests", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the suggested maximum size of pull requests", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the suggested alignment of pull requests", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_scheduling" gst_query_set_scheduling ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "SchedulingFlags"})
Int32 -> -- minsize : TBasicType TInt
Int32 -> -- maxsize : TBasicType TInt
Int32 -> -- align : TBasicType TInt
IO ()
{- |
Set the scheduling properties.
-}
querySetScheduling ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: A valid 'GI.Gst.Structs.Query.Query' of type GST_QUERY_SCHEDULING. -}
-> [Gst.Flags.SchedulingFlags]
{- ^ /@flags@/: 'GI.Gst.Flags.SchedulingFlags' -}
-> Int32
{- ^ /@minsize@/: the suggested minimum size of pull requests -}
-> Int32
{- ^ /@maxsize@/: the suggested maximum size of pull requests -}
-> Int32
{- ^ /@align@/: the suggested alignment of pull requests -}
-> m ()
querySetScheduling query flags minsize maxsize align = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let flags' = gflagsToWord flags
gst_query_set_scheduling query' flags' minsize maxsize align
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetSchedulingMethodInfo
instance (signature ~ ([Gst.Flags.SchedulingFlags] -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m) => O.MethodInfo QuerySetSchedulingMethodInfo Query signature where
overloadedMethod _ = querySetScheduling
#endif
-- method Query::set_seeking
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the format to set for the @segment_start and @segment_end values", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seekable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the seekable flag to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment_start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the segment_start to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment_end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the segment_end to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_seeking" gst_query_set_seeking ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
CInt -> -- seekable : TBasicType TBoolean
Int64 -> -- segment_start : TBasicType TInt64
Int64 -> -- segment_end : TBasicType TInt64
IO ()
{- |
Set the seeking query result fields in /@query@/.
-}
querySetSeeking ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> Gst.Enums.Format
{- ^ /@format@/: the format to set for the /@segmentStart@/ and /@segmentEnd@/ values -}
-> Bool
{- ^ /@seekable@/: the seekable flag to set -}
-> Int64
{- ^ /@segmentStart@/: the segment_start to set -}
-> Int64
{- ^ /@segmentEnd@/: the segment_end to set -}
-> m ()
querySetSeeking query format seekable segmentStart segmentEnd = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let format' = (fromIntegral . fromEnum) format
let seekable' = (fromIntegral . fromEnum) seekable
gst_query_set_seeking query' format' seekable' segmentStart segmentEnd
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetSeekingMethodInfo
instance (signature ~ (Gst.Enums.Format -> Bool -> Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo QuerySetSeekingMethodInfo Query signature where
overloadedMethod _ = querySetSeeking
#endif
-- method Query::set_segment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the rate of the segment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat of the segment values (@start_value and @stop_value)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stop value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_segment" gst_query_set_segment ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CDouble -> -- rate : TBasicType TDouble
CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"})
Int64 -> -- start_value : TBasicType TInt64
Int64 -> -- stop_value : TBasicType TInt64
IO ()
{- |
Answer a segment query by setting the requested values. The normal
playback segment of a pipeline is 0 to duration at the default rate of
1.0. If a seek was performed on the pipeline to play a different
segment, this query will return the range specified in the last seek.
/@startValue@/ and /@stopValue@/ will respectively contain the configured
playback range start and stop values expressed in /@format@/.
The values are always between 0 and the duration of the media and
/@startValue@/ \<= /@stopValue@/. /@rate@/ will contain the playback rate. For
negative rates, playback will actually happen from /@stopValue@/ to
/@startValue@/.
-}
querySetSegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> Double
{- ^ /@rate@/: the rate of the segment -}
-> Gst.Enums.Format
{- ^ /@format@/: the 'GI.Gst.Enums.Format' of the segment values (/@startValue@/ and /@stopValue@/) -}
-> Int64
{- ^ /@startValue@/: the start value -}
-> Int64
{- ^ /@stopValue@/: the stop value -}
-> m ()
querySetSegment query rate format startValue stopValue = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let rate' = realToFrac rate
let format' = (fromIntegral . fromEnum) format
gst_query_set_segment query' rate' format' startValue stopValue
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetSegmentMethodInfo
instance (signature ~ (Double -> Gst.Enums.Format -> Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo QuerySetSegmentMethodInfo Query signature where
overloadedMethod _ = querySetSegment
#endif
-- method Query::set_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery with query type GST_QUERY_URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_uri" gst_query_set_uri ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CString -> -- uri : TBasicType TUTF8
IO ()
{- |
Answer a URI query by setting the requested URI.
-}
querySetUri ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' with query type GST_QUERY_URI -}
-> T.Text
{- ^ /@uri@/: the URI to set -}
-> m ()
querySetUri query uri = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
uri' <- textToCString uri
gst_query_set_uri query' uri'
touchManagedPtr query
freeMem uri'
return ()
#if ENABLE_OVERLOADING
data QuerySetUriMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo QuerySetUriMethodInfo Query signature where
overloadedMethod _ = querySetUri
#endif
-- method Query::set_uri_redirection
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery with query type GST_QUERY_URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_uri_redirection" gst_query_set_uri_redirection ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CString -> -- uri : TBasicType TUTF8
IO ()
{- |
Answer a URI query by setting the requested URI redirection.
/Since: 1.2/
-}
querySetUriRedirection ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' with query type GST_QUERY_URI -}
-> T.Text
{- ^ /@uri@/: the URI to set -}
-> m ()
querySetUriRedirection query uri = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
uri' <- textToCString uri
gst_query_set_uri_redirection query' uri'
touchManagedPtr query
freeMem uri'
return ()
#if ENABLE_OVERLOADING
data QuerySetUriRedirectionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo QuerySetUriRedirectionMethodInfo Query signature where
overloadedMethod _ = querySetUriRedirection
#endif
-- method Query::set_uri_redirection_permanent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery with query type %GST_QUERY_URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "permanent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the redirect is permanent or not", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_set_uri_redirection_permanent" gst_query_set_uri_redirection_permanent ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
CInt -> -- permanent : TBasicType TBoolean
IO ()
{- |
Answer a URI query by setting the requested URI redirection
to permanent or not.
/Since: 1.4/
-}
querySetUriRedirectionPermanent ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' with query type 'GI.Gst.Enums.QueryTypeUri' -}
-> Bool
{- ^ /@permanent@/: whether the redirect is permanent or not -}
-> m ()
querySetUriRedirectionPermanent query permanent = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
let permanent' = (fromIntegral . fromEnum) permanent
gst_query_set_uri_redirection_permanent query' permanent'
touchManagedPtr query
return ()
#if ENABLE_OVERLOADING
data QuerySetUriRedirectionPermanentMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo QuerySetUriRedirectionPermanentMethodInfo Query signature where
overloadedMethod _ = querySetUriRedirectionPermanent
#endif
-- method Query::writable_structure
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"}))
-- throws : False
-- Skip return : False
foreign import ccall "gst_query_writable_structure" gst_query_writable_structure ::
Ptr Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"})
IO (Ptr Gst.Structure.Structure)
{- |
Get the structure of a query. This method should be called with a writable
/@query@/ so that the returned structure is guaranteed to be writable.
-}
queryWritableStructure ::
(B.CallStack.HasCallStack, MonadIO m) =>
Query
{- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -}
-> m Gst.Structure.Structure
{- ^ __Returns:__ the 'GI.Gst.Structs.Structure.Structure' of the query. The structure is
still owned by the query and will therefore be freed when the query
is unreffed. -}
queryWritableStructure query = liftIO $ do
query' <- unsafeManagedPtrGetPtr query
result <- gst_query_writable_structure query'
checkUnexpectedReturnNULL "queryWritableStructure" result
result' <- (newBoxed Gst.Structure.Structure) result
touchManagedPtr query
return result'
#if ENABLE_OVERLOADING
data QueryWritableStructureMethodInfo
instance (signature ~ (m Gst.Structure.Structure), MonadIO m) => O.MethodInfo QueryWritableStructureMethodInfo Query signature where
overloadedMethod _ = queryWritableStructure
#endif
#if ENABLE_OVERLOADING
type family ResolveQueryMethod (t :: Symbol) (o :: *) :: * where
ResolveQueryMethod "addAllocationMeta" o = QueryAddAllocationMetaMethodInfo
ResolveQueryMethod "addAllocationParam" o = QueryAddAllocationParamMethodInfo
ResolveQueryMethod "addAllocationPool" o = QueryAddAllocationPoolMethodInfo
ResolveQueryMethod "addBufferingRange" o = QueryAddBufferingRangeMethodInfo
ResolveQueryMethod "addSchedulingMode" o = QueryAddSchedulingModeMethodInfo
ResolveQueryMethod "findAllocationMeta" o = QueryFindAllocationMetaMethodInfo
ResolveQueryMethod "hasSchedulingMode" o = QueryHasSchedulingModeMethodInfo
ResolveQueryMethod "hasSchedulingModeWithFlags" o = QueryHasSchedulingModeWithFlagsMethodInfo
ResolveQueryMethod "parseAcceptCaps" o = QueryParseAcceptCapsMethodInfo
ResolveQueryMethod "parseAcceptCapsResult" o = QueryParseAcceptCapsResultMethodInfo
ResolveQueryMethod "parseAllocation" o = QueryParseAllocationMethodInfo
ResolveQueryMethod "parseBitrate" o = QueryParseBitrateMethodInfo
ResolveQueryMethod "parseBufferingPercent" o = QueryParseBufferingPercentMethodInfo
ResolveQueryMethod "parseBufferingRange" o = QueryParseBufferingRangeMethodInfo
ResolveQueryMethod "parseBufferingStats" o = QueryParseBufferingStatsMethodInfo
ResolveQueryMethod "parseCaps" o = QueryParseCapsMethodInfo
ResolveQueryMethod "parseCapsResult" o = QueryParseCapsResultMethodInfo
ResolveQueryMethod "parseContext" o = QueryParseContextMethodInfo
ResolveQueryMethod "parseContextType" o = QueryParseContextTypeMethodInfo
ResolveQueryMethod "parseConvert" o = QueryParseConvertMethodInfo
ResolveQueryMethod "parseDuration" o = QueryParseDurationMethodInfo
ResolveQueryMethod "parseLatency" o = QueryParseLatencyMethodInfo
ResolveQueryMethod "parseNFormats" o = QueryParseNFormatsMethodInfo
ResolveQueryMethod "parseNthAllocationMeta" o = QueryParseNthAllocationMetaMethodInfo
ResolveQueryMethod "parseNthAllocationParam" o = QueryParseNthAllocationParamMethodInfo
ResolveQueryMethod "parseNthAllocationPool" o = QueryParseNthAllocationPoolMethodInfo
ResolveQueryMethod "parseNthBufferingRange" o = QueryParseNthBufferingRangeMethodInfo
ResolveQueryMethod "parseNthFormat" o = QueryParseNthFormatMethodInfo
ResolveQueryMethod "parseNthSchedulingMode" o = QueryParseNthSchedulingModeMethodInfo
ResolveQueryMethod "parsePosition" o = QueryParsePositionMethodInfo
ResolveQueryMethod "parseScheduling" o = QueryParseSchedulingMethodInfo
ResolveQueryMethod "parseSeeking" o = QueryParseSeekingMethodInfo
ResolveQueryMethod "parseSegment" o = QueryParseSegmentMethodInfo
ResolveQueryMethod "parseUri" o = QueryParseUriMethodInfo
ResolveQueryMethod "parseUriRedirection" o = QueryParseUriRedirectionMethodInfo
ResolveQueryMethod "parseUriRedirectionPermanent" o = QueryParseUriRedirectionPermanentMethodInfo
ResolveQueryMethod "removeNthAllocationMeta" o = QueryRemoveNthAllocationMetaMethodInfo
ResolveQueryMethod "removeNthAllocationParam" o = QueryRemoveNthAllocationParamMethodInfo
ResolveQueryMethod "removeNthAllocationPool" o = QueryRemoveNthAllocationPoolMethodInfo
ResolveQueryMethod "writableStructure" o = QueryWritableStructureMethodInfo
ResolveQueryMethod "getNAllocationMetas" o = QueryGetNAllocationMetasMethodInfo
ResolveQueryMethod "getNAllocationParams" o = QueryGetNAllocationParamsMethodInfo
ResolveQueryMethod "getNAllocationPools" o = QueryGetNAllocationPoolsMethodInfo
ResolveQueryMethod "getNBufferingRanges" o = QueryGetNBufferingRangesMethodInfo
ResolveQueryMethod "getNSchedulingModes" o = QueryGetNSchedulingModesMethodInfo
ResolveQueryMethod "getStructure" o = QueryGetStructureMethodInfo
ResolveQueryMethod "setAcceptCapsResult" o = QuerySetAcceptCapsResultMethodInfo
ResolveQueryMethod "setBitrate" o = QuerySetBitrateMethodInfo
ResolveQueryMethod "setBufferingPercent" o = QuerySetBufferingPercentMethodInfo
ResolveQueryMethod "setBufferingRange" o = QuerySetBufferingRangeMethodInfo
ResolveQueryMethod "setBufferingStats" o = QuerySetBufferingStatsMethodInfo
ResolveQueryMethod "setCapsResult" o = QuerySetCapsResultMethodInfo
ResolveQueryMethod "setContext" o = QuerySetContextMethodInfo
ResolveQueryMethod "setConvert" o = QuerySetConvertMethodInfo
ResolveQueryMethod "setDuration" o = QuerySetDurationMethodInfo
ResolveQueryMethod "setFormatsv" o = QuerySetFormatsvMethodInfo
ResolveQueryMethod "setLatency" o = QuerySetLatencyMethodInfo
ResolveQueryMethod "setNthAllocationParam" o = QuerySetNthAllocationParamMethodInfo
ResolveQueryMethod "setNthAllocationPool" o = QuerySetNthAllocationPoolMethodInfo
ResolveQueryMethod "setPosition" o = QuerySetPositionMethodInfo
ResolveQueryMethod "setScheduling" o = QuerySetSchedulingMethodInfo
ResolveQueryMethod "setSeeking" o = QuerySetSeekingMethodInfo
ResolveQueryMethod "setSegment" o = QuerySetSegmentMethodInfo
ResolveQueryMethod "setUri" o = QuerySetUriMethodInfo
ResolveQueryMethod "setUriRedirection" o = QuerySetUriRedirectionMethodInfo
ResolveQueryMethod "setUriRedirectionPermanent" o = QuerySetUriRedirectionPermanentMethodInfo
ResolveQueryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveQueryMethod t Query, O.MethodInfo info Query p) => OL.IsLabel t (Query -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif