module Media.Streaming.GStreamer.Core.Element (
Element,
ElementClass,
castToElement,
gTypeElement,
ElementFlags(..),
State(..),
StateChange(..),
StateChangeReturn(..),
elementAddPad,
elementGetCompatiblePad,
elementGetCompatiblePadTemplate,
elementGetRequestPad,
elementGetStaticPad,
elementReleaseRequestPad,
elementRemovePad,
elementIteratePads,
elementIterateSinkPads,
elementIterateSrcPads,
elementLink,
elementUnlink,
elementLinkPads,
elementUnlinkPads,
elementLinkPadsFiltered,
elementLinkFiltered,
elementSetBaseTime,
elementGetBaseTime,
elementSetBus,
elementGetBus,
elementGetFactory,
elementSetIndex,
elementIsIndexable,
elementRequiresClock,
elementSetClock,
elementGetClock,
elementProvidesClock,
elementProvideClock,
elementSetState,
elementGetState,
elementSetLockedState,
elementIsLockedState,
elementAbortState,
elementStateGetName,
elementStateChangeReturnGetName,
elementSyncStateWithParent,
elementGetQueryTypes,
elementQuery,
elementQueryConvert,
elementQueryPosition,
elementQueryDuration,
elementSendEvent,
elementSeekSimple,
elementSeek,
elementNoMorePads,
elementPadAdded,
elementPadRemoved,
) where
import Control.Monad ( liftM )
import Data.Maybe ( fromMaybe )
import System.Glib.FFI
import System.Glib.Flags
import System.Glib.UTFString ( withUTFString
, peekUTFString )
import System.Glib.Signals
import System.Glib.GObject
import Media.Streaming.GStreamer.Core.Types
import Media.Streaming.GStreamer.Core.Signals
elementGetFlags :: ElementClass elementT
=> elementT
-> IO [ElementFlags]
elementGetFlags = mkObjectGetFlags
elementSetFlags :: ElementClass elementT
=> elementT
-> [ElementFlags]
-> IO ()
elementSetFlags = mkObjectSetFlags
elementUnsetFlags :: ElementClass elementT
=> elementT
-> [ElementFlags]
-> IO ()
elementUnsetFlags = mkObjectUnsetFlags
elementAddPad :: (ElementClass elementT, PadClass padT)
=> elementT
-> padT
-> IO Bool
elementAddPad element pad =
liftM toBool $ (\(Element arg1) (Pad arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_add_pad argPtr1 argPtr2) (toElement element) (toPad pad)
elementGetCompatiblePad :: (ElementClass elementT, PadClass padT)
=> elementT
-> padT
-> Caps
-> IO (Maybe Pad)
elementGetCompatiblePad element pad caps =
(\(Element arg1) (Pad arg2) (Caps arg3) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->withForeignPtr arg3 $ \argPtr3 ->gst_element_get_compatible_pad argPtr1 argPtr2 argPtr3) (toElement element) (toPad pad) caps >>=
maybePeek takeObject
elementGetCompatiblePadTemplate :: (ElementClass elementT, PadTemplateClass padTemplateT)
=> elementT
-> padTemplateT
-> IO (Maybe PadTemplate)
elementGetCompatiblePadTemplate element padTemplate =
(\(Element arg1) (PadTemplate arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_get_compatible_pad_template argPtr1 argPtr2) (toElement element) (toPadTemplate padTemplate) >>=
maybePeek takeObject
elementGetRequestPad :: ElementClass elementT
=> elementT
-> String
-> IO (Maybe Pad)
elementGetRequestPad element name =
(withUTFString name $ (\(Element arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_request_pad argPtr1 arg2) (toElement element)) >>=
maybePeek peekObject
elementGetStaticPad :: ElementClass elementT
=> elementT
-> String
-> IO (Maybe Pad)
elementGetStaticPad element name =
(withUTFString name $ (\(Element arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_static_pad argPtr1 arg2) (toElement element)) >>=
maybePeek takeObject
elementReleaseRequestPad :: (ElementClass elementT, PadClass padT)
=> elementT
-> padT
-> IO ()
elementReleaseRequestPad element pad =
(\(Element arg1) (Pad arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_release_request_pad argPtr1 argPtr2) (toElement element) (toPad pad)
elementRemovePad :: (ElementClass elementT, PadClass padT)
=> elementT
-> padT
-> IO Bool
elementRemovePad element pad =
liftM toBool $ (\(Element arg1) (Pad arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_remove_pad argPtr1 argPtr2) (toElement element) (toPad pad)
elementIteratePads :: (ElementClass elementT)
=> elementT
-> IO (Iterator Pad)
elementIteratePads element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_iterate_pads argPtr1) (toElement element) >>= takeIterator
elementIterateSinkPads :: (ElementClass elementT)
=> elementT
-> IO (Iterator Pad)
elementIterateSinkPads element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_iterate_sink_pads argPtr1) (toElement element) >>= takeIterator
elementIterateSrcPads :: (ElementClass elementT)
=> elementT
-> IO (Iterator Pad)
elementIterateSrcPads element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_iterate_sink_pads argPtr1) (toElement element) >>= takeIterator
elementLink :: (ElementClass srcT, ElementClass sinkT)
=> srcT
-> sinkT
-> IO Bool
elementLink src sink =
liftM toBool $ (\(Element arg1) (Element arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_link argPtr1 argPtr2) (toElement src) (toElement sink)
elementUnlink :: (ElementClass srcT, ElementClass sinkT)
=> srcT
-> sinkT
-> IO ()
elementUnlink src sink =
(\(Element arg1) (Element arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_unlink argPtr1 argPtr2) (toElement src) (toElement sink)
elementLinkPads :: (ElementClass srcT, ElementClass sinkT)
=> srcT
-> Maybe String
-> sinkT
-> Maybe String
-> IO Bool
elementLinkPads src srcPadName sink sinkPadName =
maybeWith withUTFString sinkPadName $ \cSinkPadName ->
maybeWith withUTFString srcPadName $ \cSrcPadName ->
liftM toBool $ (\(Element arg1) arg2 (Element arg3) arg4 -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg3 $ \argPtr3 ->gst_element_link_pads argPtr1 arg2 argPtr3 arg4) (toElement src) cSrcPadName (toElement sink) cSinkPadName
elementUnlinkPads :: (ElementClass srcT, ElementClass sinkT)
=> srcT
-> String
-> sinkT
-> String
-> IO ()
elementUnlinkPads src srcPadName sink sinkPadName =
withUTFString sinkPadName $ \cSinkPadName ->
withUTFString srcPadName $ \cSrcPadName ->
(\(Element arg1) arg2 (Element arg3) arg4 -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg3 $ \argPtr3 ->gst_element_unlink_pads argPtr1 arg2 argPtr3 arg4) (toElement src) cSrcPadName (toElement sink) cSinkPadName
elementLinkPadsFiltered :: (ElementClass srcT, ElementClass sinkT)
=> srcT
-> Maybe String
-> sinkT
-> Maybe String
-> Caps
-> IO Bool
elementLinkPadsFiltered src srcPadName sink sinkPadName filter =
maybeWith withUTFString sinkPadName $ \cSinkPadName ->
maybeWith withUTFString srcPadName $ \cSrcPadName ->
liftM toBool $ (\(Element arg1) arg2 (Element arg3) arg4 (Caps arg5) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg3 $ \argPtr3 ->withForeignPtr arg5 $ \argPtr5 ->gst_element_link_pads_filtered argPtr1 arg2 argPtr3 arg4 argPtr5) (toElement src) cSrcPadName (toElement sink) cSinkPadName filter
elementLinkFiltered :: (ElementClass srcT, ElementClass sinkT)
=> srcT
-> sinkT
-> Maybe Caps
-> IO Bool
elementLinkFiltered src sink filter =
liftM toBool $
(\(Element arg1) (Element arg2) (Caps arg3) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->withForeignPtr arg3 $ \argPtr3 ->gst_element_link_filtered argPtr1 argPtr2 argPtr3) (toElement src) (toElement sink) $
fromMaybe (Caps nullForeignPtr) filter
elementSetBaseTime :: ElementClass elementT
=> elementT
-> ClockTimeDiff
-> IO ()
elementSetBaseTime element time =
(\(Element arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_set_base_time argPtr1 arg2) (toElement element) $ fromIntegral time
elementGetBaseTime :: ElementClass elementT
=> elementT
-> IO ClockTimeDiff
elementGetBaseTime element =
liftM fromIntegral $ (\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_base_time argPtr1) (toElement element)
elementSetBus :: (ElementClass elementT, BusClass busT)
=> elementT
-> busT
-> IO ()
elementSetBus element bus =
(\(Element arg1) (Bus arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_set_bus argPtr1 argPtr2) (toElement element) (toBus bus)
elementGetBus :: ElementClass elementT
=> elementT
-> IO Bus
elementGetBus element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_bus argPtr1) (toElement element) >>= takeObject
elementGetFactory :: ElementClass elementT
=> elementT
-> IO ElementFactory
elementGetFactory element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_factory argPtr1) (toElement element) >>= peekObject
elementSetIndex :: (ElementClass elementT, IndexClass indexT)
=> elementT
-> indexT
-> IO ()
elementSetIndex element index =
(\(Element arg1) (Index arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_set_index argPtr1 argPtr2) (toElement element) (toIndex index)
elementGetIndex :: ElementClass elementT
=> elementT
-> IO (Maybe Index)
elementGetIndex element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_index argPtr1) (toElement element) >>= maybePeek takeObject
elementIsIndexable :: ElementClass elementT
=> elementT
-> IO Bool
elementIsIndexable element =
liftM toBool $ (\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_is_indexable argPtr1) (toElement element)
elementRequiresClock :: ElementClass elementT
=> elementT
-> IO Bool
elementRequiresClock element =
liftM toBool $ (\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_requires_clock argPtr1) (toElement element)
elementSetClock :: (ElementClass elementT, ClockClass clockT)
=> elementT
-> clockT
-> IO Bool
elementSetClock element clock =
liftM toBool $ (\(Element arg1) (Clock arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_set_clock argPtr1 argPtr2) (toElement element) (toClock clock)
elementGetClock :: ElementClass elementT
=> elementT
-> IO (Maybe Clock)
elementGetClock element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_clock argPtr1) (toElement element) >>= maybePeek takeObject
elementProvidesClock :: ElementClass elementT
=> elementT
-> IO Bool
elementProvidesClock element =
liftM toBool $ (\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_provides_clock argPtr1) $ toElement element
elementProvideClock :: ElementClass elementT
=> elementT
-> IO (Maybe Clock)
elementProvideClock element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_provide_clock argPtr1) (toElement element) >>= maybePeek takeObject
elementSetState :: ElementClass elementT
=> elementT
-> State
-> IO StateChangeReturn
elementSetState element state =
liftM (toEnum . fromIntegral) $ (\(Element arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_set_state argPtr1 arg2) (toElement element) $
fromIntegral $ fromEnum state
elementGetState :: ElementClass elementT
=> elementT
-> ClockTime
-> IO (StateChangeReturn, Maybe State, Maybe State)
elementGetState element timeout =
alloca $ \statePtr ->
alloca $ \pendingPtr ->
do poke statePtr (1)
poke pendingPtr (1)
result <- (\(Element arg1) arg2 arg3 arg4 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_state argPtr1 arg2 arg3 arg4) (toElement element)
statePtr
pendingPtr
(fromIntegral timeout)
state <- unmarshalState statePtr
pending <- unmarshalState pendingPtr
return (toEnum $ fromIntegral result, state, pending)
where unmarshalState statePtr = do
cState <- peek statePtr
if cState /= 1
then return $ Just $ toEnum $ fromIntegral cState
else return Nothing
elementSetLockedState :: ElementClass elementT
=> elementT
-> Bool
-> IO Bool
elementSetLockedState element lockedState =
liftM toBool $ (\(Element arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_set_locked_state argPtr1 arg2) (toElement element) $ fromBool lockedState
elementIsLockedState :: ElementClass elementT
=> elementT
-> IO Bool
elementIsLockedState element =
liftM toBool $ (\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_is_locked_state argPtr1) $ toElement element
elementAbortState :: ElementClass elementT
=> elementT
-> IO ()
elementAbortState element =
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_abort_state argPtr1) $ toElement element
elementStateGetName :: State
-> String
elementStateGetName state =
unsafePerformIO $ (gst_element_state_get_name $ fromIntegral $ fromEnum state) >>= peekUTFString
elementStateChangeReturnGetName :: StateChangeReturn
-> String
elementStateChangeReturnGetName stateRet =
unsafePerformIO $ (gst_element_state_change_return_get_name $ fromIntegral $ fromEnum stateRet) >>= peekUTFString
elementSyncStateWithParent :: ElementClass elementT
=> elementT
-> IO Bool
elementSyncStateWithParent element =
liftM toBool $ (\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_sync_state_with_parent argPtr1) $ toElement element
elementGetQueryTypes :: ElementClass element
=> element
-> IO [QueryType]
elementGetQueryTypes element =
liftM (map (toEnum . fromIntegral)) $
(\(Element arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_element_get_query_types argPtr1) (toElement element) >>=
peekArray0 0
elementQuery :: (ElementClass element, QueryClass query)
=> element
-> query
-> IO Bool
elementQuery element query =
do query' <- (\(MiniObject arg1) -> withForeignPtr arg1 $ \argPtr1 ->gst_mini_object_copy argPtr1) (toMiniObject query) >>=
newForeignPtr_ . castPtr
fmap toBool $ (\(Element arg1) (Query arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_query argPtr1 argPtr2) (toElement element) $ Query query'
elementQueryConvert :: ElementClass element
=> element
-> Format
-> Int64
-> Format
-> IO (Maybe (Format, Word64))
elementQueryConvert element srcFormat srcVal destFormat =
alloca $ \destFormatPtr ->
alloca $ \destValPtr ->
do poke destFormatPtr $ fromIntegral $ fromFormat destFormat
success <- (\(Element arg1) arg2 arg3 arg4 arg5 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_query_convert argPtr1 arg2 arg3 arg4 arg5) (toElement element)
(fromIntegral $ fromFormat srcFormat)
(fromIntegral srcVal)
destFormatPtr
destValPtr
if toBool success
then do destFormat <- peek destFormatPtr
destVal <- peek destValPtr
return $ Just (toFormat $ fromIntegral destFormat,
fromIntegral destVal)
else return Nothing
elementQueryPosition :: ElementClass element
=> element
-> Format
-> IO (Maybe (Format, Word64))
elementQueryPosition element format =
alloca $ \formatPtr ->
alloca $ \curPtr ->
do poke formatPtr $ fromIntegral $ fromFormat format
success <- (\(Element arg1) arg2 arg3 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_query_position argPtr1 arg2 arg3) (toElement element) formatPtr curPtr
if toBool success
then do format <- peek formatPtr
cur <- peek curPtr
return $ Just (toFormat $ fromIntegral format,
fromIntegral cur)
else return Nothing
elementQueryDuration :: ElementClass element
=> element
-> Format
-> IO (Maybe (Format, Word64))
elementQueryDuration element format =
alloca $ \formatPtr ->
alloca $ \durationPtr ->
do poke formatPtr $ fromIntegral $ fromFormat format
success <- (\(Element arg1) arg2 arg3 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_query_duration argPtr1 arg2 arg3) (toElement element) formatPtr durationPtr
if toBool success
then do format <- peek formatPtr
duration <- peek durationPtr
return $ Just (toFormat $ fromIntegral format,
fromIntegral duration)
else return Nothing
elementSendEvent :: (ElementClass element, EventClass event)
=> element
-> event
-> IO Bool
elementSendEvent element event =
liftM toBool $
giveMiniObject (toEvent event) $ (\(Element arg1) (Event arg2) -> withForeignPtr arg1 $ \argPtr1 ->withForeignPtr arg2 $ \argPtr2 ->gst_element_send_event argPtr1 argPtr2) (toElement element)
elementSeekSimple :: ElementClass element
=> element
-> Format
-> [SeekFlags]
-> Int64
-> IO Bool
elementSeekSimple element format seekFlags seekPos =
liftM toBool $
(\(Element arg1) arg2 arg3 arg4 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_seek_simple argPtr1 arg2 arg3 arg4) (toElement element)
(fromIntegral $ fromFormat format)
(fromIntegral $ fromFlags seekFlags)
(fromIntegral seekPos)
elementSeek :: ElementClass element
=> element
-> Double
-> Format
-> [SeekFlags]
-> SeekType
-> Int64
-> SeekType
-> Int64
-> IO Bool
elementSeek element rate format flags curType cur stopType stop =
liftM toBool $
(\(Element arg1) arg2 arg3 arg4 arg5 arg6 arg7 arg8 -> withForeignPtr arg1 $ \argPtr1 ->gst_element_seek argPtr1 arg2 arg3 arg4 arg5 arg6 arg7 arg8) (toElement element)
(realToFrac rate)
(fromIntegral $ fromFormat format)
(fromIntegral $ fromFlags flags)
(fromIntegral $ fromEnum curType)
(fromIntegral cur)
(fromIntegral $ fromEnum stopType)
(fromIntegral stop)
elementNoMorePads :: (ElementClass element)
=> Signal element (IO ())
elementNoMorePads =
Signal $ connect_NONE__NONE "no-more-pads"
elementPadAdded :: (ElementClass element)
=> Signal element (Pad -> IO ())
elementPadAdded =
Signal $ connect_OBJECT__NONE "pad-added"
elementPadRemoved :: (ElementClass element)
=> Signal element (Pad -> IO ())
elementPadRemoved =
Signal $ connect_OBJECT__NONE "pad-removed"
foreign import ccall safe "gst_element_add_pad"
gst_element_add_pad :: ((Ptr Element) -> ((Ptr Pad) -> (IO CInt)))
foreign import ccall safe "gst_element_get_compatible_pad"
gst_element_get_compatible_pad :: ((Ptr Element) -> ((Ptr Pad) -> ((Ptr Caps) -> (IO (Ptr Pad)))))
foreign import ccall safe "gst_element_get_compatible_pad_template"
gst_element_get_compatible_pad_template :: ((Ptr Element) -> ((Ptr PadTemplate) -> (IO (Ptr PadTemplate))))
foreign import ccall safe "gst_element_get_request_pad"
gst_element_get_request_pad :: ((Ptr Element) -> ((Ptr CChar) -> (IO (Ptr Pad))))
foreign import ccall safe "gst_element_get_static_pad"
gst_element_get_static_pad :: ((Ptr Element) -> ((Ptr CChar) -> (IO (Ptr Pad))))
foreign import ccall safe "gst_element_release_request_pad"
gst_element_release_request_pad :: ((Ptr Element) -> ((Ptr Pad) -> (IO ())))
foreign import ccall safe "gst_element_remove_pad"
gst_element_remove_pad :: ((Ptr Element) -> ((Ptr Pad) -> (IO CInt)))
foreign import ccall safe "gst_element_iterate_pads"
gst_element_iterate_pads :: ((Ptr Element) -> (IO (Ptr PtrIterator)))
foreign import ccall safe "gst_element_iterate_sink_pads"
gst_element_iterate_sink_pads :: ((Ptr Element) -> (IO (Ptr PtrIterator)))
foreign import ccall safe "gst_element_link"
gst_element_link :: ((Ptr Element) -> ((Ptr Element) -> (IO CInt)))
foreign import ccall safe "gst_element_unlink"
gst_element_unlink :: ((Ptr Element) -> ((Ptr Element) -> (IO ())))
foreign import ccall safe "gst_element_link_pads"
gst_element_link_pads :: ((Ptr Element) -> ((Ptr CChar) -> ((Ptr Element) -> ((Ptr CChar) -> (IO CInt)))))
foreign import ccall safe "gst_element_unlink_pads"
gst_element_unlink_pads :: ((Ptr Element) -> ((Ptr CChar) -> ((Ptr Element) -> ((Ptr CChar) -> (IO ())))))
foreign import ccall safe "gst_element_link_pads_filtered"
gst_element_link_pads_filtered :: ((Ptr Element) -> ((Ptr CChar) -> ((Ptr Element) -> ((Ptr CChar) -> ((Ptr Caps) -> (IO CInt))))))
foreign import ccall safe "gst_element_link_filtered"
gst_element_link_filtered :: ((Ptr Element) -> ((Ptr Element) -> ((Ptr Caps) -> (IO CInt))))
foreign import ccall safe "gst_element_set_base_time"
gst_element_set_base_time :: ((Ptr Element) -> (CULLong -> (IO ())))
foreign import ccall safe "gst_element_get_base_time"
gst_element_get_base_time :: ((Ptr Element) -> (IO CULLong))
foreign import ccall safe "gst_element_set_bus"
gst_element_set_bus :: ((Ptr Element) -> ((Ptr Bus) -> (IO ())))
foreign import ccall safe "gst_element_get_bus"
gst_element_get_bus :: ((Ptr Element) -> (IO (Ptr Bus)))
foreign import ccall safe "gst_element_get_factory"
gst_element_get_factory :: ((Ptr Element) -> (IO (Ptr ElementFactory)))
foreign import ccall safe "gst_element_set_index"
gst_element_set_index :: ((Ptr Element) -> ((Ptr Index) -> (IO ())))
foreign import ccall safe "gst_element_get_index"
gst_element_get_index :: ((Ptr Element) -> (IO (Ptr Index)))
foreign import ccall safe "gst_element_is_indexable"
gst_element_is_indexable :: ((Ptr Element) -> (IO CInt))
foreign import ccall safe "gst_element_requires_clock"
gst_element_requires_clock :: ((Ptr Element) -> (IO CInt))
foreign import ccall safe "gst_element_set_clock"
gst_element_set_clock :: ((Ptr Element) -> ((Ptr Clock) -> (IO CInt)))
foreign import ccall safe "gst_element_get_clock"
gst_element_get_clock :: ((Ptr Element) -> (IO (Ptr Clock)))
foreign import ccall safe "gst_element_provides_clock"
gst_element_provides_clock :: ((Ptr Element) -> (IO CInt))
foreign import ccall safe "gst_element_provide_clock"
gst_element_provide_clock :: ((Ptr Element) -> (IO (Ptr Clock)))
foreign import ccall safe "gst_element_set_state"
gst_element_set_state :: ((Ptr Element) -> (CInt -> (IO CInt)))
foreign import ccall safe "gst_element_get_state"
gst_element_get_state :: ((Ptr Element) -> ((Ptr CInt) -> ((Ptr CInt) -> (CULLong -> (IO CInt)))))
foreign import ccall safe "gst_element_set_locked_state"
gst_element_set_locked_state :: ((Ptr Element) -> (CInt -> (IO CInt)))
foreign import ccall safe "gst_element_is_locked_state"
gst_element_is_locked_state :: ((Ptr Element) -> (IO CInt))
foreign import ccall safe "gst_element_abort_state"
gst_element_abort_state :: ((Ptr Element) -> (IO ()))
foreign import ccall safe "gst_element_state_get_name"
gst_element_state_get_name :: (CInt -> (IO (Ptr CChar)))
foreign import ccall safe "gst_element_state_change_return_get_name"
gst_element_state_change_return_get_name :: (CInt -> (IO (Ptr CChar)))
foreign import ccall safe "gst_element_sync_state_with_parent"
gst_element_sync_state_with_parent :: ((Ptr Element) -> (IO CInt))
foreign import ccall safe "gst_element_get_query_types"
gst_element_get_query_types :: ((Ptr Element) -> (IO (Ptr CInt)))
foreign import ccall safe "gst_mini_object_copy"
gst_mini_object_copy :: ((Ptr MiniObject) -> (IO (Ptr MiniObject)))
foreign import ccall safe "gst_element_query"
gst_element_query :: ((Ptr Element) -> ((Ptr Query) -> (IO CInt)))
foreign import ccall safe "gst_element_query_convert"
gst_element_query_convert :: ((Ptr Element) -> (CInt -> (CLLong -> ((Ptr CInt) -> ((Ptr CLLong) -> (IO CInt))))))
foreign import ccall safe "gst_element_query_position"
gst_element_query_position :: ((Ptr Element) -> ((Ptr CInt) -> ((Ptr CLLong) -> (IO CInt))))
foreign import ccall safe "gst_element_query_duration"
gst_element_query_duration :: ((Ptr Element) -> ((Ptr CInt) -> ((Ptr CLLong) -> (IO CInt))))
foreign import ccall safe "gst_element_send_event"
gst_element_send_event :: ((Ptr Element) -> ((Ptr Event) -> (IO CInt)))
foreign import ccall safe "gst_element_seek_simple"
gst_element_seek_simple :: ((Ptr Element) -> (CInt -> (CInt -> (CLLong -> (IO CInt)))))
foreign import ccall safe "gst_element_seek"
gst_element_seek :: ((Ptr Element) -> (CDouble -> (CInt -> (CInt -> (CInt -> (CLLong -> (CInt -> (CLLong -> (IO CInt)))))))))