-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Binding to the GStreamer open source multimedia framework.
--   
--   This package provides a wrapper around the GStreamer C library.
--   GStreamer is a library for constructing graphs of media-handling
--   components. The applications it supports range from simple
--   Ogg<i>Vorbis playback, audio</i>video streaming to complex audio
--   (mixing) and video (non-linear editing) processing.
@package gstreamer
@version 0.12.1.2


module Media.Streaming.GStreamer.Audio.Constants
audioDefRate :: Double


module Media.Streaming.GStreamer.DataProtocol.Constants
data DPHeaderFlag
DPHeaderCRCHeader :: DPHeaderFlag
DPHeaderCRCPayload :: DPHeaderFlag
DPHeaderCRC :: DPHeaderFlag
instance Eq DPHeaderFlag
instance Bounded DPHeaderFlag
instance Show DPHeaderFlag
instance Enum DPHeaderFlag


module Media.Streaming.GStreamer.Base.Constants
data BaseSrcFlags
BaseSrcStarted :: BaseSrcFlags
instance Eq BaseSrcFlags
instance Bounded BaseSrcFlags
instance Flags BaseSrcFlags
instance Enum BaseSrcFlags


module Media.Streaming.GStreamer.Core.Init
init :: IO ()
initCheck :: IO ()
deinit :: IO ()
version :: (Word, Word, Word, Word)
versionString :: String
segtrapIsEnabled :: IO Bool
segtrapSetEnabled :: Bool -> IO ()
registryForkIsEnabled :: IO Bool
registryForkSetEnabled :: Bool -> IO ()
updateRegistry :: IO Bool


-- | This file reflects the Gtk+ object hierarchy in terms of Haskell
--   classes.
--   
--   Note: the mk... functions were originally meant to simply be an alias
--   for the constructor. However, in order to communicate the destructor
--   of an object to objectNew, the mk... functions are now a tuple
--   containing Haskell constructor and the destructor function pointer.
--   This hack avoids changing all modules that simply pass mk... to
--   objectNew.
module Media.Streaming.GStreamer.Core.MiniHierarchy

-- | Decrease the reference counter of an object
miniObjectUnref :: FinalizerPtr a
newtype MiniObject
MiniObject :: (ForeignPtr (MiniObject)) -> MiniObject
class MiniObjectClass o
toMiniObject :: MiniObjectClass o => o -> MiniObject
unsafeCastMiniObject :: MiniObjectClass o => MiniObject -> o
mkMiniObject :: (ForeignPtr MiniObject -> MiniObject, FinalizerPtr a)
unMiniObject :: MiniObject -> ForeignPtr MiniObject
isMiniObject :: MiniObjectClass obj => obj -> Bool
castToMiniObject :: MiniObjectClass obj => obj -> MiniObject
newtype Buffer
Buffer :: (ForeignPtr (Buffer)) -> Buffer
class MiniObjectClass o => BufferClass o
toBuffer :: BufferClass o => o -> Buffer
mkBuffer :: (ForeignPtr Buffer -> Buffer, FinalizerPtr a)
unBuffer :: Buffer -> ForeignPtr Buffer
castToBuffer :: MiniObjectClass obj => obj -> Buffer
gTypeBuffer :: GType
newtype Event
Event :: (ForeignPtr (Event)) -> Event
class MiniObjectClass o => EventClass o
toEvent :: EventClass o => o -> Event
mkEvent :: (ForeignPtr Event -> Event, FinalizerPtr a)
unEvent :: Event -> ForeignPtr Event
castToEvent :: MiniObjectClass obj => obj -> Event
gTypeEvent :: GType
newtype Message
Message :: (ForeignPtr (Message)) -> Message
class MiniObjectClass o => MessageClass o
toMessage :: MessageClass o => o -> Message
mkMessage :: (ForeignPtr Message -> Message, FinalizerPtr a)
unMessage :: Message -> ForeignPtr Message
castToMessage :: MiniObjectClass obj => obj -> Message
gTypeMessage :: GType
newtype Query
Query :: (ForeignPtr (Query)) -> Query
class MiniObjectClass o => QueryClass o
toQuery :: QueryClass o => o -> Query
mkQuery :: (ForeignPtr Query -> Query, FinalizerPtr a)
unQuery :: Query -> ForeignPtr Query
castToQuery :: MiniObjectClass obj => obj -> Query
gTypeQuery :: GType
instance Eq Buffer
instance Ord Buffer
instance Eq Event
instance Ord Event
instance Eq Message
instance Ord Message
instance Eq Query
instance Ord Query
instance MiniObjectClass Query
instance QueryClass Query
instance MiniObjectClass Message
instance MessageClass Message
instance MiniObjectClass Event
instance EventClass Event
instance MiniObjectClass Buffer
instance BufferClass Buffer


-- | This file reflects the Gtk+ object hierarchy in terms of Haskell
--   classes.
--   
--   Note: the mk... functions were originally meant to simply be an alias
--   for the constructor. However, in order to communicate the destructor
--   of an object to objectNew, the mk... functions are now a tuple
--   containing Haskell constructor and the destructor function pointer.
--   This hack avoids changing all modules that simply pass mk... to
--   objectNew.
module Media.Streaming.GStreamer.Core.Hierarchy
newtype Object
Object :: (ForeignPtr (Object)) -> Object
class GObjectClass o => ObjectClass o
toObject :: ObjectClass o => o -> Object
mkObject :: (ForeignPtr Object -> Object, FinalizerPtr a)
unObject :: Object -> ForeignPtr Object
castToObject :: GObjectClass obj => obj -> Object
gTypeObject :: GType
newtype Pad
Pad :: (ForeignPtr (Pad)) -> Pad
class ObjectClass o => PadClass o
toPad :: PadClass o => o -> Pad
mkPad :: (ForeignPtr Pad -> Pad, FinalizerPtr a)
unPad :: Pad -> ForeignPtr Pad
castToPad :: GObjectClass obj => obj -> Pad
gTypePad :: GType
newtype GhostPad
GhostPad :: (ForeignPtr (GhostPad)) -> GhostPad
class PadClass o => GhostPadClass o
toGhostPad :: GhostPadClass o => o -> GhostPad
mkGhostPad :: (ForeignPtr GhostPad -> GhostPad, FinalizerPtr a)
unGhostPad :: GhostPad -> ForeignPtr GhostPad
castToGhostPad :: GObjectClass obj => obj -> GhostPad
gTypeGhostPad :: GType
newtype PluginFeature
PluginFeature :: (ForeignPtr (PluginFeature)) -> PluginFeature
class ObjectClass o => PluginFeatureClass o
toPluginFeature :: PluginFeatureClass o => o -> PluginFeature
mkPluginFeature :: (ForeignPtr PluginFeature -> PluginFeature, FinalizerPtr a)
unPluginFeature :: PluginFeature -> ForeignPtr PluginFeature
castToPluginFeature :: GObjectClass obj => obj -> PluginFeature
gTypePluginFeature :: GType
newtype ElementFactory
ElementFactory :: (ForeignPtr (ElementFactory)) -> ElementFactory
class PluginFeatureClass o => ElementFactoryClass o
toElementFactory :: ElementFactoryClass o => o -> ElementFactory
mkElementFactory :: (ForeignPtr ElementFactory -> ElementFactory, FinalizerPtr a)
unElementFactory :: ElementFactory -> ForeignPtr ElementFactory
castToElementFactory :: GObjectClass obj => obj -> ElementFactory
gTypeElementFactory :: GType
newtype TypeFindFactory
TypeFindFactory :: (ForeignPtr (TypeFindFactory)) -> TypeFindFactory
class PluginFeatureClass o => TypeFindFactoryClass o
toTypeFindFactory :: TypeFindFactoryClass o => o -> TypeFindFactory
mkTypeFindFactory :: (ForeignPtr TypeFindFactory -> TypeFindFactory, FinalizerPtr a)
unTypeFindFactory :: TypeFindFactory -> ForeignPtr TypeFindFactory
castToTypeFindFactory :: GObjectClass obj => obj -> TypeFindFactory
gTypeTypeFindFactory :: GType
newtype IndexFactory
IndexFactory :: (ForeignPtr (IndexFactory)) -> IndexFactory
class PluginFeatureClass o => IndexFactoryClass o
toIndexFactory :: IndexFactoryClass o => o -> IndexFactory
mkIndexFactory :: (ForeignPtr IndexFactory -> IndexFactory, FinalizerPtr a)
unIndexFactory :: IndexFactory -> ForeignPtr IndexFactory
castToIndexFactory :: GObjectClass obj => obj -> IndexFactory
gTypeIndexFactory :: GType
newtype Element
Element :: (ForeignPtr (Element)) -> Element
class ObjectClass o => ElementClass o
toElement :: ElementClass o => o -> Element
mkElement :: (ForeignPtr Element -> Element, FinalizerPtr a)
unElement :: Element -> ForeignPtr Element
castToElement :: GObjectClass obj => obj -> Element
gTypeElement :: GType
newtype Bin
Bin :: (ForeignPtr (Bin)) -> Bin
class ElementClass o => BinClass o
toBin :: BinClass o => o -> Bin
mkBin :: (ForeignPtr Bin -> Bin, FinalizerPtr a)
unBin :: Bin -> ForeignPtr Bin
castToBin :: GObjectClass obj => obj -> Bin
gTypeBin :: GType
newtype Pipeline
Pipeline :: (ForeignPtr (Pipeline)) -> Pipeline
class BinClass o => PipelineClass o
toPipeline :: PipelineClass o => o -> Pipeline
mkPipeline :: (ForeignPtr Pipeline -> Pipeline, FinalizerPtr a)
unPipeline :: Pipeline -> ForeignPtr Pipeline
castToPipeline :: GObjectClass obj => obj -> Pipeline
gTypePipeline :: GType
newtype ImplementsInterface
ImplementsInterface :: (ForeignPtr (ImplementsInterface)) -> ImplementsInterface
class ElementClass o => ImplementsInterfaceClass o
toImplementsInterface :: ImplementsInterfaceClass o => o -> ImplementsInterface
mkImplementsInterface :: (ForeignPtr ImplementsInterface -> ImplementsInterface, FinalizerPtr a)
unImplementsInterface :: ImplementsInterface -> ForeignPtr ImplementsInterface
castToImplementsInterface :: GObjectClass obj => obj -> ImplementsInterface
gTypeImplementsInterface :: GType
newtype TagSetter
TagSetter :: (ForeignPtr (TagSetter)) -> TagSetter
class ElementClass o => TagSetterClass o
toTagSetter :: TagSetterClass o => o -> TagSetter
mkTagSetter :: (ForeignPtr TagSetter -> TagSetter, FinalizerPtr a)
unTagSetter :: TagSetter -> ForeignPtr TagSetter
castToTagSetter :: GObjectClass obj => obj -> TagSetter
gTypeTagSetter :: GType
newtype BaseSrc
BaseSrc :: (ForeignPtr (BaseSrc)) -> BaseSrc
class ElementClass o => BaseSrcClass o
toBaseSrc :: BaseSrcClass o => o -> BaseSrc
mkBaseSrc :: (ForeignPtr BaseSrc -> BaseSrc, FinalizerPtr a)
unBaseSrc :: BaseSrc -> ForeignPtr BaseSrc
castToBaseSrc :: GObjectClass obj => obj -> BaseSrc
gTypeBaseSrc :: GType
newtype PushSrc
PushSrc :: (ForeignPtr (PushSrc)) -> PushSrc
class BaseSrcClass o => PushSrcClass o
toPushSrc :: PushSrcClass o => o -> PushSrc
mkPushSrc :: (ForeignPtr PushSrc -> PushSrc, FinalizerPtr a)
unPushSrc :: PushSrc -> ForeignPtr PushSrc
castToPushSrc :: GObjectClass obj => obj -> PushSrc
gTypePushSrc :: GType
newtype BaseSink
BaseSink :: (ForeignPtr (BaseSink)) -> BaseSink
class ElementClass o => BaseSinkClass o
toBaseSink :: BaseSinkClass o => o -> BaseSink
mkBaseSink :: (ForeignPtr BaseSink -> BaseSink, FinalizerPtr a)
unBaseSink :: BaseSink -> ForeignPtr BaseSink
castToBaseSink :: GObjectClass obj => obj -> BaseSink
gTypeBaseSink :: GType
newtype BaseTransform
BaseTransform :: (ForeignPtr (BaseTransform)) -> BaseTransform
class ElementClass o => BaseTransformClass o
toBaseTransform :: BaseTransformClass o => o -> BaseTransform
mkBaseTransform :: (ForeignPtr BaseTransform -> BaseTransform, FinalizerPtr a)
unBaseTransform :: BaseTransform -> ForeignPtr BaseTransform
castToBaseTransform :: GObjectClass obj => obj -> BaseTransform
gTypeBaseTransform :: GType
newtype Plugin
Plugin :: (ForeignPtr (Plugin)) -> Plugin
class ObjectClass o => PluginClass o
toPlugin :: PluginClass o => o -> Plugin
mkPlugin :: (ForeignPtr Plugin -> Plugin, FinalizerPtr a)
unPlugin :: Plugin -> ForeignPtr Plugin
castToPlugin :: GObjectClass obj => obj -> Plugin
gTypePlugin :: GType
newtype Registry
Registry :: (ForeignPtr (Registry)) -> Registry
class ObjectClass o => RegistryClass o
toRegistry :: RegistryClass o => o -> Registry
mkRegistry :: (ForeignPtr Registry -> Registry, FinalizerPtr a)
unRegistry :: Registry -> ForeignPtr Registry
castToRegistry :: GObjectClass obj => obj -> Registry
gTypeRegistry :: GType
newtype Bus
Bus :: (ForeignPtr (Bus)) -> Bus
class ObjectClass o => BusClass o
toBus :: BusClass o => o -> Bus
mkBus :: (ForeignPtr Bus -> Bus, FinalizerPtr a)
unBus :: Bus -> ForeignPtr Bus
castToBus :: GObjectClass obj => obj -> Bus
gTypeBus :: GType
newtype Clock
Clock :: (ForeignPtr (Clock)) -> Clock
class ObjectClass o => ClockClass o
toClock :: ClockClass o => o -> Clock
mkClock :: (ForeignPtr Clock -> Clock, FinalizerPtr a)
unClock :: Clock -> ForeignPtr Clock
castToClock :: GObjectClass obj => obj -> Clock
gTypeClock :: GType
newtype AudioClock
AudioClock :: (ForeignPtr (AudioClock)) -> AudioClock
class ClockClass o => AudioClockClass o
toAudioClock :: AudioClockClass o => o -> AudioClock
mkAudioClock :: (ForeignPtr AudioClock -> AudioClock, FinalizerPtr a)
unAudioClock :: AudioClock -> ForeignPtr AudioClock
castToAudioClock :: GObjectClass obj => obj -> AudioClock
gTypeAudioClock :: GType
newtype SystemClock
SystemClock :: (ForeignPtr (SystemClock)) -> SystemClock
class ClockClass o => SystemClockClass o
toSystemClock :: SystemClockClass o => o -> SystemClock
mkSystemClock :: (ForeignPtr SystemClock -> SystemClock, FinalizerPtr a)
unSystemClock :: SystemClock -> ForeignPtr SystemClock
castToSystemClock :: GObjectClass obj => obj -> SystemClock
gTypeSystemClock :: GType
newtype NetClientClock
NetClientClock :: (ForeignPtr (NetClientClock)) -> NetClientClock
class ClockClass o => NetClientClockClass o
toNetClientClock :: NetClientClockClass o => o -> NetClientClock
mkNetClientClock :: (ForeignPtr NetClientClock -> NetClientClock, FinalizerPtr a)
unNetClientClock :: NetClientClock -> ForeignPtr NetClientClock
castToNetClientClock :: GObjectClass obj => obj -> NetClientClock
gTypeNetClientClock :: GType
newtype Index
Index :: (ForeignPtr (Index)) -> Index
class ObjectClass o => IndexClass o
toIndex :: IndexClass o => o -> Index
mkIndex :: (ForeignPtr Index -> Index, FinalizerPtr a)
unIndex :: Index -> ForeignPtr Index
castToIndex :: GObjectClass obj => obj -> Index
gTypeIndex :: GType
newtype PadTemplate
PadTemplate :: (ForeignPtr (PadTemplate)) -> PadTemplate
class ObjectClass o => PadTemplateClass o
toPadTemplate :: PadTemplateClass o => o -> PadTemplate
mkPadTemplate :: (ForeignPtr PadTemplate -> PadTemplate, FinalizerPtr a)
unPadTemplate :: PadTemplate -> ForeignPtr PadTemplate
castToPadTemplate :: GObjectClass obj => obj -> PadTemplate
gTypePadTemplate :: GType
newtype Task
Task :: (ForeignPtr (Task)) -> Task
class ObjectClass o => TaskClass o
toTask :: TaskClass o => o -> Task
mkTask :: (ForeignPtr Task -> Task, FinalizerPtr a)
unTask :: Task -> ForeignPtr Task
castToTask :: GObjectClass obj => obj -> Task
gTypeTask :: GType
newtype XML
XML :: (ForeignPtr (XML)) -> XML
class ObjectClass o => XMLClass o
toXML :: XMLClass o => o -> XML
mkXML :: (ForeignPtr XML -> XML, FinalizerPtr a)
unXML :: XML -> ForeignPtr XML
castToXML :: GObjectClass obj => obj -> XML
gTypeXML :: GType
newtype ChildProxy
ChildProxy :: (ForeignPtr (ChildProxy)) -> ChildProxy
class ObjectClass o => ChildProxyClass o
toChildProxy :: ChildProxyClass o => o -> ChildProxy
mkChildProxy :: (ForeignPtr ChildProxy -> ChildProxy, FinalizerPtr a)
unChildProxy :: ChildProxy -> ForeignPtr ChildProxy
castToChildProxy :: GObjectClass obj => obj -> ChildProxy
gTypeChildProxy :: GType
newtype CollectPads
CollectPads :: (ForeignPtr (CollectPads)) -> CollectPads
class ObjectClass o => CollectPadsClass o
toCollectPads :: CollectPadsClass o => o -> CollectPads
mkCollectPads :: (ForeignPtr CollectPads -> CollectPads, FinalizerPtr a)
unCollectPads :: CollectPads -> ForeignPtr CollectPads
castToCollectPads :: GObjectClass obj => obj -> CollectPads
gTypeCollectPads :: GType
newtype URIHandler
URIHandler :: (ForeignPtr (URIHandler)) -> URIHandler
class GObjectClass o => URIHandlerClass o
toURIHandler :: URIHandlerClass o => o -> URIHandler
mkURIHandler :: (ForeignPtr URIHandler -> URIHandler, FinalizerPtr a)
unURIHandler :: URIHandler -> ForeignPtr URIHandler
castToURIHandler :: GObjectClass obj => obj -> URIHandler
gTypeURIHandler :: GType
newtype Adapter
Adapter :: (ForeignPtr (Adapter)) -> Adapter
class GObjectClass o => AdapterClass o
toAdapter :: AdapterClass o => o -> Adapter
mkAdapter :: (ForeignPtr Adapter -> Adapter, FinalizerPtr a)
unAdapter :: Adapter -> ForeignPtr Adapter
castToAdapter :: GObjectClass obj => obj -> Adapter
gTypeAdapter :: GType
newtype Controller
Controller :: (ForeignPtr (Controller)) -> Controller
class GObjectClass o => ControllerClass o
toController :: ControllerClass o => o -> Controller
mkController :: (ForeignPtr Controller -> Controller, FinalizerPtr a)
unController :: Controller -> ForeignPtr Controller
castToController :: GObjectClass obj => obj -> Controller
gTypeController :: GType
instance Eq Object
instance Ord Object
instance Eq Pad
instance Ord Pad
instance Eq GhostPad
instance Ord GhostPad
instance Eq PluginFeature
instance Ord PluginFeature
instance Eq ElementFactory
instance Ord ElementFactory
instance Eq TypeFindFactory
instance Ord TypeFindFactory
instance Eq IndexFactory
instance Ord IndexFactory
instance Eq Element
instance Ord Element
instance Eq Bin
instance Ord Bin
instance Eq Pipeline
instance Ord Pipeline
instance Eq ImplementsInterface
instance Ord ImplementsInterface
instance Eq TagSetter
instance Ord TagSetter
instance Eq BaseSrc
instance Ord BaseSrc
instance Eq PushSrc
instance Ord PushSrc
instance Eq BaseSink
instance Ord BaseSink
instance Eq BaseTransform
instance Ord BaseTransform
instance Eq Plugin
instance Ord Plugin
instance Eq Registry
instance Ord Registry
instance Eq Bus
instance Ord Bus
instance Eq Clock
instance Ord Clock
instance Eq AudioClock
instance Ord AudioClock
instance Eq SystemClock
instance Ord SystemClock
instance Eq NetClientClock
instance Ord NetClientClock
instance Eq Index
instance Ord Index
instance Eq PadTemplate
instance Ord PadTemplate
instance Eq Task
instance Ord Task
instance Eq XML
instance Ord XML
instance Eq ChildProxy
instance Ord ChildProxy
instance Eq CollectPads
instance Ord CollectPads
instance Eq URIHandler
instance Ord URIHandler
instance Eq Adapter
instance Ord Adapter
instance Eq Controller
instance Ord Controller
instance GObjectClass Controller
instance ControllerClass Controller
instance GObjectClass Adapter
instance AdapterClass Adapter
instance GObjectClass URIHandler
instance URIHandlerClass URIHandler
instance GObjectClass CollectPads
instance ObjectClass CollectPads
instance CollectPadsClass CollectPads
instance GObjectClass ChildProxy
instance ObjectClass ChildProxy
instance ChildProxyClass ChildProxy
instance GObjectClass XML
instance ObjectClass XML
instance XMLClass XML
instance GObjectClass Task
instance ObjectClass Task
instance TaskClass Task
instance GObjectClass PadTemplate
instance ObjectClass PadTemplate
instance PadTemplateClass PadTemplate
instance GObjectClass Index
instance ObjectClass Index
instance IndexClass Index
instance GObjectClass NetClientClock
instance ObjectClass NetClientClock
instance ClockClass NetClientClock
instance NetClientClockClass NetClientClock
instance GObjectClass SystemClock
instance ObjectClass SystemClock
instance ClockClass SystemClock
instance SystemClockClass SystemClock
instance GObjectClass AudioClock
instance ObjectClass AudioClock
instance ClockClass AudioClock
instance AudioClockClass AudioClock
instance GObjectClass Clock
instance ObjectClass Clock
instance ClockClass Clock
instance GObjectClass Bus
instance ObjectClass Bus
instance BusClass Bus
instance GObjectClass Registry
instance ObjectClass Registry
instance RegistryClass Registry
instance GObjectClass Plugin
instance ObjectClass Plugin
instance PluginClass Plugin
instance GObjectClass BaseTransform
instance ObjectClass BaseTransform
instance ElementClass BaseTransform
instance BaseTransformClass BaseTransform
instance GObjectClass BaseSink
instance ObjectClass BaseSink
instance ElementClass BaseSink
instance BaseSinkClass BaseSink
instance GObjectClass PushSrc
instance ObjectClass PushSrc
instance ElementClass PushSrc
instance BaseSrcClass PushSrc
instance PushSrcClass PushSrc
instance GObjectClass BaseSrc
instance ObjectClass BaseSrc
instance ElementClass BaseSrc
instance BaseSrcClass BaseSrc
instance GObjectClass TagSetter
instance ObjectClass TagSetter
instance ElementClass TagSetter
instance TagSetterClass TagSetter
instance GObjectClass ImplementsInterface
instance ObjectClass ImplementsInterface
instance ElementClass ImplementsInterface
instance ImplementsInterfaceClass ImplementsInterface
instance GObjectClass Pipeline
instance ObjectClass Pipeline
instance ElementClass Pipeline
instance BinClass Pipeline
instance PipelineClass Pipeline
instance GObjectClass Bin
instance ObjectClass Bin
instance ElementClass Bin
instance BinClass Bin
instance GObjectClass Element
instance ObjectClass Element
instance ElementClass Element
instance GObjectClass IndexFactory
instance ObjectClass IndexFactory
instance PluginFeatureClass IndexFactory
instance IndexFactoryClass IndexFactory
instance GObjectClass TypeFindFactory
instance ObjectClass TypeFindFactory
instance PluginFeatureClass TypeFindFactory
instance TypeFindFactoryClass TypeFindFactory
instance GObjectClass ElementFactory
instance ObjectClass ElementFactory
instance PluginFeatureClass ElementFactory
instance ElementFactoryClass ElementFactory
instance GObjectClass PluginFeature
instance ObjectClass PluginFeature
instance PluginFeatureClass PluginFeature
instance GObjectClass GhostPad
instance ObjectClass GhostPad
instance PadClass GhostPad
instance GhostPadClass GhostPad
instance GObjectClass Pad
instance ObjectClass Pad
instance PadClass Pad
instance GObjectClass Object
instance ObjectClass Object


module Media.Streaming.GStreamer.Core.MiniObject
data MiniObject
class MiniObjectClass o
toMiniObject :: MiniObjectClass o => o -> MiniObject

-- | The flags a <tt>MiniObject</tt> may have.
data MiniObjectFlags

-- | A <a>Monad</a> for sequencing modifications to a <a>MiniObject</a>.
data (MiniObjectClass miniObjectT, Monad m) => MiniObjectT miniObjectT m a
castToMiniObject :: MiniObjectClass obj => obj -> MiniObject
miniObjectGetFlags :: MiniObjectClass miniObjectT => miniObjectT -> [MiniObjectFlags]
miniObjectGetFlagsM :: (MiniObjectClass miniObjectT, MonadIO m) => MiniObjectT miniObjectT m [MiniObjectFlags]
miniObjectSetFlagsM :: (MiniObjectClass miniObjectT, MonadIO m) => [MiniObjectFlags] -> MiniObjectT miniObjectT m ()
miniObjectUnsetFlagsM :: (MiniObjectClass miniObjectT, MonadIO m) => [MiniObjectFlags] -> MiniObjectT miniObjectT m ()


module Media.Streaming.GStreamer.Core.GhostPad
data GhostPad
class PadClass o => GhostPadClass o
castToGhostPad :: GObjectClass obj => obj -> GhostPad
gTypeGhostPad :: GType
ghostPadNew :: PadClass pad => String -> pad -> IO (Maybe Pad)
ghostPadNewNoTarget :: String -> PadDirection -> IO (Maybe Pad)
ghostPadNewFromTemplate :: String -> Pad -> PadTemplate -> IO (Maybe Pad)
ghostPadNewNoTargetFromTemplate :: String -> PadTemplate -> IO (Maybe Pad)
ghostPadSetTarget :: GhostPad -> Pad -> IO Bool
ghostPadGetTarget :: GhostPad -> IO Pad


module Media.Streaming.GStreamer.Core.Format

-- | An enumeration of standard predefined formats.
data Format

-- | no format
FormatUndefined :: Format

-- | the default format of the pad or element; this can be, e.g., samples
--   for raw audio
FormatDefault :: Format

-- | bytes
FormatBytes :: Format

-- | time in nanoseconds
FormatTime :: Format

-- | buffers
FormatBuffers :: Format

-- | percentage of stream
FormatPercent :: Format

-- | a user defined format
FormatUser :: FormatId -> Format

-- | A format definition.
data FormatDefinition
FormatDefinition :: FormatId -> String -> String -> Quark -> FormatDefinition

-- | the unique id of this format
formatValue :: FormatDefinition -> FormatId

-- | a short nickname for the format
formatNick :: FormatDefinition -> String

-- | a longer description of the format
formatDescription :: FormatDefinition -> String

-- | a quark for the nickname
formatQuark :: FormatDefinition -> Quark

-- | A format identifier.
data FormatId

-- | The format value for <a>FormatPercent</a> is between 0 and this value.
formatPercentMax :: Int64

-- | The value used to scale down the reported <a>FormatPercent</a> format
--   value to its real value.
formatPercentScale :: Int64

-- | Get a printable name for the given format.
formatGetName :: Format -> IO String

-- | Get the unique quark for the given format.
formatToQuark :: Format -> IO Quark

-- | Create a new format based on the given nickname, or register a new
--   format with that nickname.
formatRegister :: String -> String -> IO Format

-- | Get the format with the given nickname, or <a>FormatUndefined</a> if
--   no format by that nickname was found.
formatGetByNick :: String -> IO Format

-- | Get the given format's definition.
formatGetDetails :: Format -> IO (Maybe FormatDefinition)

-- | Get an Iterator over all registered formats.
formatIterateDefinitions :: IO (Iterator FormatDefinition)


-- | A factory for creating <a>Element</a>s.
module Media.Streaming.GStreamer.Core.ElementFactory
data ElementFactory
class PluginFeatureClass o => ElementFactoryClass o
castToElementFactory :: GObjectClass obj => obj -> ElementFactory
gTypeElementFactory :: GType

-- | Search for an element factory with the given name.
elementFactoryFind :: String -> IO (Maybe ElementFactory)

-- | Get the <a>GType</a> for elements managed by the given factory. The
--   type can only be retrieved if the element factory is loaded, which can
--   be assured with <a>pluginFeatureLoad</a>.
elementFactoryGetElementType :: ElementFactoryClass elementFactory => elementFactory -> IO (Maybe GType)

-- | Get the long name for the given factory.
elementFactoryGetLongname :: ElementFactoryClass elementFactory => elementFactory -> IO String

-- | Get the class for the given factory.
elementFactoryGetKlass :: ElementFactoryClass elementFactory => elementFactory -> IO String

-- | Get the description for the given factory.
elementFactoryGetDescription :: ElementFactoryClass elementFactory => elementFactory -> IO String

-- | Get the author of the given factory.
elementFactoryGetAuthor :: ElementFactoryClass elementFactory => elementFactory -> IO String

-- | Get the number of <a>PadTemplate</a>s provided by the given factory.
elementFactoryGetNumPadTemplates :: ElementFactoryClass elementFactory => elementFactory -> IO Word

-- | Get the type of URIs supported by the given factory.
elementFactoryGetURIType :: ElementFactoryClass elementFactory => elementFactory -> IO Int

-- | Get the list of protocols supported by the given factory.
elementFactoryGetURIProtocols :: ElementFactoryClass elementFactory => elementFactory -> IO [String]

-- | Check if the given factory implements the interface with the given
--   name.
--   
--   Since 0.10.14.
elementFactoryHasInterface :: ElementFactoryClass elementFactory => elementFactory -> String -> IO Bool

-- | Create a new element of the type supplied by the given factory. It
--   will be given the name supplied.
elementFactoryCreate :: ElementFactoryClass elementFactory => elementFactory -> String -> IO (Maybe Element)

-- | Create a new element of the type supplied by the named factory.
elementFactoryMake :: String -> Maybe String -> IO (Maybe Element)

-- | Check if the given factory can sink the given capabilities.
elementFactoryCanSinkCaps :: ElementFactoryClass elementFactory => elementFactory -> Caps -> IO Bool

-- | Check if the given factory can source the given capabilities.
elementFactoryCanSrcCaps :: ElementFactoryClass elementFactory => elementFactory -> Caps -> IO Bool

-- | Get the pad templates provided by the given factory.
elementFactoryGetPadTemplates :: ElementFactoryClass elementFactory => elementFactory -> IO [PadTemplate]


-- | A structure describing sets of media formats.
module Media.Streaming.GStreamer.Core.Caps
data Caps

-- | A <a>Caps</a> that represents an undefined media type.
capsNone :: Caps

-- | A <a>Caps</a> that represents all possible media types.
capsAny :: Caps

-- | Get the number of structures contained in the <a>Caps</a>.
capsSize :: Caps -> Word

-- | Get the <a>Structure</a> at the given index.
capsGetStructure :: Caps -> Word -> Maybe Structure

-- | Determine whether <tt>caps</tt> represents no media formats.
capsIsEmpty :: Caps -> Bool

-- | Determine whether the <tt>caps</tt> is fixed; that is, if it has
--   exactly one structure, and each field in the structure describes a
--   fixed type.
capsIsFixed :: Caps -> Bool

-- | Returns <a>True</a> if the caps represent the same set of
--   capabilities.
--   
--   This function does not work reliably if optional properties for
--   <a>Caps</a> are included on one <a>Caps</a> but omitted on the other.
capsIsEqual :: Caps -> Caps -> Bool

-- | Returns <a>True</a> if the caps are equal. The caps must both be
--   fixed.
capsIsEqualFixed :: Caps -> Caps -> Bool

-- | Returns <a>True</a> if every media format in the first caps is also
--   contained by the second. That is, the first is a subset of the second.
capsIsAlwaysCompatible :: Caps -> Caps -> Bool

-- | Returns <a>True</a> if all caps represented by the first argument are
--   also represented by the second.
--   
--   This function does not work reliably if optional properties for caps
--   are included on one caps and omitted on the other.
capsIsSubset :: Caps -> Caps -> Bool

-- | Creates a new caps containing all the formats that are common to both
--   of the caps.
capsIntersect :: Caps -> Caps -> Caps

-- | Creates a new caps containing all the formats that are common to
--   either of the caps. If either of the structures are equivalient to
--   <a>capsAny</a>, the result will be <a>capsAny</a>.
capsUnion :: Caps -> Caps -> Caps

-- | Creates a new caps containing all the formats that are in the first
--   but not the second.
capsSubtract :: Caps -> Caps -> Caps

-- | Creates a new caps that represents the same set of formats as the
--   argument, but that contains no lists.
capsNormalize :: Caps -> Caps

-- | Read a caps from a string.
capsFromString :: String -> Maybe Caps

-- | Converts the argument to a string representation. The string can be
--   converted back to a caps using <a>capsFromString</a>.
capsToString :: Caps -> String

-- | A <a>Monad</a> for sequencing modifications to a <a>Caps</a>.
data CapsM a

-- | Create a caps and mutate it according to the given action.
capsCreate :: CapsM a -> (Caps, a)

-- | Copy a caps and mutate it according to the given action.
capsModify :: Caps -> CapsM a -> (Caps, a)

-- | Append the given structure to the current caps.
capsAppendStructure :: Structure -> CapsM ()

-- | Append the structure to the current caps, if it is not already
--   expressed by the caps.
--   
--   Since 0.10.10.
capsMergeStructure :: Structure -> CapsM ()

-- | Removes the structure at the given index from the current caps.
capsRemoveStructure :: Word -> CapsM ()

-- | Discard all but the first structure from the current caps.
capsTruncate :: CapsM ()
instance Functor CapsM
instance Monad CapsM
instance Eq Caps


module Media.Streaming.GStreamer.Core.Structure
data Structure
structureEmpty :: String -> Structure
structureToString :: Structure -> String
structureFromString :: String -> (Maybe Structure, Int)
structureName :: Structure -> String
structureHasName :: Structure -> String -> Bool
structureGetBool :: Structure -> String -> Maybe Bool
structureGetInt :: Structure -> String -> Maybe Int
structureGetFourCC :: Structure -> String -> Maybe FourCC
structureGetDouble :: Structure -> String -> Maybe Double
structureGetString :: Structure -> String -> Maybe String
structureGetDate :: Structure -> String -> Maybe GDate
structureGetClockTime :: Structure -> String -> Maybe ClockTime
structureGetFraction :: Structure -> String -> Maybe Fraction
data StructureM a
structureCreate :: String -> StructureM a -> (Structure, a)
structureModify :: Structure -> StructureM a -> (Structure, a)
structureSetNameM :: String -> StructureM ()
structureRemoveFieldM :: String -> StructureM ()
structureSetBoolM :: String -> Bool -> StructureM ()
structureSetIntM :: String -> Int -> StructureM ()
structureSetFourCCM :: String -> FourCC -> StructureM ()
structureSetDoubleM :: String -> Double -> StructureM ()
structureSetStringM :: String -> String -> StructureM ()
structureSetDateM :: String -> GDate -> StructureM ()
structureSetClockTimeM :: String -> ClockTime -> StructureM ()
structureSetFractionM :: String -> Fraction -> StructureM ()
structureFixateFieldNearestIntM :: String -> Int -> StructureM Bool
structureFixateFieldNearestDoubleM :: String -> Double -> StructureM Bool
structureFixateFieldNearestFractionM :: String -> Fraction -> StructureM Bool
structureFixateFieldBoolM :: String -> Bool -> StructureM Bool


module Media.Streaming.GStreamer.Core.Message
data Message
class MiniObjectClass o => MessageClass o
castToMessage :: MiniObjectClass obj => obj -> Message
gTypeMessage :: GType

-- | The messages types that may be sent by a pipeline.
data MessageType

-- | end-of-stream
MessageEOS :: MessageType

-- | an error message
MessageError :: MessageType

-- | a warning message
MessageWarning :: MessageType

-- | an informational message
MessageInfo :: MessageType

-- | a metadata tag
MessageTag :: MessageType

-- | the pipeline is buffering
MessageBuffering :: MessageType

-- | the pipeline changed state
MessageStateChanged :: MessageType

-- | a framestep finished
MessageStepDone :: MessageType

-- | an element is able to provide a clock
MessageClockProvide :: MessageType

-- | the current clock has become unusable
MessageClockLost :: MessageType

-- | a new clock was selected by the pipeline
MessageNewClock :: MessageType

-- | the structure of the pipeline has changed
MessageStructureChange :: MessageType

-- | a stream status message
MessageStreamStatus :: MessageType

-- | a message posted by the application
MessageApplication :: MessageType

-- | an element specific message
MessageElement :: MessageType

-- | the pipeline started playback of a segment
MessageSegmentStart :: MessageType

-- | the pipeline finished playback of a segment
MessageSegmentDone :: MessageType

-- | the duration of the pipeline changed
MessageDuration :: MessageType

-- | an element's latency has changed
MessageLatency :: MessageType

-- | an element has started an async state change; used internally
MessageAsyncStart :: MessageType

-- | an element has completed an async state change; used internally
MessageAsyncDone :: MessageType
messageTypeGetName :: MessageType -> String
messageTypeToQuark :: MessageType -> Quark
messageSrc :: Message -> Object
messageTimestamp :: Message -> ClockTime
messageType :: Message -> MessageType
messageTypeName :: Message -> String
messageStructure :: Message -> Structure
messageNewApplication :: ObjectClass objectT => objectT -> Structure -> Message
messageNewClockProvide :: (ObjectClass objectT, ClockClass clockT) => objectT -> clockT -> Bool -> Message
messageNewClockLost :: (ObjectClass objectT, ClockClass clockT) => objectT -> clockT -> Message
messageNewCustom :: ObjectClass objectT => MessageType -> objectT -> Maybe Structure -> Message
messageNewElement :: ObjectClass objectT => objectT -> Maybe Structure -> Message
messageNewEOS :: ObjectClass objectT => objectT -> Message
messageNewError :: ObjectClass objectT => objectT -> GError -> String -> Message
messageNewInfo :: ObjectClass objectT => objectT -> GError -> String -> Message
messageNewNewClock :: (ObjectClass objectT, ClockClass clockT) => objectT -> clockT -> Message
messageNewSegmentDone :: ObjectClass objectT => objectT -> Format -> Int64 -> Message
messageNewSegmentStart :: ObjectClass objectT => objectT -> Format -> Int64 -> Message
messageNewStateChanged :: ObjectClass objectT => objectT -> State -> State -> State -> Message
messageNewTag :: ObjectClass objectT => objectT -> TagList -> Message
messageNewBuffering :: ObjectClass objectT => objectT -> Int -> Message
messageNewWarning :: ObjectClass objectT => objectT -> GError -> String -> Message
messageNewDuration :: ObjectClass objectT => objectT -> Format -> Int64 -> Message
messageNewStateDirty :: ObjectClass objectT => objectT -> Message
messageNewLatency :: ObjectClass objectT => objectT -> Message
messageParseClockLost :: Message -> Maybe Clock
messageParseClockProvide :: Message -> Maybe (Clock, Bool)
messageParseError :: Message -> Maybe (GError, String)
messageParseInfo :: Message -> Maybe (GError, String)
messageParseNewClock :: Message -> Maybe Clock
messageParseSegmentDone :: Message -> Maybe (Format, Int64)
messageParseSegmentStart :: Message -> Maybe (Format, Int64)
messageParseStateChanged :: Message -> Maybe (State, State, State)
messageParseTag :: Message -> Maybe TagList
messageParseBuffering :: Message -> Maybe Int
messageParseWarning :: Message -> Maybe (Maybe GError, Maybe String)
messageParseDuration :: Message -> Maybe (Format, Int64)


-- | Data-passing buffer type, supporting sub-buffers.
module Media.Streaming.GStreamer.Core.Buffer
data Buffer
class MiniObjectClass o => BufferClass o
castToBuffer :: MiniObjectClass obj => obj -> Buffer
gTypeBuffer :: GType

-- | The flags a <tt>Buffer</tt> may have.
data BufferFlags

-- | the buffer is part of a preroll and should not be displayed
BufferPreroll :: BufferFlags

-- | the buffer marks a discontinuity in the stream
BufferDiscont :: BufferFlags

-- | the buffer has been added as a field in a <tt>Caps</tt>
BufferInCaps :: BufferFlags

-- | the buffer has been created to fill a gap in the stream
BufferGap :: BufferFlags

-- | the buffer cannot be decoded independently
BufferDeltaUnit :: BufferFlags

-- | The undefined <a>BufferOffset</a> value.
bufferOffsetNone :: BufferOffset

-- | Get the flags set on <tt>buffer</tt>.
bufferGetFlags :: BufferClass bufferT => bufferT -> [BufferFlags]

-- | Get the flags set on the current <a>Buffer</a>.
bufferGetFlagsM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m [BufferFlags]

-- | Set flags on the current <a>Buffer</a>.
bufferSetFlagsM :: (BufferClass bufferT, MonadIO m) => [BufferFlags] -> MiniObjectT bufferT m ()

-- | Unset flags on the current <a>Buffer</a>.
bufferUnsetFlagsM :: (BufferClass bufferT, MonadIO m) => [BufferFlags] -> MiniObjectT bufferT m ()

-- | Get <tt>buffer</tt>'s size in bytes.
bufferGetSize :: BufferClass bufferT => bufferT -> Word

-- | Get the size of the current <a>Buffer</a> in bytes.
bufferGetSizeM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m Word

-- | Get a raw pointer to the internal data area for the current buffer.
--   The pointer may be used to write into the data area if desired. This
--   function is unsafe in that the pointer should not be used once the
--   <a>Buffer</a> is returned.
unsafeBufferGetPtrM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m (Ptr Word8)

-- | Get the timestamp on <tt>buffer</tt>.
bufferGetTimestamp :: BufferClass bufferT => bufferT -> Maybe ClockTime

-- | Get the timestamp on the current <a>Buffer</a>.
bufferGetTimestampM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m (Maybe ClockTime)

-- | Set the timestamp on the current <a>Buffer</a>.
bufferSetTimestampM :: (BufferClass bufferT, MonadIO m) => Maybe ClockTime -> MiniObjectT bufferT m ()

-- | Get the duration of <tt>buffer</tt>.
bufferGetDuration :: BufferClass bufferT => bufferT -> Maybe ClockTime

-- | Get the duration of the current <a>Buffer</a>.
bufferGetDurationM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m (Maybe ClockTime)

-- | Set the duration of the current <a>Buffer</a>.
bufferSetDurationM :: (BufferClass bufferT, MonadIO m) => Maybe ClockTime -> MiniObjectT bufferT m ()

-- | Get the <a>Caps</a> of <tt>buffer</tt>.
bufferGetCaps :: BufferClass bufferT => bufferT -> Maybe Caps

-- | Get the caps of the current <a>Buffer</a>.
bufferGetCapsM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m (Maybe Caps)

-- | Set the caps of the current <a>Buffer</a>.
bufferSetCapsM :: (BufferClass bufferT, MonadIO m) => Maybe Caps -> MiniObjectT bufferT m ()

-- | Get the start offset of the <a>Buffer</a>.
bufferGetOffset :: BufferClass bufferT => bufferT -> Maybe Word64

-- | Get the start offset of the current <a>Buffer</a>.
bufferGetOffsetM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m (Maybe Word64)

-- | Set the start offset of the current <a>Buffer</a>.
bufferSetOffsetM :: (BufferClass bufferT, MonadIO m) => Maybe Word64 -> MiniObjectT bufferT m ()

-- | Get the end offset of the <a>Buffer</a>.
bufferGetOffsetEnd :: BufferClass bufferT => bufferT -> Maybe Word64

-- | Get the end offset of the current <a>Buffer</a>.
bufferGetOffsetEndM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m (Maybe Word64)

-- | Set the end offset of the current <a>Buffer</a>.
bufferSetOffsetEndM :: (BufferClass bufferT, MonadIO m) => Maybe Word64 -> MiniObjectT bufferT m ()

-- | Return <a>True</a> if the <a>Buffer</a> marks a discontinuity in a
--   stream, or <a>False</a> otherwise. This typically occurs after a seek
--   or a dropped buffer from a live or network source.
bufferIsDiscont :: BufferClass bufferT => bufferT -> Bool

-- | Return <a>True</a> if the current <a>Buffer</a> marks a discontinuity
--   in a stream, or <a>False</a> otherwise.
bufferIsDiscontM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m Bool

-- | Create an empty <a>Buffer</a> and mutate it according to the given
--   action. Once this function returns, the <a>Buffer</a> is immutable.
bufferCreateEmpty :: MonadIO m => MiniObjectT Buffer m a -> m (Buffer, a)

-- | Create and mutate a <a>Buffer</a> of the given size.
bufferCreate :: MonadIO m => Word -> MiniObjectT Buffer m a -> m (Buffer, a)

-- | Create a sub-buffer from an existing <a>Buffer</a> with the given
--   offset and size. This sub-buffer uses the actual memory space of the
--   parent buffer. Thus function will copy the offset and timestamp fields
--   when the offset is 0. Otherwise, they will both be set to
--   <a>Nothing</a>. If the offset is 0 and the size is the total size of
--   the parent, the duration and offset end fields are also copied.
--   Otherwise they will be set to <a>Nothing</a>.
bufferCreateSub :: BufferClass bufferT => bufferT -> Word -> Word -> Maybe Buffer

-- | Return <a>True</a> if <a>bufferSpan</a> can be done without copying
--   the data, or <a>False</a> otherwise.
bufferIsSpanFast :: (BufferClass bufferT1, BufferClass bufferT2) => bufferT1 -> bufferT2 -> Bool

-- | Create a new <a>Buffer</a> that consists of a span across the given
--   buffers. Logically, the buffers are concatenated to make a larger
--   buffer, and a new buffer is created at the given offset and with the
--   given size.
--   
--   If the two buffers are children of the same larger buffer, and are
--   contiguous, no copying is necessary. You can use
--   <a>bufferIsSpanFast</a> to determine if copying is needed.
bufferSpan :: (BufferClass bufferT1, BufferClass bufferT2) => bufferT1 -> Word32 -> bufferT2 -> Word32 -> Maybe Buffer

-- | Concatenate two buffers. If the buffers point to contiguous memory
--   areas, no copying will occur.
bufferMerge :: (BufferClass bufferT1, BufferClass bufferT2) => bufferT1 -> bufferT2 -> Buffer


-- | An object describing events that are passed up and down a pipeline.
module Media.Streaming.GStreamer.Core.Event
data Event
class MiniObjectClass o => EventClass o

-- | The event types that may occur in a pipeline.
data EventType

-- | an unknown event
EventUnknown :: EventType

-- | start a flush operation
EventFlushStart :: EventType

-- | stop a flush operation
EventFlushStop :: EventType

-- | end of stream
EventEOS :: EventType

-- | a new segment follows in the dataflow
EventNewSegment :: EventType

-- | a new set of metadata tags has been found
EventTag :: EventType

-- | notification of buffering requirements
EventBufferSize :: EventType

-- | quality of service notification
EventQOS :: EventType

-- | a request for a new playback position and rate
EventSeek :: EventType

-- | notification of user request
EventNavigation :: EventType

-- | notification of latency adjustment
EventLatency :: EventType

-- | custom upstream event
EventCustomUpstream :: EventType

-- | custom downstream event
EventCustomDownstream :: EventType

-- | custom downstream out-of-band event
EventCustomDownstreamOOB :: EventType

-- | custom bidirectional event
EventCustomBoth :: EventType

-- | custom bidirectional out-of-band event
EventCustomBothOOB :: EventType
data SeekFlags
SeekFlagNone :: SeekFlags
SeekFlagFlush :: SeekFlags
SeekFlagAccurate :: SeekFlags
SeekFlagKeyUnit :: SeekFlags
SeekFlagSegment :: SeekFlags
SeekFlagSkip :: SeekFlags
data SeekType
SeekTypeNone :: SeekType
SeekTypeCur :: SeekType
SeekTypeSet :: SeekType
SeekTypeEnd :: SeekType
eventType :: EventClass event => event -> EventType
eventNewCustom :: EventType -> Structure -> IO Event
eventNewEOS :: IO Event
eventNewFlushStart :: IO Event
eventNewFlushStop :: IO Event
eventNewLatency :: ClockTime -> IO Event
eventNewNavigation :: Structure -> IO Event
eventNewNewSegment :: Bool -> Double -> Format -> Int64 -> Int64 -> Int64 -> IO Event
eventNewNewSegmentFull :: Bool -> Double -> Double -> Format -> Int64 -> Int64 -> Int64 -> IO Event
eventNewQOS :: Double -> ClockTimeDiff -> ClockTime -> IO Event
eventNewSeek :: Double -> Format -> [SeekFlags] -> SeekType -> Int64 -> SeekType -> Int64 -> IO Event
eventNewTag :: TagList -> IO Event
eventParseBufferSize :: EventClass event => event -> Maybe (Format, Int64, Int64, Bool)
eventParseLatency :: EventClass event => event -> Maybe ClockTime
eventParseNewSegment :: EventClass event => event -> Maybe (Bool, Double, Format, Int64, Int64, Int64)
eventParseNewSegmentFull :: EventClass event => event -> Maybe (Bool, Double, Double, Format, Int64, Int64, Int64)
eventParseQOS :: EventClass event => event -> Maybe (Double, ClockTimeDiff, ClockTime)
eventParseSeek :: EventClass event => event -> Maybe (Double, Format, [SeekFlags], SeekType, Int64, SeekType, Int64)
eventParseTag :: EventClass event => event -> Maybe TagList
eventTypeGetName :: EventType -> String
eventTypeGetFlags :: EventType -> [EventTypeFlags]


module Media.Streaming.GStreamer.Core.Query
data Query
class MiniObjectClass o => QueryClass o
toQuery :: QueryClass o => o -> Query
castToQuery :: MiniObjectClass obj => obj -> Query
gTypeQuery :: GType


-- | Abstract class of global clocks.
module Media.Streaming.GStreamer.Core.Clock
data Clock
class ObjectClass o => ClockClass o
castToClock :: GObjectClass obj => obj -> Clock
gTypeClock :: GType

-- | A time value in nanoseconds.
type ClockTime = Word64

-- | The undefined <a>ClockTime</a> value.
clockTimeNone :: ClockTime

-- | Returns <a>True</a> if the given <a>ClockTime</a> is valid, and
--   <a>False</a> otherwise.
clockTimeIsValid :: ClockTime -> Bool

-- | One second as a <a>ClockTime</a> value.
second :: ClockTime

-- | One millisecond as a <a>ClockTime</a> value.
msecond :: ClockTime

-- | One microsecond as a <a>ClockTime</a> value.
usecond :: ClockTime

-- | One nanosecond as a <a>ClockTime</a> value.
nsecond :: ClockTime
type ClockTimeDiff = Int64
data ClockID
data ClockReturn
ClockOk :: ClockReturn
ClockEarly :: ClockReturn
ClockUnscheduled :: ClockReturn
ClockBusy :: ClockReturn
ClockBadtime :: ClockReturn
ClockError :: ClockReturn
ClockUnsupported :: ClockReturn
ClockDone :: ClockReturn

-- | The flags that a <tt>Clock</tt> may have.
data ClockFlags

-- | the clock can do a single sync timeout request
ClockCanDoSingleSync :: ClockFlags

-- | the clock can do a single async timeout request
ClockCanDoSingleAsync :: ClockFlags

-- | the clock can do periodic sync timeout requests
ClockCanDoPeriodicSync :: ClockFlags

-- | the clock can do periodic async timeout requests
ClockCanDoPeriodicAsync :: ClockFlags

-- | the clock's resolution can be changed
ClockCanSetResolution :: ClockFlags

-- | the clock can be slaved to a master clock
ClockCanSetMaster :: ClockFlags

-- | Get the flags set on the clock.
clockGetFlags :: ClockClass clockT => clockT -> IO [ClockFlags]

-- | Set the given flags on the clock.
clockSetFlags :: ClockClass clockT => clockT -> [ClockFlags] -> IO ()

-- | Unset the given flags on the clock.
clockUnsetFlags :: ClockClass clockT => clockT -> [ClockFlags] -> IO ()

-- | The time master of the master clock and the time slave of the slave
--   clock are added to the list of observations. If enough observations
--   are available, a linear regression algorithm is run on the
--   observations and clock is recalibrated.
--   
--   If a calibration is performed, the correlation coefficient of the
--   interpolation will be returned. A value of 1.0 means the clocks are in
--   perfect sync. This value can be used to control the sampling frequency
--   of the master and slave clocks.
clockAddObservation :: ClockClass clock => clock -> ClockTime -> ClockTime -> IO (Maybe Double)

-- | Set <tt>master</tt> as the master clock for <tt>clock</tt>. The
--   <tt>clock</tt> will automatically be calibrated so that
--   <a>clockGetTime</a> reports the same time as the <tt>master</tt>
--   clock.
--   
--   A clock provider that slaves its clock to a master can get the current
--   calibration values with <a>clockGetCalibration</a>.
--   
--   The <tt>master</tt> clock can be <a>Nothing</a> in which case
--   <tt>clock</tt> will not be slaved any longer. It will, however,
--   continue to report its time adjusted using the last configured rate
--   and time offsets.
--   
--   Note that if <tt>clock</tt> does not have the
--   <tt>ClockFlagCanSetMaster</tt> flag set, this function will not
--   succeed and return <a>False</a>.
clockSetMaster :: (ClockClass clock, ClockClass master) => clock -> Maybe master -> IO Bool

-- | Return the master that <tt>clock</tt> is slaved to, or <a>Nothing</a>
--   if <tt>clock</tt> is not slaved.
clockGetMaster :: ClockClass clock => clock -> IO (Maybe Clock)

-- | Set the resolution of <tt>clock</tt>. Some clocks have the possibility
--   to operate with different resolution at the expense of more resource
--   usage. There is normally no need to change the default resolution of a
--   clock. The resolution of a clock can only be changed if the clock has
--   the <tt>ClockFlagCanSetResolution</tt> flag set.
clockSetResolution :: ClockClass clock => clock -> ClockTime -> IO ClockTime

-- | Get the resolution of the <tt>clock</tt>. The resolution of the clock
--   is the granularity of the values returned by <a>clockGetTime</a>.
clockGetResolution :: ClockClass clock => clock -> IO ClockTime

-- | Get the current time stored in <tt>clock</tt>. The time is always
--   monotonically increasing and adjusted according to the current offset
--   and rate.
clockGetTime :: ClockClass clock => clock -> IO ClockTime

-- | Get a <a>ClockID</a> from <tt>clock</tt> to trigger a single shot
--   notification at the requested time.
clockNewSingleShotID :: ClockClass clock => clock -> ClockTime -> IO ClockID

-- | Get a <a>ClockID</a> from <tt>clock</tt> to trigger periodic
--   notifications. The notifications will start at time <tt>startTime</tt>
--   and then be fired at each <tt>interval</tt> after.
clockNewPeriodicID :: ClockClass clock => clock -> ClockTime -> ClockTime -> IO ClockID

-- | Gets the current internal time of <tt>clock</tt>. The time is returned
--   unadjusted in the offset and rate.
clockGetInternalTime :: ClockClass clock => clock -> IO ClockTime

-- | Gets the internal rate and reference time of <tt>clock</tt>. See
--   <a>clockSetCalibration</a> for more information.
clockGetCalibration :: ClockClass clock => clock -> IO (ClockTime, ClockTime, Ratio ClockTime)

-- | Adjusts the rate and time of clock. A rate of <tt>1 % 1</tt> is the
--   normal speed of the clock. Larger values make the clock go faster.
--   
--   The parameters <tt>internal</tt> and <tt>external</tt> specifying that
--   <a>clockGetTime</a> should have returned <tt>external</tt> when the
--   clock had internal time <tt>internal</tt>. The parameter
--   <tt>internal</tt> should not be in the future; that is, it should be
--   less than the value returned by <a>clockGetInternalTime</a> when this
--   function is called.
--   
--   Subsequent calls to <a>clockGetTime</a> will return clock times
--   computed as follows:
--   
--   <pre>
--   (clock_internal - internal) * rate + external
--   </pre>
--   
--   Note that <a>clockGetTime</a> always returns increasing values, so if
--   the clock is moved backwards, <a>clockGetTime</a> will report the
--   previous value until the clock catches up.
clockSetCalibration :: ClockClass clock => clock -> ClockTime -> ClockTime -> Ratio ClockTime -> IO ()

-- | Get the time of <tt>clockID</tt>.
clockIDGetTime :: ClockID -> IO ClockTime

-- | Perform a blocking wait on <tt>clockID</tt>. The parameter
--   <tt>clockID</tt> should have been created with
--   <a>clockNewSingleShotID</a> or <a>clockNewPeriodicID</a>, and should
--   not been unscheduled with a call to <a>clockIDUnschedule</a>.
--   
--   If second value in the returned pair is not <a>Nothing</a>, it will
--   contain the difference against the clock and the time of
--   <tt>clockID</tt> when this method was called. Positive values indicate
--   how late <tt>clockID</tt> was relative to the clock. Negative values
--   indicate how much time was spend waiting on the clock before the
--   function returned.
clockIDWait :: ClockID -> IO (ClockReturn, Maybe ClockTimeDiff)

-- | Cancel an outstanding request with <tt>clockID</tt>. After this call,
--   <tt>clockID</tt> cannot be used anymore to recieve notifications; you
--   must create a new <a>ClockID</a>.
clockIDUnschedule :: ClockID -> IO ()

-- | The amount of time, in nanoseconds, between samples.
clockTimeout :: ClockClass clockT => Attr clockT ClockTime

-- | The size of the window used to calculate rate and offset.
clockWindowSize :: ClockClass clockT => Attr clockT Int

-- | The threshold to start calculating rate and offset.
clockWindowThreshold :: ClockClass clockT => Attr clockT Int


module Media.Streaming.GStreamer.Core.ImplementsInterface
data ImplementsInterface
class ElementClass o => ImplementsInterfaceClass o
castToImplementsInterface :: GObjectClass obj => obj -> ImplementsInterface
toImplementsInterface :: ImplementsInterfaceClass o => o -> ImplementsInterface
elementImplementsInterface :: ElementClass element => element -> GType -> IO Bool


module Media.Streaming.GStreamer.Core.IndexFactory
data IndexFactory
class PluginFeatureClass o => IndexFactoryClass o
castToIndexFactory :: GObjectClass obj => obj -> IndexFactory
gTypeIndexFactory :: GType
indexFactoryFind :: String -> IO (Maybe IndexFactory)
indexFactoryCreate :: IndexFactory -> IO Index
indexFactoryMake :: String -> IO Index


module Media.Streaming.GStreamer.Core.Iterator
data Iterable a => Iterator a
class Iterable a
type IteratorFilter itemT = itemT -> IO Bool
type IteratorFoldFunction itemT accumT = itemT -> accumT -> IO (Bool, accumT)
data IteratorResult
IteratorDone :: IteratorResult
IteratorOk :: IteratorResult
IteratorResync :: IteratorResult
IteratorError :: IteratorResult
iteratorNext :: Iterable a => Iterator a -> IO (IteratorResult, Maybe a)
iteratorResync :: Iterator a -> IO ()
iteratorFilter :: Iterable a => Iterator a -> IteratorFilter a -> IO (Iterator a)
iteratorFold :: Iterable itemT => Iterator itemT -> accumT -> IteratorFoldFunction itemT accumT -> IO (IteratorResult, accumT)
iteratorForeach :: Iterable itemT => Iterator itemT -> (itemT -> IO ()) -> IO IteratorResult
iteratorFind :: Iterable itemT => Iterator itemT -> (itemT -> IO Bool) -> IO (IteratorResult, Maybe itemT)


module Media.Streaming.GStreamer.Core.Parse
parseLaunch :: String -> IO (Maybe Element, Maybe GError)
parseLaunchFromArgs :: [String] -> IO (Maybe Element, Maybe GError)
parseBinFromDescription :: String -> Bool -> IO (Maybe Element, Maybe GError)


module Media.Streaming.GStreamer.Core.Pipeline
data Pipeline
class BinClass o => PipelineClass o
castToPipeline :: GObjectClass obj => obj -> Pipeline
gTypePipeline :: GType
pipelineNew :: String -> IO Element
pipelineGetBus :: PipelineClass pipeline => pipeline -> IO Bus
pipelineSetClock :: (PipelineClass pipeline, ClockClass clock) => pipeline -> clock -> IO Bool
pipelineUseClock :: (PipelineClass pipeline, ClockClass clock) => pipeline -> clock -> IO ()
pipelineSetNewStreamTime :: PipelineClass pipeline => pipeline -> ClockTime -> IO ()
pipelineGetLastStreamTime :: PipelineClass pipeline => pipeline -> IO ClockTime
pipelineSetAutoFlushBus :: PipelineClass pipeline => pipeline -> Bool -> IO ()
pipelineGetAutoFlushBus :: PipelineClass pipeline => pipeline -> IO Bool
pipelineSetDelay :: PipelineClass pipeline => pipeline -> ClockTime -> IO ()
pipelineGetDelay :: PipelineClass pipeline => pipeline -> IO ClockTime
pipelineAutoFlushBus :: PipelineClass pipelineT => Attr pipelineT Bool
pipelineDelay :: PipelineClass pipelineT => Attr pipelineT ClockTime


module Media.Streaming.GStreamer.Core.Plugin
data Plugin
class ObjectClass o => PluginClass o
castToPlugin :: GObjectClass obj => obj -> Plugin
gTypePlugin :: GType
pluginGetName :: PluginClass plugin => plugin -> IO String
pluginGetDescription :: PluginClass plugin => plugin -> IO String
pluginGetFilename :: PluginClass plugin => plugin -> IO FilePath
pluginGetLicense :: PluginClass plugin => plugin -> IO String
pluginGetPackage :: PluginClass plugin => plugin -> IO String
pluginGetOrigin :: PluginClass plugin => plugin -> IO String
pluginGetSource :: PluginClass plugin => plugin -> IO String
pluginGetVersion :: PluginClass plugin => plugin -> IO String
pluginIsLoaded :: PluginClass plugin => plugin -> IO Bool
pluginLoadByName :: String -> IO Plugin
pluginLoad :: PluginClass plugin => plugin -> IO plugin
pluginName :: PluginClass plugin => ReadAttr plugin String
pluginDescription :: PluginClass plugin => ReadAttr plugin String
pluginFilename :: PluginClass plugin => ReadAttr plugin FilePath
pluginLicense :: PluginClass plugin => ReadAttr plugin String
pluginPackage :: PluginClass plugin => ReadAttr plugin String
pluginOrigin :: PluginClass plugin => ReadAttr plugin String
pluginSource :: PluginClass plugin => ReadAttr plugin String
pluginVersion :: PluginClass plugin => ReadAttr plugin String


module Media.Streaming.GStreamer.Core.PluginFeature
data PluginFeature
class ObjectClass o => PluginFeatureClass o
castToPluginFeature :: GObjectClass obj => obj -> PluginFeature
gTypePluginFeature :: GType
pluginFeatureLoad :: PluginFeatureClass pluginFeature => pluginFeature -> IO pluginFeature
pluginFeatureCheckVersion :: PluginFeatureClass pluginFeature => pluginFeature -> Word -> Word -> Word -> IO Bool


module Media.Streaming.GStreamer.Core.Segment
data Segment
Segment :: Double -> Double -> Format -> [SeekFlags] -> Int64 -> Int64 -> Int64 -> Int64 -> Int64 -> Int64 -> Segment
segmentRate :: Segment -> Double
segmentAbsRate :: Segment -> Double
segmentFormat :: Segment -> Format
segmentFlags :: Segment -> [SeekFlags]
segmentStart :: Segment -> Int64
segmentStop :: Segment -> Int64
segmentTime :: Segment -> Int64
segmentAccum :: Segment -> Int64
segmentLastStop :: Segment -> Int64
segmentDuration :: Segment -> Int64
segmentClip :: Segment -> Format -> Int64 -> Int64 -> (Segment, Bool, Int64, Int64)
segmentSetDuration :: Segment -> Format -> Int64 -> Segment
segmentSetLastStop :: Segment -> Format -> Int64 -> Segment
segmentSetNewsegment :: Segment -> Bool -> Double -> Format -> Int64 -> Int64 -> Int64 -> Segment
segmentSetSeek :: Segment -> Double -> Format -> [SeekFlags] -> SeekType -> Int64 -> SeekType -> Int64 -> (Segment, Bool)
segmentToRunningTime :: Segment -> Format -> Int64 -> Int64
segmentToStreamTime :: Segment -> Format -> Int64 -> Int64


module Media.Streaming.GStreamer.Core.SystemClock
data SystemClock
class ClockClass o => SystemClockClass o
castToSystemClock :: GObjectClass obj => obj -> SystemClock
gTypeSystemClock :: GType
systemClockObtain :: IO Clock


module Media.Streaming.GStreamer.Core.TagList
data StandardTag
StandardTagTitle :: StandardTag
StandardTagArtist :: StandardTag
StandardTagAlbum :: StandardTag
StandardTagDate :: StandardTag
StandardTagGenre :: StandardTag
StandardTagComment :: StandardTag
StandardTagExtendedComment :: StandardTag
StandardTagTrackNumber :: StandardTag
StandardTagTrackCount :: StandardTag
StandardTagAlbumVolumeNumber :: StandardTag
StandardTagVolumeCount :: StandardTag
StandardTagLocation :: StandardTag
StandardTagDescription :: StandardTag
StandardTagVersion :: StandardTag
StandardTagISRC :: StandardTag
StandardTagOrganization :: StandardTag
StandardTagCopyright :: StandardTag
StandardTagContact :: StandardTag
StandardTagLicense :: StandardTag
StandardTagPerformer :: StandardTag
StandardTagDuration :: StandardTag
StandardTagCodec :: StandardTag
StandardTagVideoCodec :: StandardTag
StandardTagAudioCodec :: StandardTag
StandardTagBitrate :: StandardTag
StandardTagNominalBitrate :: StandardTag
StandardTagMinimumBitrate :: StandardTag
StandardTagMaximumBitrate :: StandardTag
StandardTagSerial :: StandardTag
StandardTagEncoder :: StandardTag
StandardTagEncoderVersion :: StandardTag
StandardTagTrackGain :: StandardTag
StandardTagTrackPeak :: StandardTag
StandardTagAlbumGain :: StandardTag
StandardTagAlbumPeak :: StandardTag
StandardTagReferenceLevel :: StandardTag
StandardTagLanguageCode :: StandardTag
StandardTagImage :: StandardTag
StandardTagPreviewImage :: StandardTag
StandardTagBeatsPerMinute :: StandardTag
standardTagToString :: StandardTag -> Tag
tagNick :: Tag -> String
tagDescription :: Tag -> String
tagGetFlag :: Tag -> TagFlag
tagIsFixed :: Tag -> Bool
tagListEmpty :: TagList
tagListIsEmpty :: TagList -> Bool
tagListMerge :: TagList -> TagList -> TagMergeMode -> TagList
tagListGetTagSize :: TagList -> Tag -> Word
tagListCreate :: StructureM a -> (TagList, a)
tagListModify :: TagList -> StructureM a -> (TagList, a)
tagListInsert :: TagList -> TagMergeMode -> StructureM ()
tagListRemoveTag :: Tag -> StructureM ()
tagListGetChar :: TagList -> Tag -> Maybe Char
tagListGetCharIndex :: TagList -> Tag -> Word -> Maybe Char
tagListGetUChar :: TagList -> Tag -> Maybe Word8
tagListGetUCharIndex :: TagList -> Tag -> Word -> Maybe Word8
tagListGetBool :: TagList -> Tag -> Maybe Bool
tagListGetBoolIndex :: TagList -> Tag -> Word -> Maybe Bool
tagListGetInt :: TagList -> Tag -> Maybe Int
tagListGetIntIndex :: TagList -> Tag -> Word -> Maybe Int
tagListGetUInt :: TagList -> Tag -> Maybe Word
tagListGetUIntIndex :: TagList -> Tag -> Word -> Maybe Word
tagListGetLong :: TagList -> Tag -> Maybe Int64
tagListGetLongIndex :: TagList -> Tag -> Word -> Maybe Int64
tagListGetULong :: TagList -> Tag -> Maybe Word64
tagListGetULongIndex :: TagList -> Tag -> Word -> Maybe Word64
tagListGetInt64 :: TagList -> Tag -> Maybe Int64
tagListGetInt64Index :: TagList -> Tag -> Word -> Maybe Int64
tagListGetUInt64 :: TagList -> Tag -> Maybe Word64
tagListGetUInt64Index :: TagList -> Tag -> Word -> Maybe Word64
tagListGetFloat :: TagList -> Tag -> Maybe Float
tagListGetFloatIndex :: TagList -> Tag -> Word -> Maybe Float
tagListGetDouble :: TagList -> Tag -> Maybe Double
tagListGetDoubleIndex :: TagList -> Tag -> Word -> Maybe Double
tagListGetString :: TagList -> Tag -> Maybe String
tagListGetStringIndex :: TagList -> Tag -> Word -> Maybe String
tagListGetDate :: TagList -> Tag -> Maybe GDate
tagListGetDateIndex :: TagList -> Tag -> Word -> Maybe GDate
instance Eq StandardTag
instance Enum StandardTag
instance Bounded StandardTag
instance Show StandardTag


module Media.Streaming.GStreamer.Base.BaseSrc
data BaseSrc
class ElementClass o => BaseSrcClass o
castToBaseSrc :: GObjectClass obj => obj -> BaseSrc
gTypeBaseSrc :: GType
baseSrcGetFlags :: BaseSrcClass baseSrcT => baseSrcT -> IO [BaseSrcFlags]
baseSrcSetFlags :: BaseSrcClass baseSrcT => baseSrcT -> [BaseSrcFlags] -> IO ()
baseSrcUnsetFlags :: BaseSrcClass baseSrcT => baseSrcT -> [BaseSrcFlags] -> IO ()
baseSrcWaitPlaying :: BaseSrcClass baseSrcT => baseSrcT -> IO FlowReturn
baseSrcIsLive :: BaseSrcClass baseSrcT => baseSrcT -> IO Bool
baseSrcGetPad :: BaseSrcClass baseSrcT => baseSrcT -> IO Pad
baseSrcBlockSize :: BaseSrcClass baseSrcT => Attr baseSrcT Word64
baseSrcNumBuffers :: BaseSrcClass baseSrcT => Attr baseSrcT Int
baseSrcTypefind :: BaseSrcClass baseSrcT => Attr baseSrcT Bool


module Media.Streaming.GStreamer.Base.BaseSink
data BaseSink
class ElementClass o => BaseSinkClass o
castToBaseSink :: GObjectClass obj => obj -> BaseSink
gTypeBaseSink :: GType
baseSinkQueryLatency :: BaseSinkClass baseSinkT => baseSinkT -> IO (Maybe (Bool, Bool, ClockTime, ClockTime))
baseSinkGetLatency :: BaseSinkClass baseSinkT => baseSinkT -> IO ClockTime
baseSinkWaitPreroll :: BaseSinkClass baseSinkT => baseSinkT -> IO FlowReturn
baseSinkSetSync :: BaseSinkClass baseSinkT => baseSinkT -> Bool -> IO ()
baseSinkGetSync :: BaseSinkClass baseSinkT => baseSinkT -> IO Bool
baseSinkSetMaxLateness :: BaseSinkClass baseSinkT => baseSinkT -> Word64 -> IO ()
baseSinkGetMaxLateness :: BaseSinkClass baseSinkT => baseSinkT -> IO Word64
baseSinkIsQOSEnabled :: BaseSinkClass baseSinkT => baseSinkT -> IO Bool
baseSinkSetQOSEnabled :: BaseSinkClass baseSinkT => baseSinkT -> Bool -> IO ()
baseSinkPrerollQueueLength :: BaseSinkClass baseSinkT => Attr baseSinkT Int
baseSinkGetPad :: BaseSinkClass baseSinkT => baseSinkT -> IO Pad


module Media.Streaming.GStreamer.Base.BaseTransform
data BaseTransform
class ElementClass o => BaseTransformClass o
castToBaseTransform :: GObjectClass obj => obj -> BaseTransform
gTypeBaseTransform :: GType
baseTransformIsPassthrough :: BaseTransformClass baseTransformT => baseTransformT -> IO Bool
baseTransformSetPassthrough :: BaseTransformClass baseTransformT => baseTransformT -> Bool -> IO ()
baseTransformIsInPlace :: BaseTransformClass baseTransformT => baseTransformT -> IO Bool
baseTransformSetInPlace :: BaseTransformClass baseTransformT => baseTransformT -> Bool -> IO ()
baseTransformIsQOSEnabled :: BaseTransformClass baseTransformT => baseTransformT -> IO Bool
baseTransformSetQOSEnabled :: BaseTransformClass baseTransformT => baseTransformT -> Bool -> IO ()
baseTransformGetSinkPad :: BaseTransformClass baseTransformT => baseTransformT -> IO Pad
baseTransformGetSrcPad :: BaseTransformClass baseTransformT => baseTransformT -> IO Pad
baseTransformQOS :: BaseTransformClass baseTransformT => Attr baseTransformT Bool


module Media.Streaming.GStreamer.Base.PushSrc
data PushSrc
class BaseSrcClass o => PushSrcClass o
castToPushSrc :: GObjectClass obj => obj -> PushSrc
gTypePushSrc :: GType


module Media.Streaming.GStreamer.Base.Adapter
data Adapter
class GObjectClass o => AdapterClass o
castToAdapter :: GObjectClass obj => obj -> Adapter
gTypeAdapter :: GType
adapterNew :: IO Adapter
adapterClear :: AdapterClass adapterT => adapterT -> IO ()
adapterPush :: (AdapterClass adapterT, BufferClass bufferT) => adapterT -> bufferT -> IO ()
adapterFlush :: AdapterClass adapterT => adapterT -> Word -> IO ()
adapterAvailable :: AdapterClass adapterT => adapterT -> IO Word
adapterAvailableFast :: AdapterClass adapterT => adapterT -> IO Word
adapterTakeBuffer :: AdapterClass adapterT => adapterT -> Word -> IO (Maybe Buffer)


module Media.Streaming.GStreamer.Base


module Media.Streaming.GStreamer.Base.CollectPads
data CollectData
data CollectPads


module Media.Streaming.GStreamer.Controller.Controller
data Controller
class GObjectClass o => ControllerClass o


module Media.Streaming.GStreamer.Net.NetClientClock


module Media.Streaming.GStreamer.DataProtocol.DataProtocol
instance Enum DPVersion
instance Enum DPPayloadType


module Media.Streaming.GStreamer.Audio.Audio
data AudioFieldFlag
AudioFieldRate :: AudioFieldFlag
AudioFieldChannels :: AudioFieldFlag
AudioFieldEndianness :: AudioFieldFlag
AudioFieldWidth :: AudioFieldFlag
AudioFieldDepth :: AudioFieldFlag
AudioFieldSigned :: AudioFieldFlag


module Media.Streaming.GStreamer.Core.Object
data Object
class GObjectClass o => ObjectClass o
castToObject :: GObjectClass obj => obj -> Object
gTypeObject :: GType
objectGetFlags :: ObjectClass objectT => objectT -> IO [ObjectFlags]
objectSetFlags :: ObjectClass objectT => objectT -> [ObjectFlags] -> IO ()
objectUnsetFlags :: ObjectClass objectT => objectT -> [ObjectFlags] -> IO ()
objectSetName :: ObjectClass obj => obj -> Maybe String -> IO Bool
objectGetName :: ObjectClass obj => obj -> IO (Maybe String)
objectSetParent :: (ObjectClass obj, ObjectClass parent) => obj -> parent -> IO Bool
objectGetParent :: ObjectClass obj => obj -> IO (Maybe Object)
objectUnparent :: ObjectClass obj => obj -> IO ()
objectGetNamePrefix :: ObjectClass obj => obj -> IO (Maybe String)
objectSetNamePrefix :: ObjectClass obj => obj -> Maybe String -> IO ()
objectHasAncestor :: (ObjectClass obj, ObjectClass obj') => obj -> obj' -> IO Bool
objectWithLock :: ObjectClass objectT => objectT -> IO a -> IO a
objectWithTrylock :: ObjectClass objectT => objectT -> IO a -> IO (Maybe a)
objectLock :: ObjectClass objectT => objectT -> IO ()
objectTrylock :: ObjectClass objectT => objectT -> IO Bool
objectUnlock :: ObjectClass objectT => objectT -> IO ()
onObjectParentSet :: ObjectClass objectT => objectT -> (GObject -> IO ()) -> IO (ConnectId objectT)
afterObjectParentSet :: ObjectClass objectT => objectT -> (GObject -> IO ()) -> IO (ConnectId objectT)
onObjectParentUnset :: ObjectClass objectT => objectT -> (GObject -> IO ()) -> IO (ConnectId objectT)
afterObjectParentUnset :: ObjectClass objectT => objectT -> (GObject -> IO ()) -> IO (ConnectId objectT)
objectName :: ObjectClass objectT => Attr objectT (Maybe String)


-- | Abstract class of pipeline elements.
module Media.Streaming.GStreamer.Core.Element
data Element
class ObjectClass o => ElementClass o
castToElement :: GObjectClass obj => obj -> Element
gTypeElement :: GType

-- | The flags that an <tt>Element</tt> may have.
data ElementFlags

-- | parent state changes are ignored
ElementLockedState :: ElementFlags

-- | the element is a sink
ElementIsSink :: ElementFlags

-- | child is being removed from the parent bin
ElementUnparenting :: ElementFlags
data State
StateVoidPending :: State
StateNull :: State
StateReady :: State
StatePaused :: State
StatePlaying :: State

-- | The different state changes that are passed to the state change
--   functions of <tt>Element</tt>s.
data StateChange

-- | state change from <tt>StateNull</tt> to <tt>StateReady</tt>
StateChangeNullToReady :: StateChange

-- | state change from <tt>StateReady</tt> to <tt>StatePaused</tt>
StateChangeReadyToPaused :: StateChange

-- | state change from <tt>StatePaused</tt> to <tt>StatePlaying</tt>
StateChangePausedToPlaying :: StateChange

-- | state change from <tt>StatePlaying</tt> to <tt>StatePaused</tt>
StateChangePlayingToPaused :: StateChange

-- | state change from <tt>StatePaused</tt> to <tt>StateReady</tt>
StateChangePausedToReady :: StateChange

-- | state change from <tt>StateReady</tt> to <tt>StateNull</tt>
StateChangeReadyToNull :: StateChange
data StateChangeReturn
StateChangeFailure :: StateChangeReturn
StateChangeSuccess :: StateChangeReturn
StateChangeAsync :: StateChangeReturn
StateChangeNoPreroll :: StateChangeReturn

-- | Add a pad (link point) to an element. The pad's parent will be set to
--   <tt>element</tt>.
--   
--   Pads are not automatically activated so elements should perform the
--   needed steps to activate the pad in case this pad is added in the
--   <a>StatePaused</a> or <a>StatePlaying</a> state. See
--   <tt>padSetActive</tt> for more information about activating pads.
--   
--   This function will emit the <a>elementPadAdded</a> signal on the
--   element.
elementAddPad :: (ElementClass elementT, PadClass padT) => elementT -> padT -> IO Bool

-- | Look for an unlinked pad to which the <tt>pad</tt> can link. It is not
--   guaranteed that linking the pads will work, though it should work in
--   most cases.
elementGetCompatiblePad :: (ElementClass elementT, PadClass padT) => elementT -> padT -> Caps -> IO (Maybe Pad)

-- | Retrieve a pad template from <tt>element</tt> that is compatible with
--   <tt>padTemplate</tt>. Pads from compatible templates can be linked
--   together.
elementGetCompatiblePadTemplate :: (ElementClass elementT, PadTemplateClass padTemplateT) => elementT -> padTemplateT -> IO (Maybe PadTemplate)

-- | Retrieve a pad from the element by name. This version only retrieves
--   request pads. The pad should be released with
--   <a>elementReleaseRequestPad</a>.
elementGetRequestPad :: ElementClass elementT => elementT -> String -> IO (Maybe Pad)

-- | Retreive a pad from <tt>element</tt> by name. This version only
--   retrieves already-existing (i.e. <a>static</a>) pads.
elementGetStaticPad :: ElementClass elementT => elementT -> String -> IO (Maybe Pad)

-- | Release a request pad that was previously obtained with
--   <a>elementGetRequestPad</a>.
elementReleaseRequestPad :: (ElementClass elementT, PadClass padT) => elementT -> padT -> IO ()

-- | Remove <tt>pad</tt> from <tt>element</tt>.
--   
--   This function is used by plugin developers and should not be used by
--   applications. Pads that were dynamically requested from elements with
--   <a>elementGetRequestPad</a> should be released with the
--   <a>elementReleaseRequestPad</a> function instead.
--   
--   Pads are not automatically deactivated so elements should perform the
--   needed steps to deactivate the pad in case this pad is removed in the
--   PAUSED or PLAYING state. See <tt>padSetActive</tt> for more
--   information about deactivating pads.
--   
--   The pad and the element should be unlocked when calling this function.
--   
--   This function will emit the <tt>padRemoved</tt> signal on the element.
--   
--   Returns: <a>True</a> if the pad could be removed. Can return
--   <a>False</a> if the pad does not belong to the provided element.
elementRemovePad :: (ElementClass elementT, PadClass padT) => elementT -> padT -> IO Bool

-- | Retrieve an <a>Iterator</a> over <tt>element</tt>'s pads.
elementIteratePads :: ElementClass elementT => elementT -> IO (Iterator Pad)

-- | Retrieve an <a>Iterator</a> over <tt>element</tt>'s sink pads.
elementIterateSinkPads :: ElementClass elementT => elementT -> IO (Iterator Pad)

-- | Retrieve an <a>Iterator</a> over <tt>element</tt>'s src pads.
elementIterateSrcPads :: ElementClass elementT => elementT -> IO (Iterator Pad)

-- | Link <tt>src</tt> to <tt>sink</tt>. The link must be from source to
--   sink; the other direction will not be tried. The function looks for
--   existing pads that aren't linked yet. It will request new pads if
--   necessary. Such pads must be released manually (with
--   <a>elementReleaseRequestPad</a>) when unlinking. If multiple links are
--   possible, only one is established.
--   
--   Make sure you have added your elements to a <a>Bin</a> or
--   <a>Pipeline</a> with <tt>binAdd</tt> before trying to link them.
elementLink :: (ElementClass srcT, ElementClass sinkT) => srcT -> sinkT -> IO Bool

-- | Unlink all source pads of the <tt>src</tt> from all sink pads of the
--   <tt>sink</tt>.
elementUnlink :: (ElementClass srcT, ElementClass sinkT) => srcT -> sinkT -> IO ()

-- | Link the named pads of <tt>src</tt> and <tt>sink</tt>.
elementLinkPads :: (ElementClass srcT, ElementClass sinkT) => srcT -> Maybe String -> sinkT -> Maybe String -> IO Bool

-- | Unlink the named pads of <tt>src</tt> and <tt>sink</tt>.
elementUnlinkPads :: (ElementClass srcT, ElementClass sinkT) => srcT -> String -> sinkT -> String -> IO ()

-- | Link the named pads of <tt>src</tt> and <tt>sink</tt>. A side effect
--   is that if one of the pads has no parent, it becomes a child of the
--   parent of the other element. If they have different parents, the link
--   will fail. If <tt>caps</tt> is not <a>Nothing</a>, make sure that the
--   <a>Caps</a> of the link is a subset of <tt>caps</tt>.
elementLinkPadsFiltered :: (ElementClass srcT, ElementClass sinkT) => srcT -> Maybe String -> sinkT -> Maybe String -> Caps -> IO Bool

-- | Link <tt>src</tt> to <tt>dest</tt> using the given <a>Caps</a> as a
--   filter. The link must be from source to sink; the other direction will
--   not be tried. The function looks for existing pads that aren't linked
--   yet. If will request new pads if necessary. If multiple links are
--   possible, only one is established.
--   
--   Make sure you have added your elements to a <a>Bin</a> or
--   <a>Pipeline</a> with <tt>binAdd</tt> before trying to link them.
elementLinkFiltered :: (ElementClass srcT, ElementClass sinkT) => srcT -> sinkT -> Maybe Caps -> IO Bool

-- | Set the base time of <tt>element</tt>. See <a>elementGetBaseTime</a>
--   for more information.
elementSetBaseTime :: ElementClass elementT => elementT -> ClockTimeDiff -> IO ()

-- | Return the base time of <tt>element</tt>. The base time is the
--   absolute time of the clock when this element was last set to
--   <a>StatePlaying</a>. Subtract the base time from the clock time to get
--   the stream time of the element.
elementGetBaseTime :: ElementClass elementT => elementT -> IO ClockTimeDiff

-- | Set the <a>Bus</a> used by <tt>element</tt>. For internal use only,
--   unless you're testing elements.
elementSetBus :: (ElementClass elementT, BusClass busT) => elementT -> busT -> IO ()

-- | Get the bus of <tt>element</tt>. Not that only a <a>Pipeline</a> will
--   provide a bus for the application.
elementGetBus :: ElementClass elementT => elementT -> IO Bus

-- | Get the factory used to create <tt>element</tt>.
elementGetFactory :: ElementClass elementT => elementT -> IO ElementFactory

-- | Set the <a>Index</a> used by <tt>element</tt>.
elementSetIndex :: (ElementClass elementT, IndexClass indexT) => elementT -> indexT -> IO ()

-- | Determine whether <tt>element</tt> can be indexed.
elementIsIndexable :: ElementClass elementT => elementT -> IO Bool

-- | Determine whether <tt>element</tt> requires a clock.
elementRequiresClock :: ElementClass elementT => elementT -> IO Bool

-- | Set the <a>Clock</a> used by <tt>element</tt>.
elementSetClock :: (ElementClass elementT, ClockClass clockT) => elementT -> clockT -> IO Bool

-- | Get the <a>Clock</a> used by <tt>element</tt>.
elementGetClock :: ElementClass elementT => elementT -> IO (Maybe Clock)

-- | Determine whether <tt>element</tt> provides a clock. A <a>Clock</a>
--   provided by an element can be used as the global clock for a pipeline.
--   An element that can provide a clock is only required to do so in the
--   <a>StatePaused</a> state, meaning that it is fully negotiated and has
--   allocated the resources needed to operate the clock.
elementProvidesClock :: ElementClass elementT => elementT -> IO Bool

-- | Get the <a>Clock</a> provided by <tt>element</tt>.
--   
--   Note that an element is only required to provide a clock in the
--   <a>StatePaused</a> state. Some elements can provide a clock in other
--   states.
elementProvideClock :: ElementClass elementT => elementT -> IO (Maybe Clock)

-- | Set the state of <tt>element</tt> to <tt>state</tt>. This function
--   will try to set the requested state by going through all the
--   intermediary states and calling the class's state change function for
--   each.
--   
--   This function can return <a>StateChangeAsync</a>, in which case the
--   element will perform the remainder of the state change asynchronously
--   in another thread. An application can use <a>elementGetState</a> to
--   wait for the completion of the state change or it can wait for a state
--   change message on the bus.
elementSetState :: ElementClass elementT => elementT -> State -> IO StateChangeReturn

-- | Get the state of <tt>element</tt>.
--   
--   For elements that performed an asynchronous state change, as reported
--   by <a>elementSetState</a>, this function will block up to the
--   specified timeout value for the state change to complete. If the
--   element completes the state change or goes into an error, this
--   function returns immediately with a return value of
--   <a>StateChangeSuccess</a> or <a>StateChangeFailure</a>, respectively.
--   
--   This function returns <a>StateChangeNoPreroll</a> if the element
--   successfully changed its state but is not able to provide data yet.
--   This mostly happens for live sources that not only produce data in the
--   <a>StatePlaying</a> state. While the state change return is equivalent
--   to <a>StateChangeSuccess</a>, it is returned to the application to
--   signal that some sink elements might not be able to somplete their
--   state change because an element is not producing data to complete the
--   preroll. When setting the element to playing, the preroll will
--   complete and playback will start.
elementGetState :: ElementClass elementT => elementT -> ClockTime -> IO (StateChangeReturn, Maybe State, Maybe State)

-- | Lock the state of <tt>element</tt>, so state changes in the parent
--   don't affect this element any longer.
elementSetLockedState :: ElementClass elementT => elementT -> Bool -> IO Bool

-- | Determine whether <tt>element</tt>'s state is locked.
elementIsLockedState :: ElementClass elementT => elementT -> IO Bool

-- | Abort <tt>element</tt>'s state change. This function is used by
--   elements that do asynchronous state changes and find out something is
--   wrong.
--   
--   This function should be called with the state lock held.
elementAbortState :: ElementClass elementT => elementT -> IO ()

-- | Get a string representation of <tt>state</tt>.
elementStateGetName :: State -> String

-- | Get a string representation of <tt>stateRet</tt>.
--   
--   Since 0.10.11.
elementStateChangeReturnGetName :: StateChangeReturn -> String

-- | Try to change the state of <tt>element</tt> to the same as its parent.
--   If this function returns <a>False</a>, the state of the element is
--   undefined.
elementSyncStateWithParent :: ElementClass elementT => elementT -> IO Bool
elementGetQueryTypes :: ElementClass element => element -> IO [QueryType]

-- | Perform a query on the given element.
--   
--   For elements that don't implement a query handler, this function
--   forwards the query to a random srcpad or to the peer of a random
--   linked sinkpad of this element.
elementQuery :: (ElementClass element, QueryClass query) => element -> query -> IO Bool

-- | Query an element for the convertion of a value from one format to
--   another.
elementQueryConvert :: ElementClass element => element -> Format -> Int64 -> Format -> IO (Maybe (Format, Word64))

-- | Query an element for its stream position.
elementQueryPosition :: ElementClass element => element -> Format -> IO (Maybe (Format, Word64))

-- | Query an element for its stream duration.
elementQueryDuration :: ElementClass element => element -> Format -> IO (Maybe (Format, Word64))

-- | Send an event to an element.
--   
--   If the element doesn't implement an event handler, the event will be
--   pushed to a random linked sink pad for upstream events or a random
--   linked source pad for downstream events.
elementSendEvent :: (ElementClass element, EventClass event) => element -> event -> IO Bool

-- | Perform a seek on the given element. This function only supports
--   seeking to a position relative to the start of the stream. For more
--   complex operations like segment seeks (such as for looping), or
--   changing the playback rate, or seeking relative to the last configured
--   playback segment you should use <a>elementSeek</a>.
--   
--   In a completely prerolled pipeline in the <a>StatePaused</a> or
--   <a>StatePlaying</a> states, seeking is always guaranteed to return
--   <a>True</a> on a seekable media type, or <a>False</a> when the media
--   type is certainly not seekable (such as a live stream).
--   
--   Some elements allow for seeking in the <a>StateReady</a> state, in
--   which case they will store the seek event and execute it when they are
--   put into the <a>StatePaused</a> state. If the element supports seek in
--   <a>StateReady</a>, it will always return <a>True</a> when it recieves
--   the event in the <a>StateReady</a> state.
elementSeekSimple :: ElementClass element => element -> Format -> [SeekFlags] -> Int64 -> IO Bool

-- | Send a seek event to an element. See <a>eventNewSeek</a> for the
--   details of the parameters. The seek event is sent to the element using
--   <a>elementSendEvent</a>.
elementSeek :: ElementClass element => element -> Double -> Format -> [SeekFlags] -> SeekType -> Int64 -> SeekType -> Int64 -> IO Bool

-- | The signal emitted when an element will not generate more dynamic
--   pads.
elementNoMorePads :: ElementClass element => Signal element (IO ())

-- | The signal emitted when a new <a>Pad</a> has been added to the
--   element.
elementPadAdded :: ElementClass element => Signal element (Pad -> IO ())

-- | The signal emitted when a <a>Pad</a> has been removed from the
--   element.
elementPadRemoved :: ElementClass element => Signal element (Pad -> IO ())


module Media.Streaming.GStreamer.Core.Pad
data Pad
class ObjectClass o => PadClass o
castToPad :: GObjectClass obj => obj -> Pad
gTypePad :: GType

-- | The flags that a <tt>Pad</tt> may have.
data PadFlags

-- | dataflow on the pad is blocked
PadBlocked :: PadFlags

-- | the pad is refusing buffers
PadFlushing :: PadFlags

-- | <tt>padGetCaps</tt> is executing
PadInGetCaps :: PadFlags

-- | <tt>padSetCaps</tt> is executing
PadInSetCaps :: PadFlags

-- | the pad is blocking on a buffer or event
PadBlocking :: PadFlags
data PadDirection
PadUnknown :: PadDirection
PadSrc :: PadDirection
PadSink :: PadDirection
data PadLinkReturn
PadLinkOk :: PadLinkReturn
PadLinkWrongHierarchy :: PadLinkReturn
PadLinkWasLinked :: PadLinkReturn
PadLinkWrongDirection :: PadLinkReturn
PadLinkNoformat :: PadLinkReturn
PadLinkNosched :: PadLinkReturn
PadLinkRefused :: PadLinkReturn
data FlowReturn
FlowCustomSuccess2 :: FlowReturn
FlowCustomSuccess1 :: FlowReturn
FlowCustomSuccess :: FlowReturn
FlowResend :: FlowReturn
FlowOk :: FlowReturn
FlowNotLinked :: FlowReturn
FlowWrongState :: FlowReturn
FlowUnexpected :: FlowReturn
FlowNotNegotiated :: FlowReturn
FlowError :: FlowReturn
FlowNotSupported :: FlowReturn
FlowCustomError :: FlowReturn
FlowCustomError1 :: FlowReturn
FlowCustomError2 :: FlowReturn
data ActivateMode
ActivateNone :: ActivateMode
ActivatePush :: ActivateMode
ActivatePull :: ActivateMode
padGetFlags :: PadClass padT => padT -> IO [PadFlags]
padSetFlags :: PadClass padT => padT -> [PadFlags] -> IO ()
padUnsetFlags :: PadClass padT => padT -> [PadFlags] -> IO ()
padNew :: String -> PadDirection -> IO Pad
padGetDirection :: PadClass pad => pad -> IO PadDirection
padGetParentElement :: PadClass pad => pad -> IO Element
padLink :: (PadClass srcpad, PadClass sinkpad) => srcpad -> sinkpad -> IO PadLinkReturn
padUnlink :: (PadClass srcpad, PadClass sinkpad) => srcpad -> sinkpad -> IO Bool
padIsLinked :: PadClass pad => pad -> IO Bool
padCanLink :: (PadClass srcpad, PadClass sinkpad) => srcpad -> sinkpad -> IO Bool
padGetCaps :: PadClass pad => pad -> IO Caps
padGetAllowedCaps :: PadClass pad => pad -> IO (Maybe Caps)
padGetNegotiatedCaps :: PadClass pad => pad -> IO (Maybe Caps)
padGetPadTemplateCaps :: PadClass pad => pad -> IO Caps
padSetCaps :: PadClass pad => pad -> Maybe Caps -> IO Bool
padGetPeer :: PadClass pad => pad -> IO (Maybe Pad)
padPeerGetCaps :: PadClass pad => pad -> IO (Maybe Caps)
padIsActive :: PadClass pad => pad -> IO Bool
padSetBlocked :: PadClass pad => pad -> Bool -> IO Bool
padIsBlocked :: PadClass pad => pad -> IO Bool
padIsBlocking :: PadClass pad => pad -> IO Bool
padNewFromTemplate :: PadTemplateClass padTemplate => padTemplate -> String -> IO (Maybe Pad)
padAcceptCaps :: PadClass pad => pad -> Caps -> IO Bool
padProxyGetcaps :: PadClass pad => pad -> IO Caps
padFixateCaps :: PadClass pad => pad -> Caps -> IO Caps
padPeerAcceptCaps :: PadClass pad => pad -> Caps -> IO Bool
padSendEvent :: (PadClass pad, EventClass event) => pad -> event -> IO Bool
padQuery :: (PadClass pad, QueryClass query) => pad -> query -> IO (Maybe query)
padQueryPosition :: PadClass pad => pad -> IO (Maybe (Format, Int64))
padQueryDuration :: PadClass pad => pad -> IO (Maybe (Format, Int64))
padQueryConvert :: PadClass pad => pad -> Format -> Int64 -> IO (Maybe (Format, Int64))
padQueryPeerPosition :: PadClass pad => pad -> IO (Maybe (Format, Int64))
padQueryPeerDuration :: PadClass pad => pad -> IO (Maybe (Format, Int64))
padQueryPeerConvert :: PadClass pad => pad -> Format -> Int64 -> IO (Maybe (Format, Int64))
padGetQueryTypes :: PadClass pad => pad -> IO [QueryType]
onPadLinked :: PadClass pad => pad -> (Pad -> IO ()) -> IO (ConnectId pad)
afterPadLinked :: PadClass pad => pad -> (Pad -> IO ()) -> IO (ConnectId pad)
onPadRequestLink :: PadClass pad => pad -> IO () -> IO (ConnectId pad)
afterPadRequestLink :: PadClass pad => pad -> IO () -> IO (ConnectId pad)
onPadUnlinked :: PadClass pad => pad -> (Pad -> IO ()) -> IO (ConnectId pad)
afterPadUnlinked :: PadClass pad => pad -> (Pad -> IO ()) -> IO (ConnectId pad)
padCaps :: PadClass pad => ReadAttr pad Caps
padDirection :: PadClass pad => ReadAttr pad PadDirection
padTemplate :: PadClass pad => ReadAttr pad PadTemplate


-- | Base class for elements that can contain other elements.
module Media.Streaming.GStreamer.Core.Bin
data Bin
class ElementClass o => BinClass o
castToBin :: GObjectClass obj => obj -> Bin
gTypeBin :: GType

-- | Create a new <a>Bin</a> with the given name.
binNew :: String -> IO Bin

-- | Add <tt>element</tt> to <tt>bin</tt>, and set <tt>element</tt>'s
--   parent to <tt>bin</tt>. An <a>Element</a> can only be added to one
--   <a>Bin</a> at a time.
--   
--   If any of <tt>element</tt>'s pads are linked to other <a>Pad</a>s,
--   they will be unlinked before <tt>element</tt> is added to
--   <tt>bin</tt>.
binAdd :: (BinClass bin, ElementClass element) => bin -> element -> IO Bool

-- | Remove <tt>element</tt> from <tt>bin</tt>, unparenting it as well.
--   
--   If any <tt>element</tt>'s pads are linked to other pads, they will be
--   unlinked before <tt>element</tt> is added to <tt>bin</tt>.
binRemove :: (BinClass bin, ElementClass element) => bin -> element -> IO Bool

-- | Get the <a>Element</a> with the given name <tt>name</tt> from
--   <tt>bin</tt>, recursing down through <tt>bin</tt>'s children.
--   <a>Nothing</a> is returned if no <a>Element</a> with the given name is
--   found.
binGetByName :: BinClass bin => bin -> String -> IO (Maybe Element)

-- | Get the <a>Element</a> with the given name <tt>name</tt> from
--   <tt>bin</tt>, recursing up through <tt>bin</tt>'s parents. Returns
--   <a>Nothing</a> if no element with the given name is found.
binGetByNameRecurseUp :: BinClass bin => bin -> String -> IO (Maybe Element)

-- | Find an <a>Element</a> inside <tt>bin</tt> that implements the
--   interface given by <tt>iface</tt>. The returned <a>Element</a> can be
--   casted to <tt>iface</tt>'s type. If you want all the <a>Element</a>s
--   that implement an interface, use <a>binIterateAllByInterface</a>.
--   
--   This function recurses into child bins.
binGetByInterface :: BinClass bin => bin -> GType -> IO (Maybe Element)

-- | Get an <a>Iterator</a> over the <a>Element</a>s in <tt>bin</tt>.
binIterateElements :: BinClass bin => bin -> IO (Maybe (Iterator Element))

-- | Get an <a>Iterator</a> over the <a>Element</a>s in <tt>bin</tt>. This
--   iterator recurses into <tt>bin</tt>'s children.
binIterateRecurse :: BinClass bin => bin -> IO (Maybe (Iterator Element))

-- | Get an iterator over the <a>Element</a>s in <tt>bin</tt> that have the
--   <a>ElementIsSink</a> flag set.
binIterateSinks :: BinClass bin => bin -> IO (Maybe (Iterator Element))

-- | Gets an iterator for the elements in this bin in topologically sorted
--   order. This means that the elements are returned from the most
--   downstream elements (sinks) to the sources.
--   
--   This function is used internally to perform state changes of the bin
--   elements.
binIterateSorted :: BinClass bin => bin -> IO (Maybe (Iterator Element))

-- | Gets an iterator for all elements in the bin that have no sink pads
--   and have the <a>ElementIsSink</a> flag unset.
binIterateSources :: BinClass bin => bin -> IO (Maybe (Iterator Element))

-- | Looks for all elements inside the bin that implement the given
--   interface. You can safely case all elements to the given interface.
--   The function recurses inside child bins.
binIterateAllByInterface :: BinClass bin => bin -> GType -> IO (Maybe (Iterator Element))

-- | Recursively looks for elements with an unconnected pad of the given
--   direction within the specified bin. Returns an unconnected pad if one
--   is found, otherwise <a>Nothing</a>.
--   
--   Since 0.10.3.
binFindUnconnectedPad :: BinClass bin => bin -> PadDirection -> IO (Maybe Pad)

-- | An <a>Element</a> has been added to the <a>Bin</a>.
binElementAdded :: BinClass bin => Signal bin (Element -> IO ())

-- | An <a>Element</a> has been removed from the <a>Bin</a>.
binElementRemoved :: BinClass bin => Signal bin (Element -> IO ())


-- | An asynchronous message bus subsystem.
module Media.Streaming.GStreamer.Core.Bus
data Bus
class ObjectClass o => BusClass o
data BusSyncReply
type BusSyncHandler = Bus -> Message -> IO BusSyncReply
castToBus :: GObjectClass obj => obj -> Bus
gTypeBus :: GType

-- | Get the flags set on this bus.
busGetFlags :: BusClass busT => busT -> IO [BusFlags]

-- | Set flags on this bus.
busSetFlags :: BusClass busT => busT -> [BusFlags] -> IO ()

-- | Unset flags on this bus.
busUnsetFlags :: BusClass busT => busT -> [BusFlags] -> IO ()

-- | Create a new bus.
busNew :: IO Bus

-- | Post a message to the bus.
busPost :: BusClass busT => busT -> Message -> IO Bool

-- | Check if there are pending messages on the bus.
busHavePending :: BusClass busT => busT -> IO Bool

-- | Get the message at the front of the queue. Any message returned will
--   remain on the queue.
busPeek :: BusClass busT => busT -> IO (Maybe Message)

-- | Get the message at the front of the queue. It will be removed from the
--   queue.
busPop :: BusClass busT => busT -> IO (Maybe Message)

-- | Get a message from the bus, waiting up to the specified timeout. If
--   the time given is <a>Nothing</a>, the function will wait forever. If
--   the time given is <tt>0</tt>, the function will behave like
--   <a>busPop</a>.
--   
--   Since 0.10.12.
busTimedPop :: BusClass busT => busT -> Maybe ClockTime -> IO (Maybe Message)

-- | If <tt>flushing</tt> is <a>True</a>, the bus will flush out any queued
--   messages, as well as any future messages, until the function is called
--   with <tt>flushing</tt> set to <a>False</a>.
busSetFlushing :: BusClass busT => busT -> Bool -> IO ()

-- | Set the synchronous message handler on the bus. The function will be
--   called every time a new message is posted to the bus. Note that the
--   function will be called from the thread context of the poster.
--   
--   Calling this function will replace any previously set sync handler. If
--   <a>Nothing</a> is passed to this function, it will unset the handler.
busSetSyncHandler :: BusClass busT => busT -> Maybe BusSyncHandler -> IO ()

-- | Use a synchronous message handler that converts all messages to
--   signals.
busUseSyncSignalHandler :: BusClass busT => busT -> IO ()

-- | Create a watch for the bus. The <a>Source</a> will dispatch a signal
--   whenever a message is on the bus. After the signal is dispatched, the
--   message is popped off the bus.
busCreateWatch :: BusClass busT => busT -> IO Source

-- | Adds a bus watch to the default main context with the given priority.
--   This function is used to receive asynchronous messages in the main
--   loop.
--   
--   The watch can be removed by calling <a>sourceRemove</a>.
busAddWatch :: BusClass busT => busT -> Priority -> BusFunc -> IO HandlerId

-- | Instructs GStreamer to stop emitting the <a>busSyncMessage</a> signal
--   for this bus. See <a>busEnableSyncMessageEmission</a> for more
--   information.
--   
--   In the event that multiple pieces of code have called
--   <a>busEnableSyncMessageEmission</a>, the sync-message emissions will
--   only be stopped after all calls to <a>busEnableSyncMessageEmission</a>
--   were <a>cancelled</a> by calling this function.
busDisableSyncMessageEmission :: BusClass busT => busT -> IO ()

-- | Instructs GStreamer to emit the <a>busSyncMessage</a> signal after
--   running the bus's sync handler. This function is here so that
--   programmers can ensure that they can synchronously receive messages
--   without having to affect what the bin's sync handler is.
--   
--   This function may be called multiple times. To clean up, the caller is
--   responsible for calling <a>busDisableSyncMessageEmission</a> as many
--   times as this function is called.
--   
--   While this function looks similar to <a>busAddSignalWatch</a>, it is
--   not exactly the same -- this function enables synchronous emission of
--   signals when messages arrive; <a>busAddSignalWatch</a> adds an idle
--   callback to pop messages off the bus asynchronously. The
--   <a>busSyncMessage</a> signal comes from the thread of whatever object
--   posted the message; the <a>busMessage</a> signal is marshalled to the
--   main thread via the main loop.
busEnableSyncMessageEmission :: BusClass busT => busT -> IO ()

-- | Adds a bus signal watch to the default main context with the given
--   priority. After calling this method, the bus will emit the
--   <a>busMessage</a> signal for each message posted on the bus.
--   
--   This function may be called multiple times. To clean up, the caller is
--   responsible for calling <a>busRemoveSignalWatch</a> as many times.
busAddSignalWatch :: BusClass busT => busT -> Priority -> IO ()

-- | Remove the signal watch that was added with <a>busAddSignalWatch</a>.
busRemoveSignalWatch :: BusClass busT => busT -> IO ()

-- | Poll the bus for a message. Will block while waiting for messages to
--   come. You can specify the maximum amount of time to wait with the
--   <tt>timeout</tt> parameter. If <tt>timeout</tt> is negative, the
--   function will wait indefinitely.
--   
--   Messages not in <tt>events</tt> will be popped off the bus and
--   ignored.
--   
--   Because <a>busPoll</a> is implemented using the <a>busMessage</a>
--   signal enabled by <a>busAddSignalWatch</a>, calling <a>busPoll</a>
--   will cause the <a>busMessage</a> signal to be emitted for every
--   message that the function sees. Thus, a <a>busMessage</a> signal
--   handler will see every message that <a>busPoll</a> sees -- neither
--   will steal messages from the other.
--   
--   This function will run a main loop in the default main context while
--   polling.
busPoll :: BusClass busT => busT -> [MessageType] -> ClockTimeDiff -> IO Message

-- | A message has been posted on the bus. This signal is emitted from a
--   <a>Source</a> added to the <a>MainLoop</a>, and only when it is
--   running.
busMessage :: BusClass busT => Signal busT (Message -> IO ())

-- | A message has been posted on the bus. This signal is emitted from the
--   thread that posted the message so one has to be careful with locking.
--   
--   This signal will not be emitted by default, you must first call
--   <a>busUseSyncSignalHandler</a> if you want this signal to be emitted
--   when a message is posted on the bus.
busSyncMessage :: BusClass busT => Signal busT (Message -> IO ())


module Media.Streaming.GStreamer.Core.PadTemplate
data PadTemplate
class ObjectClass o => PadTemplateClass o
castToPadTemplate :: GObjectClass obj => obj -> PadTemplate
gTypePadTemplate :: GType
data PadPresence
PadAlways :: PadPresence
PadSometimes :: PadPresence
PadRequest :: PadPresence
padTemplateNew :: String -> PadDirection -> PadPresence -> Caps -> IO PadTemplate
padTemplateGetCaps :: PadTemplateClass padTemplate => padTemplate -> IO Caps
padTemplateGetNameTemplate :: PadTemplateClass padTemplate => padTemplate -> IO String
padTemplateGetDirection :: PadTemplateClass padTemplate => padTemplate -> IO PadDirection
padTemplateGetPresence :: PadTemplateClass padTemplate => padTemplate -> IO PadPresence
onPadTemplatePadCreated :: PadTemplateClass padTemplateT => padTemplateT -> (Pad -> IO ()) -> IO (ConnectId padTemplateT)
afterPadTemplatePadCreated :: PadTemplateClass padTemplateT => padTemplateT -> (Pad -> IO ()) -> IO (ConnectId padTemplateT)


module Media.Streaming.GStreamer.Core.Index
data Index
class ObjectClass o => IndexClass o
castToIndex :: GObjectClass obj => obj -> Index
gTypeIndex :: GType
indexNew :: IO Index
indexCommit :: IndexClass index => index -> Int -> IO ()
indexGetGroup :: IndexClass index => index -> IO Int
indexNewGroup :: IndexClass index => index -> IO Int
indexSetGroup :: IndexClass index => index -> Int -> IO Bool
indexSetCertainty :: IndexClass index => index -> IndexCertainty -> IO ()
indexSetFilter :: IndexClass index => index -> IndexFilter -> IO ()
indexGetWriterId :: IndexClass index => index -> Object -> IO (Maybe Int)
indexAddFormat :: IndexClass index => index -> Int -> Format -> IO IndexEntry
indexAddAssociations :: IndexClass index => index -> Int -> [AssocFlags] -> [IndexAssociation] -> IO IndexEntry
indexAddId :: IndexClass index => index -> Int -> String -> IO IndexEntry
indexGetAssocEntry :: IndexClass index => index -> Int -> IndexLookupMethod -> [AssocFlags] -> Format -> Int64 -> IO (Maybe IndexEntry)
indexEntryAssocMap :: IndexEntry -> Format -> Maybe Int64
onIndexEntryAdded :: IndexClass index => index -> (IndexEntry -> IO ()) -> IO (ConnectId index)
afterIndexEntryAdded :: IndexClass index => index -> (IndexEntry -> IO ()) -> IO (ConnectId index)


module Media.Streaming.GStreamer.Core.Registry
data Registry
class ObjectClass o => RegistryClass o
castToRegistry :: GObjectClass obj => obj -> Registry
gTypeRegistry :: GType
defaultRegistry :: Registry
registryGetFeatureList :: RegistryClass registry => registry -> GType -> IO [PluginFeature]
registryGetFeatureListByPlugin :: RegistryClass registry => registry -> String -> IO [PluginFeature]
registryGetPathList :: RegistryClass registry => registry -> IO [FilePath]
registryGetPluginList :: RegistryClass registry => registry -> IO [Plugin]
registryAddPlugin :: (RegistryClass registry, PluginClass plugin) => registry -> plugin -> IO Bool
registryRemovePlugin :: (RegistryClass registry, PluginClass plugin) => registry -> plugin -> IO ()
registryPluginFilter :: RegistryClass registry => registry -> PluginFilter -> Bool -> IO [Plugin]
registryFeatureFilter :: RegistryClass registry => registry -> PluginFeatureFilter -> Bool -> IO [PluginFeature]
registryFindPlugin :: RegistryClass registry => registry -> String -> IO (Maybe Plugin)
registryFindFeature :: RegistryClass registry => registry -> String -> GType -> IO (Maybe PluginFeature)
registryLookupFeature :: RegistryClass registry => registry -> String -> IO (Maybe PluginFeature)
registryScanPath :: RegistryClass registry => registry -> FilePath -> IO Bool
registryXMLReadCache :: RegistryClass registry => registry -> FilePath -> IO Bool
registryXMLWriteCache :: RegistryClass registry => registry -> FilePath -> IO Bool
registryLookup :: RegistryClass registry => registry -> FilePath -> IO Plugin
registryRemoveFeature :: (RegistryClass registry, PluginFeatureClass pluginFeature) => registry -> pluginFeature -> IO ()
registryAddFeature :: (RegistryClass registry, PluginFeatureClass pluginFeature) => registry -> pluginFeature -> IO Bool
defaultRegistryCheckFeatureVersion :: String -> Word -> Word -> Word -> IO Bool
defaultRegistryGetPathList :: IO [FilePath]
defaultRegistryAddPlugin :: PluginClass plugin => plugin -> IO Bool
defaultRegistryScanPath :: String -> IO Bool
defaultRegistryFindPlugin :: String -> IO (Maybe Plugin)
defaultRegistryFindFeature :: String -> GType -> IO (Maybe PluginFeature)
defaultRegistryFeatureFilter :: PluginFeatureFilter -> Bool -> IO [PluginFeature]
onRegistryFeatureAdded :: RegistryClass registry => registry -> (PluginFeature -> IO ()) -> IO (ConnectId registry)
afterRegistryFeatureAdded :: RegistryClass registry => registry -> (PluginFeature -> IO ()) -> IO (ConnectId registry)
onRegistryPluginAdded :: RegistryClass registry => registry -> (Plugin -> IO ()) -> IO (ConnectId registry)
afterRegistryPluginAdded :: RegistryClass registry => registry -> (Plugin -> IO ()) -> IO (ConnectId registry)


module Media.Streaming.GStreamer.Core


module Media.Streaming.GStreamer


module Media.Streaming.GStreamer.Audio.AudioClock
data AudioClock
