-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.GstPbutils.Callbacks
    ( 

 -- * Signals
-- ** AudioVisualizerShaderFunc #signal:AudioVisualizerShaderFunc#

    AudioVisualizerShaderFunc               ,
    C_AudioVisualizerShaderFunc             ,
    dynamic_AudioVisualizerShaderFunc       ,
    genClosure_AudioVisualizerShaderFunc    ,
    mk_AudioVisualizerShaderFunc            ,
    noAudioVisualizerShaderFunc             ,
    wrap_AudioVisualizerShaderFunc          ,


-- ** InstallPluginsResultFunc #signal:InstallPluginsResultFunc#

    C_InstallPluginsResultFunc              ,
    InstallPluginsResultFunc                ,
    InstallPluginsResultFunc_WithClosures   ,
    drop_closures_InstallPluginsResultFunc  ,
    dynamic_InstallPluginsResultFunc        ,
    genClosure_InstallPluginsResultFunc     ,
    mk_InstallPluginsResultFunc             ,
    noInstallPluginsResultFunc              ,
    noInstallPluginsResultFunc_WithClosures ,
    wrap_InstallPluginsResultFunc           ,




    ) 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.GI.Base.Signals as B.Signals
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 {-# SOURCE #-} qualified GI.GstPbutils.Enums as GstPbutils.Enums
import {-# SOURCE #-} qualified GI.GstPbutils.Objects.AudioVisualizer as GstPbutils.AudioVisualizer
import qualified GI.GstVideo.Structs.VideoFrame as GstVideo.VideoFrame

-- callback InstallPluginsResultFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "result", argType = TInterface (Name {namespace = "GstPbutils", name = "InstallPluginsReturn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the installation of the requested plugins succeeded or not", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the user data passed to gst_install_plugins_async()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The prototype of the callback function that will be called once the\nexternal plugin installer program has returned. You only need to provide\na callback function if you are using the asynchronous interface.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_InstallPluginsResultFunc =
    CUInt ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "result"
--           , argType =
--               TInterface
--                 Name { namespace = "GstPbutils" , name = "InstallPluginsReturn" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "whether the installation of the requested plugins succeeded or not"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the user data passed to gst_install_plugins_async()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InstallPluginsResultFunc :: FunPtr C_InstallPluginsResultFunc -> C_InstallPluginsResultFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InstallPluginsResultFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_InstallPluginsResultFunc
    -> GstPbutils.Enums.InstallPluginsReturn
    -- ^ /@result@/: whether the installation of the requested plugins succeeded or not
    -> Ptr ()
    -- ^ /@userData@/: the user data passed to 'GI.GstPbutils.Functions.installPluginsAsync'
    -> m ()
dynamic_InstallPluginsResultFunc :: FunPtr C_InstallPluginsResultFunc
-> InstallPluginsReturn -> Ptr () -> m ()
dynamic_InstallPluginsResultFunc __funPtr :: FunPtr C_InstallPluginsResultFunc
__funPtr result_ :: InstallPluginsReturn
result_ userData :: Ptr ()
userData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let result_' :: CUInt
result_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (InstallPluginsReturn -> Int) -> InstallPluginsReturn -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InstallPluginsReturn -> Int
forall a. Enum a => a -> Int
fromEnum) InstallPluginsReturn
result_
    (FunPtr C_InstallPluginsResultFunc -> C_InstallPluginsResultFunc
__dynamic_C_InstallPluginsResultFunc FunPtr C_InstallPluginsResultFunc
__funPtr) CUInt
result_' Ptr ()
userData
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Generate a function pointer callable from C code, from a `C_InstallPluginsResultFunc`.
foreign import ccall "wrapper"
    mk_InstallPluginsResultFunc :: C_InstallPluginsResultFunc -> IO (FunPtr C_InstallPluginsResultFunc)

-- | The prototype of the callback function that will be called once the
-- external plugin installer program has returned. You only need to provide
-- a callback function if you are using the asynchronous interface.
type InstallPluginsResultFunc =
    GstPbutils.Enums.InstallPluginsReturn
    -- ^ /@result@/: whether the installation of the requested plugins succeeded or not
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InstallPluginsResultFunc`@.
noInstallPluginsResultFunc :: Maybe InstallPluginsResultFunc
noInstallPluginsResultFunc :: Maybe InstallPluginsResultFunc
noInstallPluginsResultFunc = Maybe InstallPluginsResultFunc
forall a. Maybe a
Nothing

-- | The prototype of the callback function that will be called once the
-- external plugin installer program has returned. You only need to provide
-- a callback function if you are using the asynchronous interface.
type InstallPluginsResultFunc_WithClosures =
    GstPbutils.Enums.InstallPluginsReturn
    -- ^ /@result@/: whether the installation of the requested plugins succeeded or not
    -> Ptr ()
    -- ^ /@userData@/: the user data passed to 'GI.GstPbutils.Functions.installPluginsAsync'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InstallPluginsResultFunc_WithClosures`@.
noInstallPluginsResultFunc_WithClosures :: Maybe InstallPluginsResultFunc_WithClosures
noInstallPluginsResultFunc_WithClosures :: Maybe InstallPluginsResultFunc_WithClosures
noInstallPluginsResultFunc_WithClosures = Maybe InstallPluginsResultFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_InstallPluginsResultFunc :: InstallPluginsResultFunc -> InstallPluginsResultFunc_WithClosures
drop_closures_InstallPluginsResultFunc :: InstallPluginsResultFunc -> InstallPluginsResultFunc_WithClosures
drop_closures_InstallPluginsResultFunc _f :: InstallPluginsResultFunc
_f result_ :: InstallPluginsReturn
result_ _ = InstallPluginsResultFunc
_f InstallPluginsReturn
result_

-- | Wrap the callback into a `GClosure`.
genClosure_InstallPluginsResultFunc :: MonadIO m => InstallPluginsResultFunc -> m (GClosure C_InstallPluginsResultFunc)
genClosure_InstallPluginsResultFunc :: InstallPluginsResultFunc -> m (GClosure C_InstallPluginsResultFunc)
genClosure_InstallPluginsResultFunc cb :: InstallPluginsResultFunc
cb = IO (GClosure C_InstallPluginsResultFunc)
-> m (GClosure C_InstallPluginsResultFunc)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InstallPluginsResultFunc)
 -> m (GClosure C_InstallPluginsResultFunc))
-> IO (GClosure C_InstallPluginsResultFunc)
-> m (GClosure C_InstallPluginsResultFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: InstallPluginsResultFunc_WithClosures
cb' = InstallPluginsResultFunc -> InstallPluginsResultFunc_WithClosures
drop_closures_InstallPluginsResultFunc InstallPluginsResultFunc
cb
    let cb'' :: C_InstallPluginsResultFunc
cb'' = Maybe (Ptr (FunPtr C_InstallPluginsResultFunc))
-> InstallPluginsResultFunc_WithClosures
-> C_InstallPluginsResultFunc
wrap_InstallPluginsResultFunc Maybe (Ptr (FunPtr C_InstallPluginsResultFunc))
forall a. Maybe a
Nothing InstallPluginsResultFunc_WithClosures
cb'
    C_InstallPluginsResultFunc
-> IO (FunPtr C_InstallPluginsResultFunc)
mk_InstallPluginsResultFunc C_InstallPluginsResultFunc
cb'' IO (FunPtr C_InstallPluginsResultFunc)
-> (FunPtr C_InstallPluginsResultFunc
    -> IO (GClosure C_InstallPluginsResultFunc))
-> IO (GClosure C_InstallPluginsResultFunc)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InstallPluginsResultFunc
-> IO (GClosure C_InstallPluginsResultFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InstallPluginsResultFunc` into a `C_InstallPluginsResultFunc`.
wrap_InstallPluginsResultFunc ::
    Maybe (Ptr (FunPtr C_InstallPluginsResultFunc)) ->
    InstallPluginsResultFunc_WithClosures ->
    C_InstallPluginsResultFunc
wrap_InstallPluginsResultFunc :: Maybe (Ptr (FunPtr C_InstallPluginsResultFunc))
-> InstallPluginsResultFunc_WithClosures
-> C_InstallPluginsResultFunc
wrap_InstallPluginsResultFunc funptrptr :: Maybe (Ptr (FunPtr C_InstallPluginsResultFunc))
funptrptr _cb :: InstallPluginsResultFunc_WithClosures
_cb result_ :: CUInt
result_ userData :: Ptr ()
userData = do
    let result_' :: InstallPluginsReturn
result_' = (Int -> InstallPluginsReturn
forall a. Enum a => Int -> a
toEnum (Int -> InstallPluginsReturn)
-> (CUInt -> Int) -> CUInt -> InstallPluginsReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result_
    InstallPluginsResultFunc_WithClosures
_cb  InstallPluginsReturn
result_' Ptr ()
userData
    Maybe (Ptr (FunPtr C_InstallPluginsResultFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_InstallPluginsResultFunc))
funptrptr


-- callback AudioVisualizerShaderFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "scope", argType = TInterface (Name {namespace = "GstPbutils", name = "AudioVisualizer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "s", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "d", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_AudioVisualizerShaderFunc =
    Ptr GstPbutils.AudioVisualizer.AudioVisualizer ->
    Ptr GstVideo.VideoFrame.VideoFrame ->
    Ptr GstVideo.VideoFrame.VideoFrame ->
    IO ()

-- Args: [ Arg
--           { argCName = "scope"
--           , argType =
--               TInterface
--                 Name { namespace = "GstPbutils" , name = "AudioVisualizer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "s"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "VideoFrame" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "d"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "VideoFrame" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_AudioVisualizerShaderFunc :: FunPtr C_AudioVisualizerShaderFunc -> C_AudioVisualizerShaderFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_AudioVisualizerShaderFunc ::
    (B.CallStack.HasCallStack, MonadIO m, GstPbutils.AudioVisualizer.IsAudioVisualizer a) =>
    FunPtr C_AudioVisualizerShaderFunc
    -> a
    -> GstVideo.VideoFrame.VideoFrame
    -> GstVideo.VideoFrame.VideoFrame
    -> m ()
dynamic_AudioVisualizerShaderFunc :: FunPtr C_AudioVisualizerShaderFunc
-> a -> VideoFrame -> VideoFrame -> m ()
dynamic_AudioVisualizerShaderFunc __funPtr :: FunPtr C_AudioVisualizerShaderFunc
__funPtr scope :: a
scope s :: VideoFrame
s d :: VideoFrame
d = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr AudioVisualizer
scope' <- a -> IO (Ptr AudioVisualizer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scope
    Ptr VideoFrame
s' <- VideoFrame -> IO (Ptr VideoFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoFrame
s
    Ptr VideoFrame
d' <- VideoFrame -> IO (Ptr VideoFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoFrame
d
    (FunPtr C_AudioVisualizerShaderFunc -> C_AudioVisualizerShaderFunc
__dynamic_C_AudioVisualizerShaderFunc FunPtr C_AudioVisualizerShaderFunc
__funPtr) Ptr AudioVisualizer
scope' Ptr VideoFrame
s' Ptr VideoFrame
d'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scope
    VideoFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoFrame
s
    VideoFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoFrame
d
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Generate a function pointer callable from C code, from a `C_AudioVisualizerShaderFunc`.
foreign import ccall "wrapper"
    mk_AudioVisualizerShaderFunc :: C_AudioVisualizerShaderFunc -> IO (FunPtr C_AudioVisualizerShaderFunc)

-- | /No description available in the introspection data./
type AudioVisualizerShaderFunc =
    GstPbutils.AudioVisualizer.AudioVisualizer
    -> GstVideo.VideoFrame.VideoFrame
    -> GstVideo.VideoFrame.VideoFrame
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AudioVisualizerShaderFunc`@.
noAudioVisualizerShaderFunc :: Maybe AudioVisualizerShaderFunc
noAudioVisualizerShaderFunc :: Maybe AudioVisualizerShaderFunc
noAudioVisualizerShaderFunc = Maybe AudioVisualizerShaderFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_AudioVisualizerShaderFunc :: MonadIO m => AudioVisualizerShaderFunc -> m (GClosure C_AudioVisualizerShaderFunc)
genClosure_AudioVisualizerShaderFunc :: AudioVisualizerShaderFunc
-> m (GClosure C_AudioVisualizerShaderFunc)
genClosure_AudioVisualizerShaderFunc cb :: AudioVisualizerShaderFunc
cb = IO (GClosure C_AudioVisualizerShaderFunc)
-> m (GClosure C_AudioVisualizerShaderFunc)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AudioVisualizerShaderFunc)
 -> m (GClosure C_AudioVisualizerShaderFunc))
-> IO (GClosure C_AudioVisualizerShaderFunc)
-> m (GClosure C_AudioVisualizerShaderFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AudioVisualizerShaderFunc
cb' = Maybe (Ptr (FunPtr C_AudioVisualizerShaderFunc))
-> AudioVisualizerShaderFunc -> C_AudioVisualizerShaderFunc
wrap_AudioVisualizerShaderFunc Maybe (Ptr (FunPtr C_AudioVisualizerShaderFunc))
forall a. Maybe a
Nothing AudioVisualizerShaderFunc
cb
    C_AudioVisualizerShaderFunc
-> IO (FunPtr C_AudioVisualizerShaderFunc)
mk_AudioVisualizerShaderFunc C_AudioVisualizerShaderFunc
cb' IO (FunPtr C_AudioVisualizerShaderFunc)
-> (FunPtr C_AudioVisualizerShaderFunc
    -> IO (GClosure C_AudioVisualizerShaderFunc))
-> IO (GClosure C_AudioVisualizerShaderFunc)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AudioVisualizerShaderFunc
-> IO (GClosure C_AudioVisualizerShaderFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AudioVisualizerShaderFunc` into a `C_AudioVisualizerShaderFunc`.
wrap_AudioVisualizerShaderFunc ::
    Maybe (Ptr (FunPtr C_AudioVisualizerShaderFunc)) ->
    AudioVisualizerShaderFunc ->
    C_AudioVisualizerShaderFunc
wrap_AudioVisualizerShaderFunc :: Maybe (Ptr (FunPtr C_AudioVisualizerShaderFunc))
-> AudioVisualizerShaderFunc -> C_AudioVisualizerShaderFunc
wrap_AudioVisualizerShaderFunc funptrptr :: Maybe (Ptr (FunPtr C_AudioVisualizerShaderFunc))
funptrptr _cb :: AudioVisualizerShaderFunc
_cb scope :: Ptr AudioVisualizer
scope s :: Ptr VideoFrame
s d :: Ptr VideoFrame
d = do
    AudioVisualizer
scope' <- ((ManagedPtr AudioVisualizer -> AudioVisualizer)
-> Ptr AudioVisualizer -> IO AudioVisualizer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr AudioVisualizer -> AudioVisualizer
GstPbutils.AudioVisualizer.AudioVisualizer) Ptr AudioVisualizer
scope
    VideoFrame
s' <- ((ManagedPtr VideoFrame -> VideoFrame)
-> Ptr VideoFrame -> IO VideoFrame
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr VideoFrame -> VideoFrame
GstVideo.VideoFrame.VideoFrame) Ptr VideoFrame
s
    VideoFrame
d' <- ((ManagedPtr VideoFrame -> VideoFrame)
-> Ptr VideoFrame -> IO VideoFrame
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr VideoFrame -> VideoFrame
GstVideo.VideoFrame.VideoFrame) Ptr VideoFrame
d
    AudioVisualizerShaderFunc
_cb  AudioVisualizer
scope' VideoFrame
s' VideoFrame
d'
    Maybe (Ptr (FunPtr C_AudioVisualizerShaderFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AudioVisualizerShaderFunc))
funptrptr