DiscovererInfo.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)

Structure containing the information of a URI analyzed by 'GI.GstPbutils.Objects.Discoverer.Discoverer'.
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.GstPbutils.Objects.DiscovererInfo
    ( 

-- * Exported types
    DiscovererInfo(..)                      ,
    IsDiscovererInfo                        ,
    toDiscovererInfo                        ,
    noDiscovererInfo                        ,


 -- * Methods
-- ** copy #method:copy#

#if ENABLE_OVERLOADING
    DiscovererInfoCopyMethodInfo            ,
#endif
    discovererInfoCopy                      ,


-- ** fromVariant #method:fromVariant#

    discovererInfoFromVariant               ,


-- ** getAudioStreams #method:getAudioStreams#

#if ENABLE_OVERLOADING
    DiscovererInfoGetAudioStreamsMethodInfo ,
#endif
    discovererInfoGetAudioStreams           ,


-- ** getContainerStreams #method:getContainerStreams#

#if ENABLE_OVERLOADING
    DiscovererInfoGetContainerStreamsMethodInfo,
#endif
    discovererInfoGetContainerStreams       ,


-- ** getDuration #method:getDuration#

#if ENABLE_OVERLOADING
    DiscovererInfoGetDurationMethodInfo     ,
#endif
    discovererInfoGetDuration               ,


-- ** getLive #method:getLive#

#if ENABLE_OVERLOADING
    DiscovererInfoGetLiveMethodInfo         ,
#endif
    discovererInfoGetLive                   ,


-- ** getMisc #method:getMisc#

#if ENABLE_OVERLOADING
    DiscovererInfoGetMiscMethodInfo         ,
#endif
    discovererInfoGetMisc                   ,


-- ** getMissingElementsInstallerDetails #method:getMissingElementsInstallerDetails#

#if ENABLE_OVERLOADING
    DiscovererInfoGetMissingElementsInstallerDetailsMethodInfo,
#endif
    discovererInfoGetMissingElementsInstallerDetails,


-- ** getResult #method:getResult#

#if ENABLE_OVERLOADING
    DiscovererInfoGetResultMethodInfo       ,
#endif
    discovererInfoGetResult                 ,


-- ** getSeekable #method:getSeekable#

#if ENABLE_OVERLOADING
    DiscovererInfoGetSeekableMethodInfo     ,
#endif
    discovererInfoGetSeekable               ,


-- ** getStreamInfo #method:getStreamInfo#

#if ENABLE_OVERLOADING
    DiscovererInfoGetStreamInfoMethodInfo   ,
#endif
    discovererInfoGetStreamInfo             ,


-- ** getStreamList #method:getStreamList#

#if ENABLE_OVERLOADING
    DiscovererInfoGetStreamListMethodInfo   ,
#endif
    discovererInfoGetStreamList             ,


-- ** getStreams #method:getStreams#

#if ENABLE_OVERLOADING
    DiscovererInfoGetStreamsMethodInfo      ,
#endif
    discovererInfoGetStreams                ,


-- ** getSubtitleStreams #method:getSubtitleStreams#

#if ENABLE_OVERLOADING
    DiscovererInfoGetSubtitleStreamsMethodInfo,
#endif
    discovererInfoGetSubtitleStreams        ,


-- ** getTags #method:getTags#

#if ENABLE_OVERLOADING
    DiscovererInfoGetTagsMethodInfo         ,
#endif
    discovererInfoGetTags                   ,


-- ** getToc #method:getToc#

#if ENABLE_OVERLOADING
    DiscovererInfoGetTocMethodInfo          ,
#endif
    discovererInfoGetToc                    ,


-- ** getUri #method:getUri#

#if ENABLE_OVERLOADING
    DiscovererInfoGetUriMethodInfo          ,
#endif
    discovererInfoGetUri                    ,


-- ** getVideoStreams #method:getVideoStreams#

#if ENABLE_OVERLOADING
    DiscovererInfoGetVideoStreamsMethodInfo ,
#endif
    discovererInfoGetVideoStreams           ,


-- ** toVariant #method:toVariant#

#if ENABLE_OVERLOADING
    DiscovererInfoToVariantMethodInfo       ,
#endif
    discovererInfoToVariant                 ,




    ) 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 qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Structs.Structure as Gst.Structure
import qualified GI.Gst.Structs.TagList as Gst.TagList
import qualified GI.Gst.Structs.Toc as Gst.Toc
import {-# SOURCE #-} qualified GI.GstPbutils.Enums as GstPbutils.Enums
import {-# SOURCE #-} qualified GI.GstPbutils.Flags as GstPbutils.Flags
import {-# SOURCE #-} qualified GI.GstPbutils.Objects.DiscovererStreamInfo as GstPbutils.DiscovererStreamInfo

-- | Memory-managed wrapper type.
newtype DiscovererInfo = DiscovererInfo (ManagedPtr DiscovererInfo)
foreign import ccall "gst_discoverer_info_get_type"
    c_gst_discoverer_info_get_type :: IO GType

instance GObject DiscovererInfo where
    gobjectType = c_gst_discoverer_info_get_type
    

-- | Type class for types which can be safely cast to `DiscovererInfo`, for instance with `toDiscovererInfo`.
class (GObject o, O.IsDescendantOf DiscovererInfo o) => IsDiscovererInfo o
instance (GObject o, O.IsDescendantOf DiscovererInfo o) => IsDiscovererInfo o

instance O.HasParentTypes DiscovererInfo
type instance O.ParentTypes DiscovererInfo = '[GObject.Object.Object]

-- | Cast to `DiscovererInfo`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDiscovererInfo :: (MonadIO m, IsDiscovererInfo o) => o -> m DiscovererInfo
toDiscovererInfo = liftIO . unsafeCastTo DiscovererInfo

-- | A convenience alias for `Nothing` :: `Maybe` `DiscovererInfo`.
noDiscovererInfo :: Maybe DiscovererInfo
noDiscovererInfo = Nothing

#if ENABLE_OVERLOADING
type family ResolveDiscovererInfoMethod (t :: Symbol) (o :: *) :: * where
    ResolveDiscovererInfoMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDiscovererInfoMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDiscovererInfoMethod "copy" o = DiscovererInfoCopyMethodInfo
    ResolveDiscovererInfoMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDiscovererInfoMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDiscovererInfoMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDiscovererInfoMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDiscovererInfoMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDiscovererInfoMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDiscovererInfoMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDiscovererInfoMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDiscovererInfoMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDiscovererInfoMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDiscovererInfoMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDiscovererInfoMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDiscovererInfoMethod "toVariant" o = DiscovererInfoToVariantMethodInfo
    ResolveDiscovererInfoMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDiscovererInfoMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDiscovererInfoMethod "getAudioStreams" o = DiscovererInfoGetAudioStreamsMethodInfo
    ResolveDiscovererInfoMethod "getContainerStreams" o = DiscovererInfoGetContainerStreamsMethodInfo
    ResolveDiscovererInfoMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDiscovererInfoMethod "getDuration" o = DiscovererInfoGetDurationMethodInfo
    ResolveDiscovererInfoMethod "getLive" o = DiscovererInfoGetLiveMethodInfo
    ResolveDiscovererInfoMethod "getMisc" o = DiscovererInfoGetMiscMethodInfo
    ResolveDiscovererInfoMethod "getMissingElementsInstallerDetails" o = DiscovererInfoGetMissingElementsInstallerDetailsMethodInfo
    ResolveDiscovererInfoMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDiscovererInfoMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDiscovererInfoMethod "getResult" o = DiscovererInfoGetResultMethodInfo
    ResolveDiscovererInfoMethod "getSeekable" o = DiscovererInfoGetSeekableMethodInfo
    ResolveDiscovererInfoMethod "getStreamInfo" o = DiscovererInfoGetStreamInfoMethodInfo
    ResolveDiscovererInfoMethod "getStreamList" o = DiscovererInfoGetStreamListMethodInfo
    ResolveDiscovererInfoMethod "getStreams" o = DiscovererInfoGetStreamsMethodInfo
    ResolveDiscovererInfoMethod "getSubtitleStreams" o = DiscovererInfoGetSubtitleStreamsMethodInfo
    ResolveDiscovererInfoMethod "getTags" o = DiscovererInfoGetTagsMethodInfo
    ResolveDiscovererInfoMethod "getToc" o = DiscovererInfoGetTocMethodInfo
    ResolveDiscovererInfoMethod "getUri" o = DiscovererInfoGetUriMethodInfo
    ResolveDiscovererInfoMethod "getVideoStreams" o = DiscovererInfoGetVideoStreamsMethodInfo
    ResolveDiscovererInfoMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDiscovererInfoMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDiscovererInfoMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDiscovererInfoMethod t DiscovererInfo, O.MethodInfo info DiscovererInfo p) => OL.IsLabel t (DiscovererInfo -> 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

#if ENABLE_OVERLOADING
instance O.HasAttributeList DiscovererInfo
type instance O.AttributeList DiscovererInfo = DiscovererInfoAttributeList
type DiscovererInfoAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
type instance O.SignalList DiscovererInfo = DiscovererInfoSignalList
type DiscovererInfoSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method DiscovererInfo::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "ptr", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_copy" gst_discoverer_info_copy :: 
    Ptr DiscovererInfo ->                   -- ptr : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr DiscovererInfo)

{- |
/No description available in the introspection data./
-}
discovererInfoCopy ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@ptr@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m DiscovererInfo
    {- ^ __Returns:__ A copy of the 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
discovererInfoCopy ptr = liftIO $ do
    ptr' <- unsafeManagedPtrCastPtr ptr
    result <- gst_discoverer_info_copy ptr'
    checkUnexpectedReturnNULL "discovererInfoCopy" result
    result' <- (wrapObject DiscovererInfo) result
    touchManagedPtr ptr
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoCopyMethodInfo
instance (signature ~ (m DiscovererInfo), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoCopyMethodInfo a signature where
    overloadedMethod _ = discovererInfoCopy

#endif

-- method DiscovererInfo::get_audio_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_audio_streams" gst_discoverer_info_get_audio_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds all the 'GI.GstPbutils.Objects.DiscovererAudioInfo.DiscovererAudioInfo' contained in /@info@/
-}
discovererInfoGetAudioStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetAudioStreams info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_audio_streams info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if ENABLE_OVERLOADING
data DiscovererInfoGetAudioStreamsMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetAudioStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetAudioStreams

#endif

-- method DiscovererInfo::get_container_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_container_streams" gst_discoverer_info_get_container_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds all the 'GI.GstPbutils.Objects.DiscovererContainerInfo.DiscovererContainerInfo' contained in /@info@/
-}
discovererInfoGetContainerStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetContainerStreams info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_container_streams info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if ENABLE_OVERLOADING
data DiscovererInfoGetContainerStreamsMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetContainerStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetContainerStreams

#endif

-- method DiscovererInfo::get_duration
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_duration" gst_discoverer_info_get_duration :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO Word64

{- |
/No description available in the introspection data./
-}
discovererInfoGetDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Word64
    {- ^ __Returns:__ the duration of the URI in @/GstClockTime/@ (nanoseconds). -}
discovererInfoGetDuration info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_duration info'
    touchManagedPtr info
    return result

#if ENABLE_OVERLOADING
data DiscovererInfoGetDurationMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetDurationMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetDuration

#endif

-- method DiscovererInfo::get_live
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", 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_discoverer_info_get_live" gst_discoverer_info_get_live :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO CInt

{- |
/No description available in the introspection data./

/Since: 1.14/
-}
discovererInfoGetLive ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Bool
    {- ^ __Returns:__ whether the URI is live. -}
discovererInfoGetLive info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_live info'
    let result' = (/= 0) result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetLiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetLiveMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetLive

#endif

-- method DiscovererInfo::get_misc
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", 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_discoverer_info_get_misc" gst_discoverer_info_get_misc :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr Gst.Structure.Structure)

{-# DEPRECATED discovererInfoGetMisc ["This functions is deprecated since version 1.4, use","@/gst_discoverer_info_get_missing_elements_installer_details/@"] #-}
{- |
/No description available in the introspection data./
-}
discovererInfoGetMisc ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Gst.Structure.Structure
    {- ^ __Returns:__ Miscellaneous information stored as a 'GI.Gst.Structs.Structure.Structure'
(for example: information about missing plugins). If you wish to use the
'GI.Gst.Structs.Structure.Structure' after the life-time of /@info@/, you will need to copy it. -}
discovererInfoGetMisc info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_misc info'
    checkUnexpectedReturnNULL "discovererInfoGetMisc" result
    result' <- (newBoxed Gst.Structure.Structure) result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetMiscMethodInfo
instance (signature ~ (m Gst.Structure.Structure), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetMiscMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetMisc

#endif

-- method DiscovererInfo::get_missing_elements_installer_details
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererStreamInfo to retrieve installer detail\nfor the missing element", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_missing_elements_installer_details" gst_discoverer_info_get_missing_elements_installer_details :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr CString)

{- |
Get the installer details for missing elements

/Since: 1.4/
-}
discovererInfoGetMissingElementsInstallerDetails ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo' to retrieve installer detail
for the missing element -}
    -> m [T.Text]
    {- ^ __Returns:__ An array of strings
containing informations about how to install the various missing elements
for /@info@/ to be usable. If you wish to use the strings after the life-time
of /@info@/, you will need to copy them. -}
discovererInfoGetMissingElementsInstallerDetails info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_missing_elements_installer_details info'
    checkUnexpectedReturnNULL "discovererInfoGetMissingElementsInstallerDetails" result
    result' <- unpackZeroTerminatedUTF8CArray result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetMissingElementsInstallerDetailsMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetMissingElementsInstallerDetailsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetMissingElementsInstallerDetails

#endif

-- method DiscovererInfo::get_result
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstPbutils", name = "DiscovererResult"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_result" gst_discoverer_info_get_result :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO CUInt

{- |
/No description available in the introspection data./
-}
discovererInfoGetResult ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m GstPbutils.Enums.DiscovererResult
    {- ^ __Returns:__ the result of the discovery as a 'GI.GstPbutils.Enums.DiscovererResult'. -}
discovererInfoGetResult info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_result info'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetResultMethodInfo
instance (signature ~ (m GstPbutils.Enums.DiscovererResult), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetResultMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetResult

#endif

-- method DiscovererInfo::get_seekable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", 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_discoverer_info_get_seekable" gst_discoverer_info_get_seekable :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO CInt

{- |
/No description available in the introspection data./
-}
discovererInfoGetSeekable ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Bool
    {- ^ __Returns:__ the whether the URI is seekable. -}
discovererInfoGetSeekable info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_seekable info'
    let result' = (/= 0) result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetSeekableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetSeekableMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetSeekable

#endif

-- method DiscovererInfo::get_stream_info
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_stream_info" gst_discoverer_info_get_stream_info :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)

{- |
/No description available in the introspection data./
-}
discovererInfoGetStreamInfo ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo
    {- ^ __Returns:__ the structure (or topology) of the URI as a
'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'.
This structure can be traversed to see the original hierarchy. Unref with
@/gst_discoverer_stream_info_unref()/@ after usage. -}
discovererInfoGetStreamInfo info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_stream_info info'
    checkUnexpectedReturnNULL "discovererInfoGetStreamInfo" result
    result' <- (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetStreamInfoMethodInfo
instance (signature ~ (m GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetStreamInfoMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetStreamInfo

#endif

-- method DiscovererInfo::get_stream_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_stream_list" gst_discoverer_info_get_stream_list :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
/No description available in the introspection data./
-}
discovererInfoGetStreamList ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ the list of
all streams contained in the @/info/@. Free after usage
with 'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetStreamList info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_stream_list info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if ENABLE_OVERLOADING
data DiscovererInfoGetStreamListMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetStreamListMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetStreamList

#endif

-- method DiscovererInfo::get_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "streamtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GType derived from #GstDiscovererStreamInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_streams" gst_discoverer_info_get_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    CGType ->                               -- streamtype : TBasicType TGType
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds the 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo' contained in /@info@/ that match the
given /@streamtype@/.
-}
discovererInfoGetStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> GType
    {- ^ /@streamtype@/: a 'GType' derived from 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetStreams info streamtype = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    let streamtype' = gtypeToCGType streamtype
    result <- gst_discoverer_info_get_streams info' streamtype'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if ENABLE_OVERLOADING
data DiscovererInfoGetStreamsMethodInfo
instance (signature ~ (GType -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetStreams

#endif

-- method DiscovererInfo::get_subtitle_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_subtitle_streams" gst_discoverer_info_get_subtitle_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds all the 'GI.GstPbutils.Objects.DiscovererSubtitleInfo.DiscovererSubtitleInfo' contained in /@info@/
-}
discovererInfoGetSubtitleStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetSubtitleStreams info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_subtitle_streams info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if ENABLE_OVERLOADING
data DiscovererInfoGetSubtitleStreamsMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetSubtitleStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetSubtitleStreams

#endif

-- method DiscovererInfo::get_tags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_tags" gst_discoverer_info_get_tags :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr Gst.TagList.TagList)

{- |
/No description available in the introspection data./
-}
discovererInfoGetTags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Gst.TagList.TagList
    {- ^ __Returns:__ all tags contained in the URI. If you wish to use
the tags after the life-time of /@info@/, you will need to copy them. -}
discovererInfoGetTags info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_tags info'
    checkUnexpectedReturnNULL "discovererInfoGetTags" result
    result' <- (newBoxed Gst.TagList.TagList) result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetTagsMethodInfo
instance (signature ~ (m Gst.TagList.TagList), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetTagsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetTags

#endif

-- method DiscovererInfo::get_toc
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Toc"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_toc" gst_discoverer_info_get_toc :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr Gst.Toc.Toc)

{- |
/No description available in the introspection data./
-}
discovererInfoGetToc ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Gst.Toc.Toc
    {- ^ __Returns:__ TOC contained in the URI. If you wish to use
the TOC after the life-time of /@info@/, you will need to copy it. -}
discovererInfoGetToc info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_toc info'
    checkUnexpectedReturnNULL "discovererInfoGetToc" result
    result' <- (newBoxed Gst.Toc.Toc) result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetTocMethodInfo
instance (signature ~ (m Gst.Toc.Toc), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetTocMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetToc

#endif

-- method DiscovererInfo::get_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_uri" gst_discoverer_info_get_uri :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO CString

{- |
/No description available in the introspection data./
-}
discovererInfoGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m T.Text
    {- ^ __Returns:__ the URI to which this information corresponds to.
Copy it if you wish to use it after the life-time of /@info@/. -}
discovererInfoGetUri info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_uri info'
    checkUnexpectedReturnNULL "discovererInfoGetUri" result
    result' <- cstringToText result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoGetUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetUriMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetUri

#endif

-- method DiscovererInfo::get_video_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_video_streams" gst_discoverer_info_get_video_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds all the 'GI.GstPbutils.Objects.DiscovererVideoInfo.DiscovererVideoInfo' contained in /@info@/
-}
discovererInfoGetVideoStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetVideoStreams info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_video_streams info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if ENABLE_OVERLOADING
data DiscovererInfoGetVideoStreamsMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetVideoStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetVideoStreams

#endif

-- method DiscovererInfo::to_variant
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererSerializeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A combination of #GstDiscovererSerializeFlags to specify\nwhat needs to be serialized.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_to_variant" gst_discoverer_info_to_variant :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "GstPbutils", name = "DiscovererSerializeFlags"})
    IO (Ptr GVariant)

{- |
Serializes /@info@/ to a 'GVariant' that can be parsed again
through 'GI.GstPbutils.Objects.DiscovererInfo.discovererInfoFromVariant'.

Note that any 'GI.Gst.Structs.Toc.Toc' (s) that might have been discovered will not be serialized
for now.

/Since: 1.6/
-}
discovererInfoToVariant ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: A 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> [GstPbutils.Flags.DiscovererSerializeFlags]
    {- ^ /@flags@/: A combination of 'GI.GstPbutils.Flags.DiscovererSerializeFlags' to specify
what needs to be serialized. -}
    -> m GVariant
    {- ^ __Returns:__ A newly-allocated 'GVariant' representing /@info@/. -}
discovererInfoToVariant info flags = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    let flags' = gflagsToWord flags
    result <- gst_discoverer_info_to_variant info' flags'
    checkUnexpectedReturnNULL "discovererInfoToVariant" result
    result' <- B.GVariant.wrapGVariantPtr result
    touchManagedPtr info
    return result'

#if ENABLE_OVERLOADING
data DiscovererInfoToVariantMethodInfo
instance (signature ~ ([GstPbutils.Flags.DiscovererSerializeFlags] -> m GVariant), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoToVariantMethodInfo a signature where
    overloadedMethod _ = discovererInfoToVariant

#endif

-- method DiscovererInfo::from_variant
-- method type : MemberFunction
-- Args : [Arg {argCName = "variant", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GVariant to deserialize into a #GstDiscovererInfo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_from_variant" gst_discoverer_info_from_variant :: 
    Ptr GVariant ->                         -- variant : TVariant
    IO (Ptr DiscovererInfo)

{- |
Parses a 'GVariant' as produced by 'GI.GstPbutils.Objects.DiscovererInfo.discovererInfoToVariant'
back to a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo'.

/Since: 1.6/
-}
discovererInfoFromVariant ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GVariant
    {- ^ /@variant@/: A 'GVariant' to deserialize into a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo'. -}
    -> m DiscovererInfo
    {- ^ __Returns:__ A newly-allocated 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo'. -}
discovererInfoFromVariant variant = liftIO $ do
    variant' <- unsafeManagedPtrGetPtr variant
    result <- gst_discoverer_info_from_variant variant'
    checkUnexpectedReturnNULL "discovererInfoFromVariant" result
    result' <- (wrapObject DiscovererInfo) result
    touchManagedPtr variant
    return result'

#if ENABLE_OVERLOADING
#endif