#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.GstVideo.Objects.VideoEncoder
(
VideoEncoder(..) ,
IsVideoEncoder ,
toVideoEncoder ,
noVideoEncoder ,
#if ENABLE_OVERLOADING
VideoEncoderAllocateOutputBufferMethodInfo,
#endif
videoEncoderAllocateOutputBuffer ,
#if ENABLE_OVERLOADING
VideoEncoderAllocateOutputFrameMethodInfo,
#endif
videoEncoderAllocateOutputFrame ,
#if ENABLE_OVERLOADING
VideoEncoderFinishFrameMethodInfo ,
#endif
videoEncoderFinishFrame ,
#if ENABLE_OVERLOADING
VideoEncoderGetAllocatorMethodInfo ,
#endif
videoEncoderGetAllocator ,
#if ENABLE_OVERLOADING
VideoEncoderGetFrameMethodInfo ,
#endif
videoEncoderGetFrame ,
#if ENABLE_OVERLOADING
VideoEncoderGetFramesMethodInfo ,
#endif
videoEncoderGetFrames ,
#if ENABLE_OVERLOADING
VideoEncoderGetLatencyMethodInfo ,
#endif
videoEncoderGetLatency ,
#if ENABLE_OVERLOADING
VideoEncoderGetMaxEncodeTimeMethodInfo ,
#endif
videoEncoderGetMaxEncodeTime ,
#if ENABLE_OVERLOADING
VideoEncoderGetOldestFrameMethodInfo ,
#endif
videoEncoderGetOldestFrame ,
#if ENABLE_OVERLOADING
VideoEncoderGetOutputStateMethodInfo ,
#endif
videoEncoderGetOutputState ,
#if ENABLE_OVERLOADING
VideoEncoderIsQosEnabledMethodInfo ,
#endif
videoEncoderIsQosEnabled ,
#if ENABLE_OVERLOADING
VideoEncoderMergeTagsMethodInfo ,
#endif
videoEncoderMergeTags ,
#if ENABLE_OVERLOADING
VideoEncoderNegotiateMethodInfo ,
#endif
videoEncoderNegotiate ,
#if ENABLE_OVERLOADING
VideoEncoderProxyGetcapsMethodInfo ,
#endif
videoEncoderProxyGetcaps ,
#if ENABLE_OVERLOADING
VideoEncoderSetHeadersMethodInfo ,
#endif
videoEncoderSetHeaders ,
#if ENABLE_OVERLOADING
VideoEncoderSetLatencyMethodInfo ,
#endif
videoEncoderSetLatency ,
#if ENABLE_OVERLOADING
VideoEncoderSetMinPtsMethodInfo ,
#endif
videoEncoderSetMinPts ,
#if ENABLE_OVERLOADING
VideoEncoderSetOutputStateMethodInfo ,
#endif
videoEncoderSetOutputState ,
#if ENABLE_OVERLOADING
VideoEncoderSetQosEnabledMethodInfo ,
#endif
videoEncoderSetQosEnabled ,
#if ENABLE_OVERLOADING
VideoEncoderQosPropertyInfo ,
#endif
constructVideoEncoderQos ,
getVideoEncoderQos ,
setVideoEncoderQos ,
#if ENABLE_OVERLOADING
videoEncoderQos ,
#endif
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Enums as Gst.Enums
import qualified GI.Gst.Interfaces.Preset as Gst.Preset
import qualified GI.Gst.Objects.Allocator as Gst.Allocator
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.Caps as Gst.Caps
import qualified GI.Gst.Structs.TagList as Gst.TagList
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoCodecFrame as GstVideo.VideoCodecFrame
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoCodecState as GstVideo.VideoCodecState
newtype VideoEncoder = VideoEncoder (ManagedPtr VideoEncoder)
foreign import ccall "gst_video_encoder_get_type"
c_gst_video_encoder_get_type :: IO GType
instance GObject VideoEncoder where
gobjectType = c_gst_video_encoder_get_type
class (GObject o, O.IsDescendantOf VideoEncoder o) => IsVideoEncoder o
instance (GObject o, O.IsDescendantOf VideoEncoder o) => IsVideoEncoder o
instance O.HasParentTypes VideoEncoder
type instance O.ParentTypes VideoEncoder = '[Gst.Element.Element, Gst.Object.Object, GObject.Object.Object, Gst.Preset.Preset]
toVideoEncoder :: (MonadIO m, IsVideoEncoder o) => o -> m VideoEncoder
toVideoEncoder = liftIO . unsafeCastTo VideoEncoder
noVideoEncoder :: Maybe VideoEncoder
noVideoEncoder = Nothing
#if ENABLE_OVERLOADING
type family ResolveVideoEncoderMethod (t :: Symbol) (o :: *) :: * where
ResolveVideoEncoderMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo
ResolveVideoEncoderMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveVideoEncoderMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo
ResolveVideoEncoderMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo
ResolveVideoEncoderMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo
ResolveVideoEncoderMethod "allocateOutputBuffer" o = VideoEncoderAllocateOutputBufferMethodInfo
ResolveVideoEncoderMethod "allocateOutputFrame" o = VideoEncoderAllocateOutputFrameMethodInfo
ResolveVideoEncoderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveVideoEncoderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveVideoEncoderMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo
ResolveVideoEncoderMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo
ResolveVideoEncoderMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo
ResolveVideoEncoderMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo
ResolveVideoEncoderMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveVideoEncoderMethod "deletePreset" o = Gst.Preset.PresetDeletePresetMethodInfo
ResolveVideoEncoderMethod "finishFrame" o = VideoEncoderFinishFrameMethodInfo
ResolveVideoEncoderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveVideoEncoderMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo
ResolveVideoEncoderMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo
ResolveVideoEncoderMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo
ResolveVideoEncoderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveVideoEncoderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveVideoEncoderMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveVideoEncoderMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveVideoEncoderMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveVideoEncoderMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveVideoEncoderMethod "isEditable" o = Gst.Preset.PresetIsEditableMethodInfo
ResolveVideoEncoderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveVideoEncoderMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo
ResolveVideoEncoderMethod "isQosEnabled" o = VideoEncoderIsQosEnabledMethodInfo
ResolveVideoEncoderMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo
ResolveVideoEncoderMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo
ResolveVideoEncoderMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo
ResolveVideoEncoderMethod "link" o = Gst.Element.ElementLinkMethodInfo
ResolveVideoEncoderMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo
ResolveVideoEncoderMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo
ResolveVideoEncoderMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo
ResolveVideoEncoderMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo
ResolveVideoEncoderMethod "loadPreset" o = Gst.Preset.PresetLoadPresetMethodInfo
ResolveVideoEncoderMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo
ResolveVideoEncoderMethod "mergeTags" o = VideoEncoderMergeTagsMethodInfo
ResolveVideoEncoderMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo
ResolveVideoEncoderMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo
ResolveVideoEncoderMethod "negotiate" o = VideoEncoderNegotiateMethodInfo
ResolveVideoEncoderMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo
ResolveVideoEncoderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveVideoEncoderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveVideoEncoderMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo
ResolveVideoEncoderMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo
ResolveVideoEncoderMethod "proxyGetcaps" o = VideoEncoderProxyGetcapsMethodInfo
ResolveVideoEncoderMethod "query" o = Gst.Element.ElementQueryMethodInfo
ResolveVideoEncoderMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo
ResolveVideoEncoderMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo
ResolveVideoEncoderMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo
ResolveVideoEncoderMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveVideoEncoderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveVideoEncoderMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo
ResolveVideoEncoderMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveVideoEncoderMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo
ResolveVideoEncoderMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo
ResolveVideoEncoderMethod "renamePreset" o = Gst.Preset.PresetRenamePresetMethodInfo
ResolveVideoEncoderMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo
ResolveVideoEncoderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveVideoEncoderMethod "savePreset" o = Gst.Preset.PresetSavePresetMethodInfo
ResolveVideoEncoderMethod "seek" o = Gst.Element.ElementSeekMethodInfo
ResolveVideoEncoderMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo
ResolveVideoEncoderMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo
ResolveVideoEncoderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveVideoEncoderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveVideoEncoderMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveVideoEncoderMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo
ResolveVideoEncoderMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveVideoEncoderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveVideoEncoderMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo
ResolveVideoEncoderMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo
ResolveVideoEncoderMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveVideoEncoderMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveVideoEncoderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveVideoEncoderMethod "getAllocator" o = VideoEncoderGetAllocatorMethodInfo
ResolveVideoEncoderMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo
ResolveVideoEncoderMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo
ResolveVideoEncoderMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo
ResolveVideoEncoderMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo
ResolveVideoEncoderMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo
ResolveVideoEncoderMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo
ResolveVideoEncoderMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo
ResolveVideoEncoderMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo
ResolveVideoEncoderMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveVideoEncoderMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveVideoEncoderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveVideoEncoderMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo
ResolveVideoEncoderMethod "getFrame" o = VideoEncoderGetFrameMethodInfo
ResolveVideoEncoderMethod "getFrames" o = VideoEncoderGetFramesMethodInfo
ResolveVideoEncoderMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveVideoEncoderMethod "getLatency" o = VideoEncoderGetLatencyMethodInfo
ResolveVideoEncoderMethod "getMaxEncodeTime" o = VideoEncoderGetMaxEncodeTimeMethodInfo
ResolveVideoEncoderMethod "getMeta" o = Gst.Preset.PresetGetMetaMethodInfo
ResolveVideoEncoderMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo
ResolveVideoEncoderMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveVideoEncoderMethod "getOldestFrame" o = VideoEncoderGetOldestFrameMethodInfo
ResolveVideoEncoderMethod "getOutputState" o = VideoEncoderGetOutputStateMethodInfo
ResolveVideoEncoderMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo
ResolveVideoEncoderMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo
ResolveVideoEncoderMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveVideoEncoderMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveVideoEncoderMethod "getPresetNames" o = Gst.Preset.PresetGetPresetNamesMethodInfo
ResolveVideoEncoderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveVideoEncoderMethod "getPropertyNames" o = Gst.Preset.PresetGetPropertyNamesMethodInfo
ResolveVideoEncoderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveVideoEncoderMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo
ResolveVideoEncoderMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo
ResolveVideoEncoderMethod "getState" o = Gst.Element.ElementGetStateMethodInfo
ResolveVideoEncoderMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo
ResolveVideoEncoderMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveVideoEncoderMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo
ResolveVideoEncoderMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo
ResolveVideoEncoderMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo
ResolveVideoEncoderMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo
ResolveVideoEncoderMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveVideoEncoderMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveVideoEncoderMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveVideoEncoderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveVideoEncoderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveVideoEncoderMethod "setHeaders" o = VideoEncoderSetHeadersMethodInfo
ResolveVideoEncoderMethod "setLatency" o = VideoEncoderSetLatencyMethodInfo
ResolveVideoEncoderMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo
ResolveVideoEncoderMethod "setMeta" o = Gst.Preset.PresetSetMetaMethodInfo
ResolveVideoEncoderMethod "setMinPts" o = VideoEncoderSetMinPtsMethodInfo
ResolveVideoEncoderMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveVideoEncoderMethod "setOutputState" o = VideoEncoderSetOutputStateMethodInfo
ResolveVideoEncoderMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveVideoEncoderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveVideoEncoderMethod "setQosEnabled" o = VideoEncoderSetQosEnabledMethodInfo
ResolveVideoEncoderMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo
ResolveVideoEncoderMethod "setState" o = Gst.Element.ElementSetStateMethodInfo
ResolveVideoEncoderMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveVideoEncoderMethod t VideoEncoder, O.MethodInfo info VideoEncoder p) => OL.IsLabel t (VideoEncoder -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
getVideoEncoderQos :: (MonadIO m, IsVideoEncoder o) => o -> m Bool
getVideoEncoderQos obj = liftIO $ B.Properties.getObjectPropertyBool obj "qos"
setVideoEncoderQos :: (MonadIO m, IsVideoEncoder o) => o -> Bool -> m ()
setVideoEncoderQos obj val = liftIO $ B.Properties.setObjectPropertyBool obj "qos" val
constructVideoEncoderQos :: (IsVideoEncoder o) => Bool -> IO (GValueConstruct o)
constructVideoEncoderQos val = B.Properties.constructObjectPropertyBool "qos" val
#if ENABLE_OVERLOADING
data VideoEncoderQosPropertyInfo
instance AttrInfo VideoEncoderQosPropertyInfo where
type AttrAllowedOps VideoEncoderQosPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint VideoEncoderQosPropertyInfo = (~) Bool
type AttrBaseTypeConstraint VideoEncoderQosPropertyInfo = IsVideoEncoder
type AttrGetType VideoEncoderQosPropertyInfo = Bool
type AttrLabel VideoEncoderQosPropertyInfo = "qos"
type AttrOrigin VideoEncoderQosPropertyInfo = VideoEncoder
attrGet _ = getVideoEncoderQos
attrSet _ = setVideoEncoderQos
attrConstruct _ = constructVideoEncoderQos
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList VideoEncoder
type instance O.AttributeList VideoEncoder = VideoEncoderAttributeList
type VideoEncoderAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("qos", VideoEncoderQosPropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
videoEncoderQos :: AttrLabelProxy "qos"
videoEncoderQos = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
type instance O.SignalList VideoEncoder = VideoEncoderSignalList
type VideoEncoderSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_video_encoder_allocate_output_buffer" gst_video_encoder_allocate_output_buffer ::
Ptr VideoEncoder ->
Word64 ->
IO (Ptr Gst.Buffer.Buffer)
videoEncoderAllocateOutputBuffer ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> Word64
-> m Gst.Buffer.Buffer
videoEncoderAllocateOutputBuffer encoder size = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
result <- gst_video_encoder_allocate_output_buffer encoder' size
checkUnexpectedReturnNULL "videoEncoderAllocateOutputBuffer" result
result' <- (wrapBoxed Gst.Buffer.Buffer) result
touchManagedPtr encoder
return result'
#if ENABLE_OVERLOADING
data VideoEncoderAllocateOutputBufferMethodInfo
instance (signature ~ (Word64 -> m Gst.Buffer.Buffer), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderAllocateOutputBufferMethodInfo a signature where
overloadedMethod _ = videoEncoderAllocateOutputBuffer
#endif
foreign import ccall "gst_video_encoder_allocate_output_frame" gst_video_encoder_allocate_output_frame ::
Ptr VideoEncoder ->
Ptr GstVideo.VideoCodecFrame.VideoCodecFrame ->
Word64 ->
IO CInt
videoEncoderAllocateOutputFrame ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> GstVideo.VideoCodecFrame.VideoCodecFrame
-> Word64
-> m Gst.Enums.FlowReturn
videoEncoderAllocateOutputFrame encoder frame size = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
frame' <- unsafeManagedPtrGetPtr frame
result <- gst_video_encoder_allocate_output_frame encoder' frame' size
let result' = (toEnum . fromIntegral) result
touchManagedPtr encoder
touchManagedPtr frame
return result'
#if ENABLE_OVERLOADING
data VideoEncoderAllocateOutputFrameMethodInfo
instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> Word64 -> m Gst.Enums.FlowReturn), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderAllocateOutputFrameMethodInfo a signature where
overloadedMethod _ = videoEncoderAllocateOutputFrame
#endif
foreign import ccall "gst_video_encoder_finish_frame" gst_video_encoder_finish_frame ::
Ptr VideoEncoder ->
Ptr GstVideo.VideoCodecFrame.VideoCodecFrame ->
IO CInt
videoEncoderFinishFrame ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> GstVideo.VideoCodecFrame.VideoCodecFrame
-> m Gst.Enums.FlowReturn
videoEncoderFinishFrame encoder frame = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
frame' <- B.ManagedPtr.disownBoxed frame
result <- gst_video_encoder_finish_frame encoder' frame'
let result' = (toEnum . fromIntegral) result
touchManagedPtr encoder
touchManagedPtr frame
return result'
#if ENABLE_OVERLOADING
data VideoEncoderFinishFrameMethodInfo
instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m Gst.Enums.FlowReturn), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderFinishFrameMethodInfo a signature where
overloadedMethod _ = videoEncoderFinishFrame
#endif
foreign import ccall "gst_video_encoder_get_allocator" gst_video_encoder_get_allocator ::
Ptr VideoEncoder ->
Ptr (Ptr Gst.Allocator.Allocator) ->
Ptr Gst.AllocationParams.AllocationParams ->
IO ()
videoEncoderGetAllocator ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> m ((Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams))
videoEncoderGetAllocator encoder = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator.Allocator))
params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams.AllocationParams)
gst_video_encoder_get_allocator encoder' allocator params
allocator' <- peek allocator
allocator'' <- (wrapObject Gst.Allocator.Allocator) allocator'
params' <- (wrapBoxed Gst.AllocationParams.AllocationParams) params
touchManagedPtr encoder
freeMem allocator
return (allocator'', params')
#if ENABLE_OVERLOADING
data VideoEncoderGetAllocatorMethodInfo
instance (signature ~ (m ((Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams))), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetAllocatorMethodInfo a signature where
overloadedMethod _ = videoEncoderGetAllocator
#endif
foreign import ccall "gst_video_encoder_get_frame" gst_video_encoder_get_frame ::
Ptr VideoEncoder ->
Int32 ->
IO (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame)
videoEncoderGetFrame ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> Int32
-> m GstVideo.VideoCodecFrame.VideoCodecFrame
videoEncoderGetFrame encoder frameNumber = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
result <- gst_video_encoder_get_frame encoder' frameNumber
checkUnexpectedReturnNULL "videoEncoderGetFrame" result
result' <- (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result
touchManagedPtr encoder
return result'
#if ENABLE_OVERLOADING
data VideoEncoderGetFrameMethodInfo
instance (signature ~ (Int32 -> m GstVideo.VideoCodecFrame.VideoCodecFrame), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetFrameMethodInfo a signature where
overloadedMethod _ = videoEncoderGetFrame
#endif
foreign import ccall "gst_video_encoder_get_frames" gst_video_encoder_get_frames ::
Ptr VideoEncoder ->
IO (Ptr (GList (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame)))
videoEncoderGetFrames ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> m [GstVideo.VideoCodecFrame.VideoCodecFrame]
videoEncoderGetFrames encoder = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
result <- gst_video_encoder_get_frames encoder'
result' <- unpackGList result
result'' <- mapM (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result'
g_list_free result
touchManagedPtr encoder
return result''
#if ENABLE_OVERLOADING
data VideoEncoderGetFramesMethodInfo
instance (signature ~ (m [GstVideo.VideoCodecFrame.VideoCodecFrame]), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetFramesMethodInfo a signature where
overloadedMethod _ = videoEncoderGetFrames
#endif
foreign import ccall "gst_video_encoder_get_latency" gst_video_encoder_get_latency ::
Ptr VideoEncoder ->
Ptr Word64 ->
Ptr Word64 ->
IO ()
videoEncoderGetLatency ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> m ((Word64, Word64))
videoEncoderGetLatency encoder = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
minLatency <- allocMem :: IO (Ptr Word64)
maxLatency <- allocMem :: IO (Ptr Word64)
gst_video_encoder_get_latency encoder' minLatency maxLatency
minLatency' <- peek minLatency
maxLatency' <- peek maxLatency
touchManagedPtr encoder
freeMem minLatency
freeMem maxLatency
return (minLatency', maxLatency')
#if ENABLE_OVERLOADING
data VideoEncoderGetLatencyMethodInfo
instance (signature ~ (m ((Word64, Word64))), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetLatencyMethodInfo a signature where
overloadedMethod _ = videoEncoderGetLatency
#endif
foreign import ccall "gst_video_encoder_get_max_encode_time" gst_video_encoder_get_max_encode_time ::
Ptr VideoEncoder ->
Ptr GstVideo.VideoCodecFrame.VideoCodecFrame ->
IO Int64
videoEncoderGetMaxEncodeTime ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> GstVideo.VideoCodecFrame.VideoCodecFrame
-> m Int64
videoEncoderGetMaxEncodeTime encoder frame = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
frame' <- unsafeManagedPtrGetPtr frame
result <- gst_video_encoder_get_max_encode_time encoder' frame'
touchManagedPtr encoder
touchManagedPtr frame
return result
#if ENABLE_OVERLOADING
data VideoEncoderGetMaxEncodeTimeMethodInfo
instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m Int64), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetMaxEncodeTimeMethodInfo a signature where
overloadedMethod _ = videoEncoderGetMaxEncodeTime
#endif
foreign import ccall "gst_video_encoder_get_oldest_frame" gst_video_encoder_get_oldest_frame ::
Ptr VideoEncoder ->
IO (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame)
videoEncoderGetOldestFrame ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> m GstVideo.VideoCodecFrame.VideoCodecFrame
videoEncoderGetOldestFrame encoder = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
result <- gst_video_encoder_get_oldest_frame encoder'
checkUnexpectedReturnNULL "videoEncoderGetOldestFrame" result
result' <- (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result
touchManagedPtr encoder
return result'
#if ENABLE_OVERLOADING
data VideoEncoderGetOldestFrameMethodInfo
instance (signature ~ (m GstVideo.VideoCodecFrame.VideoCodecFrame), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetOldestFrameMethodInfo a signature where
overloadedMethod _ = videoEncoderGetOldestFrame
#endif
foreign import ccall "gst_video_encoder_get_output_state" gst_video_encoder_get_output_state ::
Ptr VideoEncoder ->
IO (Ptr GstVideo.VideoCodecState.VideoCodecState)
videoEncoderGetOutputState ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> m GstVideo.VideoCodecState.VideoCodecState
videoEncoderGetOutputState encoder = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
result <- gst_video_encoder_get_output_state encoder'
checkUnexpectedReturnNULL "videoEncoderGetOutputState" result
result' <- (wrapBoxed GstVideo.VideoCodecState.VideoCodecState) result
touchManagedPtr encoder
return result'
#if ENABLE_OVERLOADING
data VideoEncoderGetOutputStateMethodInfo
instance (signature ~ (m GstVideo.VideoCodecState.VideoCodecState), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetOutputStateMethodInfo a signature where
overloadedMethod _ = videoEncoderGetOutputState
#endif
foreign import ccall "gst_video_encoder_is_qos_enabled" gst_video_encoder_is_qos_enabled ::
Ptr VideoEncoder ->
IO CInt
videoEncoderIsQosEnabled ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> m Bool
videoEncoderIsQosEnabled encoder = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
result <- gst_video_encoder_is_qos_enabled encoder'
let result' = (/= 0) result
touchManagedPtr encoder
return result'
#if ENABLE_OVERLOADING
data VideoEncoderIsQosEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderIsQosEnabledMethodInfo a signature where
overloadedMethod _ = videoEncoderIsQosEnabled
#endif
foreign import ccall "gst_video_encoder_merge_tags" gst_video_encoder_merge_tags ::
Ptr VideoEncoder ->
Ptr Gst.TagList.TagList ->
CUInt ->
IO ()
videoEncoderMergeTags ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> Maybe (Gst.TagList.TagList)
-> Gst.Enums.TagMergeMode
-> m ()
videoEncoderMergeTags encoder tags mode = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
maybeTags <- case tags of
Nothing -> return nullPtr
Just jTags -> do
jTags' <- unsafeManagedPtrGetPtr jTags
return jTags'
let mode' = (fromIntegral . fromEnum) mode
gst_video_encoder_merge_tags encoder' maybeTags mode'
touchManagedPtr encoder
whenJust tags touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data VideoEncoderMergeTagsMethodInfo
instance (signature ~ (Maybe (Gst.TagList.TagList) -> Gst.Enums.TagMergeMode -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderMergeTagsMethodInfo a signature where
overloadedMethod _ = videoEncoderMergeTags
#endif
foreign import ccall "gst_video_encoder_negotiate" gst_video_encoder_negotiate ::
Ptr VideoEncoder ->
IO CInt
videoEncoderNegotiate ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> m Bool
videoEncoderNegotiate encoder = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
result <- gst_video_encoder_negotiate encoder'
let result' = (/= 0) result
touchManagedPtr encoder
return result'
#if ENABLE_OVERLOADING
data VideoEncoderNegotiateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderNegotiateMethodInfo a signature where
overloadedMethod _ = videoEncoderNegotiate
#endif
foreign import ccall "gst_video_encoder_proxy_getcaps" gst_video_encoder_proxy_getcaps ::
Ptr VideoEncoder ->
Ptr Gst.Caps.Caps ->
Ptr Gst.Caps.Caps ->
IO (Ptr Gst.Caps.Caps)
videoEncoderProxyGetcaps ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> Maybe (Gst.Caps.Caps)
-> Maybe (Gst.Caps.Caps)
-> m Gst.Caps.Caps
videoEncoderProxyGetcaps enc caps filter = liftIO $ do
enc' <- unsafeManagedPtrCastPtr enc
maybeCaps <- case caps of
Nothing -> return nullPtr
Just jCaps -> do
jCaps' <- unsafeManagedPtrGetPtr jCaps
return jCaps'
maybeFilter <- case filter of
Nothing -> return nullPtr
Just jFilter -> do
jFilter' <- unsafeManagedPtrGetPtr jFilter
return jFilter'
result <- gst_video_encoder_proxy_getcaps enc' maybeCaps maybeFilter
checkUnexpectedReturnNULL "videoEncoderProxyGetcaps" result
result' <- (wrapBoxed Gst.Caps.Caps) result
touchManagedPtr enc
whenJust caps touchManagedPtr
whenJust filter touchManagedPtr
return result'
#if ENABLE_OVERLOADING
data VideoEncoderProxyGetcapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> Maybe (Gst.Caps.Caps) -> m Gst.Caps.Caps), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderProxyGetcapsMethodInfo a signature where
overloadedMethod _ = videoEncoderProxyGetcaps
#endif
foreign import ccall "gst_video_encoder_set_headers" gst_video_encoder_set_headers ::
Ptr VideoEncoder ->
Ptr (GList (Ptr Gst.Buffer.Buffer)) ->
IO ()
videoEncoderSetHeaders ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> [Gst.Buffer.Buffer]
-> m ()
videoEncoderSetHeaders encoder headers = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
headers' <- mapM B.ManagedPtr.disownBoxed headers
headers'' <- packGList headers'
gst_video_encoder_set_headers encoder' headers''
touchManagedPtr encoder
mapM_ touchManagedPtr headers
return ()
#if ENABLE_OVERLOADING
data VideoEncoderSetHeadersMethodInfo
instance (signature ~ ([Gst.Buffer.Buffer] -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetHeadersMethodInfo a signature where
overloadedMethod _ = videoEncoderSetHeaders
#endif
foreign import ccall "gst_video_encoder_set_latency" gst_video_encoder_set_latency ::
Ptr VideoEncoder ->
Word64 ->
Word64 ->
IO ()
videoEncoderSetLatency ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> Word64
-> Word64
-> m ()
videoEncoderSetLatency encoder minLatency maxLatency = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
gst_video_encoder_set_latency encoder' minLatency maxLatency
touchManagedPtr encoder
return ()
#if ENABLE_OVERLOADING
data VideoEncoderSetLatencyMethodInfo
instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetLatencyMethodInfo a signature where
overloadedMethod _ = videoEncoderSetLatency
#endif
foreign import ccall "gst_video_encoder_set_min_pts" gst_video_encoder_set_min_pts ::
Ptr VideoEncoder ->
Word64 ->
IO ()
videoEncoderSetMinPts ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> Word64
-> m ()
videoEncoderSetMinPts encoder minPts = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
gst_video_encoder_set_min_pts encoder' minPts
touchManagedPtr encoder
return ()
#if ENABLE_OVERLOADING
data VideoEncoderSetMinPtsMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetMinPtsMethodInfo a signature where
overloadedMethod _ = videoEncoderSetMinPts
#endif
foreign import ccall "gst_video_encoder_set_output_state" gst_video_encoder_set_output_state ::
Ptr VideoEncoder ->
Ptr Gst.Caps.Caps ->
Ptr GstVideo.VideoCodecState.VideoCodecState ->
IO (Ptr GstVideo.VideoCodecState.VideoCodecState)
videoEncoderSetOutputState ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> Gst.Caps.Caps
-> Maybe (GstVideo.VideoCodecState.VideoCodecState)
-> m GstVideo.VideoCodecState.VideoCodecState
videoEncoderSetOutputState encoder caps reference = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
caps' <- B.ManagedPtr.disownBoxed caps
maybeReference <- case reference of
Nothing -> return nullPtr
Just jReference -> do
jReference' <- unsafeManagedPtrGetPtr jReference
return jReference'
result <- gst_video_encoder_set_output_state encoder' caps' maybeReference
checkUnexpectedReturnNULL "videoEncoderSetOutputState" result
result' <- (wrapBoxed GstVideo.VideoCodecState.VideoCodecState) result
touchManagedPtr encoder
touchManagedPtr caps
whenJust reference touchManagedPtr
return result'
#if ENABLE_OVERLOADING
data VideoEncoderSetOutputStateMethodInfo
instance (signature ~ (Gst.Caps.Caps -> Maybe (GstVideo.VideoCodecState.VideoCodecState) -> m GstVideo.VideoCodecState.VideoCodecState), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetOutputStateMethodInfo a signature where
overloadedMethod _ = videoEncoderSetOutputState
#endif
foreign import ccall "gst_video_encoder_set_qos_enabled" gst_video_encoder_set_qos_enabled ::
Ptr VideoEncoder ->
CInt ->
IO ()
videoEncoderSetQosEnabled ::
(B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) =>
a
-> Bool
-> m ()
videoEncoderSetQosEnabled encoder enabled = liftIO $ do
encoder' <- unsafeManagedPtrCastPtr encoder
let enabled' = (fromIntegral . fromEnum) enabled
gst_video_encoder_set_qos_enabled encoder' enabled'
touchManagedPtr encoder
return ()
#if ENABLE_OVERLOADING
data VideoEncoderSetQosEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetQosEnabledMethodInfo a signature where
overloadedMethod _ = videoEncoderSetQosEnabled
#endif