-- 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
--   OggVorbis playback, audiovideo 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

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

-- | The flags a MiniObject may have.
data MiniObjectFlags

-- | A Monad for sequencing modifications to a MiniObject.
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 FormatPercent is between 0 and this value.
formatPercentMax :: Int64

-- | The value used to scale down the reported FormatPercent 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 FormatUndefined 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 Elements.
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 GType for elements managed by the given factory. The
--   type can only be retrieved if the element factory is loaded, which can
--   be assured with pluginFeatureLoad.
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 PadTemplates 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 Caps that represents an undefined media type.
capsNone :: Caps

-- | A Caps that represents all possible media types.
capsAny :: Caps

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

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

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

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

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

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

-- | Returns True 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 True 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
--   capsAny, the result will be capsAny.
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 capsFromString.
capsToString :: Caps -> String

-- | A Monad for sequencing modifications to a Caps.
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 Buffer 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 Caps
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 BufferOffset value.
bufferOffsetNone :: BufferOffset

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

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

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

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

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

-- | Get the size of the current Buffer 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
--   Buffer is returned.
unsafeBufferGetPtrM :: (BufferClass bufferT, MonadIO m) => MiniObjectT bufferT m (Ptr Word8)

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

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

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

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

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

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

-- | Get the Caps of buffer.
bufferGetCaps :: BufferClass bufferT => bufferT -> Maybe Caps

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

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

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

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

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

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

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

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

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

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

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

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

-- | Create a sub-buffer from an existing Buffer 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
--   Nothing. 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 Nothing.
bufferCreateSub :: BufferClass bufferT => bufferT -> Word -> Word -> Maybe Buffer

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

-- | Create a new Buffer 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
--   bufferIsSpanFast 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 ClockTime value.
clockTimeNone :: ClockTime

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

-- | One second as a ClockTime value.
second :: ClockTime

-- | One millisecond as a ClockTime value.
msecond :: ClockTime

-- | One microsecond as a ClockTime value.
usecond :: ClockTime

-- | One nanosecond as a ClockTime 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 Clock 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 master as the master clock for clock. The
--   clock will automatically be calibrated so that
--   clockGetTime reports the same time as the master
--   clock.
--   
--   A clock provider that slaves its clock to a master can get the current
--   calibration values with clockGetCalibration.
--   
--   The master clock can be Nothing in which case
--   clock 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 clock does not have the
--   ClockFlagCanSetMaster flag set, this function will not
--   succeed and return False.
clockSetMaster :: (ClockClass clock, ClockClass master) => clock -> Maybe master -> IO Bool

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

-- | Set the resolution of clock. 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 ClockFlagCanSetResolution flag set.
clockSetResolution :: ClockClass clock => clock -> ClockTime -> IO ClockTime

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

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

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

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

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

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

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

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

-- | Perform a blocking wait on clockID. The parameter
--   clockID should have been created with
--   clockNewSingleShotID or clockNewPeriodicID, and should
--   not been unscheduled with a call to clockIDUnschedule.
--   
--   If second value in the returned pair is not Nothing, it will
--   contain the difference against the clock and the time of
--   clockID when this method was called. Positive values indicate
--   how late clockID 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 clockID. After this call,
--   clockID cannot be used anymore to recieve notifications; you
--   must create a new ClockID.
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 Element 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 Elements.
data StateChange

-- | state change from StateNull to StateReady
StateChangeNullToReady :: StateChange

-- | state change from StateReady to StatePaused
StateChangeReadyToPaused :: StateChange

-- | state change from StatePaused to StatePlaying
StateChangePausedToPlaying :: StateChange

-- | state change from StatePlaying to StatePaused
StateChangePlayingToPaused :: StateChange

-- | state change from StatePaused to StateReady
StateChangePausedToReady :: StateChange

-- | state change from StateReady to StateNull
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
--   element.
--   
--   Pads are not automatically activated so elements should perform the
--   needed steps to activate the pad in case this pad is added in the
--   StatePaused or StatePlaying state. See
--   padSetActive for more information about activating pads.
--   
--   This function will emit the elementPadAdded signal on the
--   element.
elementAddPad :: (ElementClass elementT, PadClass padT) => elementT -> padT -> IO Bool

-- | Look for an unlinked pad to which the pad 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 element that is compatible with
--   padTemplate. 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
--   elementReleaseRequestPad.
elementGetRequestPad :: ElementClass elementT => elementT -> String -> IO (Maybe Pad)

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

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

-- | Remove pad from element.
--   
--   This function is used by plugin developers and should not be used by
--   applications. Pads that were dynamically requested from elements with
--   elementGetRequestPad should be released with the
--   elementReleaseRequestPad 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 padSetActive for more
--   information about deactivating pads.
--   
--   The pad and the element should be unlocked when calling this function.
--   
--   This function will emit the padRemoved signal on the element.
--   
--   Returns: True if the pad could be removed. Can return
--   False if the pad does not belong to the provided element.
elementRemovePad :: (ElementClass elementT, PadClass padT) => elementT -> padT -> IO Bool

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

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

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

-- | Link src to sink. 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
--   elementReleaseRequestPad) when unlinking. If multiple links are
--   possible, only one is established.
--   
--   Make sure you have added your elements to a Bin or
--   Pipeline with binAdd before trying to link them.
elementLink :: (ElementClass srcT, ElementClass sinkT) => srcT -> sinkT -> IO Bool

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

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

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

-- | Link the named pads of src and sink. 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 caps is not Nothing, make sure that the
--   Caps of the link is a subset of caps.
elementLinkPadsFiltered :: (ElementClass srcT, ElementClass sinkT) => srcT -> Maybe String -> sinkT -> Maybe String -> Caps -> IO Bool

-- | Link src to dest using the given Caps 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 Bin or
--   Pipeline with binAdd before trying to link them.
elementLinkFiltered :: (ElementClass srcT, ElementClass sinkT) => srcT -> sinkT -> Maybe Caps -> IO Bool

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

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

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

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

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

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

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

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

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

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

-- | Determine whether element provides a clock. A Clock
--   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
--   StatePaused 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 Clock provided by element.
--   
--   Note that an element is only required to provide a clock in the
--   StatePaused state. Some elements can provide a clock in other
--   states.
elementProvideClock :: ElementClass elementT => elementT -> IO (Maybe Clock)

-- | Set the state of element to state. 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 StateChangeAsync, in which case the
--   element will perform the remainder of the state change asynchronously
--   in another thread. An application can use elementGetState 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 element.
--   
--   For elements that performed an asynchronous state change, as reported
--   by elementSetState, 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
--   StateChangeSuccess or StateChangeFailure, respectively.
--   
--   This function returns StateChangeNoPreroll 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
--   StatePlaying state. While the state change return is equivalent
--   to StateChangeSuccess, 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 element, so state changes in the parent
--   don't affect this element any longer.
elementSetLockedState :: ElementClass elementT => elementT -> Bool -> IO Bool

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

-- | Abort element'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 state.
elementStateGetName :: State -> String

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

-- | Try to change the state of element to the same as its parent.
--   If this function returns False, 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 elementSeek.
--   
--   In a completely prerolled pipeline in the StatePaused or
--   StatePlaying states, seeking is always guaranteed to return
--   True on a seekable media type, or False when the media
--   type is certainly not seekable (such as a live stream).
--   
--   Some elements allow for seeking in the StateReady state, in
--   which case they will store the seek event and execute it when they are
--   put into the StatePaused state. If the element supports seek in
--   StateReady, it will always return True when it recieves
--   the event in the StateReady state.
elementSeekSimple :: ElementClass element => element -> Format -> [SeekFlags] -> Int64 -> IO Bool

-- | Send a seek event to an element. See eventNewSeek for the
--   details of the parameters. The seek event is sent to the element using
--   elementSendEvent.
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 Pad has been added to the
--   element.
elementPadAdded :: ElementClass element => Signal element (Pad -> IO ())

-- | The signal emitted when a Pad 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 Pad may have.
data PadFlags

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

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

-- | padGetCaps is executing
PadInGetCaps :: PadFlags

-- | padSetCaps 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 Bin with the given name.
binNew :: String -> IO Bin

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

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

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

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

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

-- | Get an Iterator over the Elements in bin.
binIterateElements :: BinClass bin => bin -> IO (Maybe (Iterator Element))

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

-- | Get an iterator over the Elements in bin that have the
--   ElementIsSink 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 ElementIsSink 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 Nothing.
--   
--   Since 0.10.3.
binFindUnconnectedPad :: BinClass bin => bin -> PadDirection -> IO (Maybe Pad)

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

-- | An Element has been removed from the Bin.
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 Nothing, the function will wait forever. If
--   the time given is 0, the function will behave like
--   busPop.
--   
--   Since 0.10.12.
busTimedPop :: BusClass busT => busT -> Maybe ClockTime -> IO (Maybe Message)

-- | If flushing is True, the bus will flush out any queued
--   messages, as well as any future messages, until the function is called
--   with flushing set to False.
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
--   Nothing 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 Source 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 sourceRemove.
busAddWatch :: BusClass busT => busT -> Priority -> BusFunc -> IO HandlerId

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

-- | Instructs GStreamer to emit the busSyncMessage 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 busDisableSyncMessageEmission as many
--   times as this function is called.
--   
--   While this function looks similar to busAddSignalWatch, it is
--   not exactly the same -- this function enables synchronous emission of
--   signals when messages arrive; busAddSignalWatch adds an idle
--   callback to pop messages off the bus asynchronously. The
--   busSyncMessage signal comes from the thread of whatever object
--   posted the message; the busMessage 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
--   busMessage signal for each message posted on the bus.
--   
--   This function may be called multiple times. To clean up, the caller is
--   responsible for calling busRemoveSignalWatch as many times.
busAddSignalWatch :: BusClass busT => busT -> Priority -> IO ()

-- | Remove the signal watch that was added with busAddSignalWatch.
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
--   timeout parameter. If timeout is negative, the
--   function will wait indefinitely.
--   
--   Messages not in events will be popped off the bus and
--   ignored.
--   
--   Because busPoll is implemented using the busMessage
--   signal enabled by busAddSignalWatch, calling busPoll
--   will cause the busMessage signal to be emitted for every
--   message that the function sees. Thus, a busMessage signal
--   handler will see every message that busPoll 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
--   Source added to the MainLoop, 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
--   busUseSyncSignalHandler 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
