{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.GstAudio.Objects.AudioClock.AudioClock' makes it easy for elements to implement a t'GI.Gst.Objects.Clock.Clock', they
-- simply need to provide a function that returns the current clock time.
-- 
-- This object is internally used to implement the clock in t'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink'.

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

module GI.GstAudio.Objects.AudioClock
    ( 

-- * Exported types
    AudioClock(..)                          ,
    IsAudioClock                            ,
    toAudioClock                            ,
    noAudioClock                            ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveAudioClockMethod                 ,
#endif


-- ** adjust #method:adjust#

#if defined(ENABLE_OVERLOADING)
    AudioClockAdjustMethodInfo              ,
#endif
    audioClockAdjust                        ,


-- ** getTime #method:getTime#

#if defined(ENABLE_OVERLOADING)
    AudioClockGetTimeMethodInfo             ,
#endif
    audioClockGetTime                       ,


-- ** invalidate #method:invalidate#

#if defined(ENABLE_OVERLOADING)
    AudioClockInvalidateMethodInfo          ,
#endif
    audioClockInvalidate                    ,


-- ** new #method:new#

    audioClockNew                           ,


-- ** reset #method:reset#

#if defined(ENABLE_OVERLOADING)
    AudioClockResetMethodInfo               ,
#endif
    audioClockReset                         ,




    ) 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 qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Objects.Clock as Gst.Clock
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Objects.SystemClock as Gst.SystemClock
import qualified GI.GstAudio.Callbacks as GstAudio.Callbacks

-- | Memory-managed wrapper type.
newtype AudioClock = AudioClock (ManagedPtr AudioClock)
    deriving (AudioClock -> AudioClock -> Bool
(AudioClock -> AudioClock -> Bool)
-> (AudioClock -> AudioClock -> Bool) -> Eq AudioClock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioClock -> AudioClock -> Bool
$c/= :: AudioClock -> AudioClock -> Bool
== :: AudioClock -> AudioClock -> Bool
$c== :: AudioClock -> AudioClock -> Bool
Eq)
foreign import ccall "gst_audio_clock_get_type"
    c_gst_audio_clock_get_type :: IO GType

instance GObject AudioClock where
    gobjectType :: IO GType
gobjectType = IO GType
c_gst_audio_clock_get_type
    

-- | Convert 'AudioClock' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue AudioClock where
    toGValue :: AudioClock -> IO GValue
toGValue o :: AudioClock
o = do
        GType
gtype <- IO GType
c_gst_audio_clock_get_type
        AudioClock -> (Ptr AudioClock -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AudioClock
o (GType
-> (GValue -> Ptr AudioClock -> IO ())
-> Ptr AudioClock
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr AudioClock -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO AudioClock
fromGValue gv :: GValue
gv = do
        Ptr AudioClock
ptr <- GValue -> IO (Ptr AudioClock)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr AudioClock)
        (ManagedPtr AudioClock -> AudioClock)
-> Ptr AudioClock -> IO AudioClock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr AudioClock -> AudioClock
AudioClock Ptr AudioClock
ptr
        
    

-- | Type class for types which can be safely cast to `AudioClock`, for instance with `toAudioClock`.
class (GObject o, O.IsDescendantOf AudioClock o) => IsAudioClock o
instance (GObject o, O.IsDescendantOf AudioClock o) => IsAudioClock o

instance O.HasParentTypes AudioClock
type instance O.ParentTypes AudioClock = '[Gst.SystemClock.SystemClock, Gst.Clock.Clock, Gst.Object.Object, GObject.Object.Object]

-- | Cast to `AudioClock`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toAudioClock :: (MonadIO m, IsAudioClock o) => o -> m AudioClock
toAudioClock :: o -> m AudioClock
toAudioClock = IO AudioClock -> m AudioClock
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioClock -> m AudioClock)
-> (o -> IO AudioClock) -> o -> m AudioClock
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr AudioClock -> AudioClock) -> o -> IO AudioClock
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr AudioClock -> AudioClock
AudioClock

-- | A convenience alias for `Nothing` :: `Maybe` `AudioClock`.
noAudioClock :: Maybe AudioClock
noAudioClock :: Maybe AudioClock
noAudioClock = Maybe AudioClock
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveAudioClockMethod (t :: Symbol) (o :: *) :: * where
    ResolveAudioClockMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveAudioClockMethod "addObservation" o = Gst.Clock.ClockAddObservationMethodInfo
    ResolveAudioClockMethod "addObservationUnapplied" o = Gst.Clock.ClockAddObservationUnappliedMethodInfo
    ResolveAudioClockMethod "adjust" o = AudioClockAdjustMethodInfo
    ResolveAudioClockMethod "adjustUnlocked" o = Gst.Clock.ClockAdjustUnlockedMethodInfo
    ResolveAudioClockMethod "adjustWithCalibration" o = Gst.Clock.ClockAdjustWithCalibrationMethodInfo
    ResolveAudioClockMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAudioClockMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAudioClockMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveAudioClockMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAudioClockMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAudioClockMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveAudioClockMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveAudioClockMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveAudioClockMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveAudioClockMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveAudioClockMethod "invalidate" o = AudioClockInvalidateMethodInfo
    ResolveAudioClockMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAudioClockMethod "isSynced" o = Gst.Clock.ClockIsSyncedMethodInfo
    ResolveAudioClockMethod "newPeriodicId" o = Gst.Clock.ClockNewPeriodicIdMethodInfo
    ResolveAudioClockMethod "newSingleShotId" o = Gst.Clock.ClockNewSingleShotIdMethodInfo
    ResolveAudioClockMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAudioClockMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAudioClockMethod "periodicIdReinit" o = Gst.Clock.ClockPeriodicIdReinitMethodInfo
    ResolveAudioClockMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveAudioClockMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAudioClockMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveAudioClockMethod "reset" o = AudioClockResetMethodInfo
    ResolveAudioClockMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAudioClockMethod "singleShotIdReinit" o = Gst.Clock.ClockSingleShotIdReinitMethodInfo
    ResolveAudioClockMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAudioClockMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAudioClockMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveAudioClockMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveAudioClockMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAudioClockMethod "unadjustUnlocked" o = Gst.Clock.ClockUnadjustUnlockedMethodInfo
    ResolveAudioClockMethod "unadjustWithCalibration" o = Gst.Clock.ClockUnadjustWithCalibrationMethodInfo
    ResolveAudioClockMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveAudioClockMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveAudioClockMethod "waitForSync" o = Gst.Clock.ClockWaitForSyncMethodInfo
    ResolveAudioClockMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAudioClockMethod "getCalibration" o = Gst.Clock.ClockGetCalibrationMethodInfo
    ResolveAudioClockMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveAudioClockMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveAudioClockMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAudioClockMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveAudioClockMethod "getInternalTime" o = Gst.Clock.ClockGetInternalTimeMethodInfo
    ResolveAudioClockMethod "getMaster" o = Gst.Clock.ClockGetMasterMethodInfo
    ResolveAudioClockMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveAudioClockMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveAudioClockMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveAudioClockMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAudioClockMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAudioClockMethod "getResolution" o = Gst.Clock.ClockGetResolutionMethodInfo
    ResolveAudioClockMethod "getTime" o = AudioClockGetTimeMethodInfo
    ResolveAudioClockMethod "getTimeout" o = Gst.Clock.ClockGetTimeoutMethodInfo
    ResolveAudioClockMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveAudioClockMethod "setCalibration" o = Gst.Clock.ClockSetCalibrationMethodInfo
    ResolveAudioClockMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveAudioClockMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveAudioClockMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveAudioClockMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAudioClockMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveAudioClockMethod "setMaster" o = Gst.Clock.ClockSetMasterMethodInfo
    ResolveAudioClockMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveAudioClockMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveAudioClockMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAudioClockMethod "setResolution" o = Gst.Clock.ClockSetResolutionMethodInfo
    ResolveAudioClockMethod "setSynced" o = Gst.Clock.ClockSetSyncedMethodInfo
    ResolveAudioClockMethod "setTimeout" o = Gst.Clock.ClockSetTimeoutMethodInfo
    ResolveAudioClockMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAudioClockMethod t AudioClock, O.MethodInfo info AudioClock p) => OL.IsLabel t (AudioClock -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AudioClock
type instance O.AttributeList AudioClock = AudioClockAttributeList
type AudioClockAttributeList = ('[ '("clockType", Gst.SystemClock.SystemClockClockTypePropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("timeout", Gst.Clock.ClockTimeoutPropertyInfo), '("windowSize", Gst.Clock.ClockWindowSizePropertyInfo), '("windowThreshold", Gst.Clock.ClockWindowThresholdPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList AudioClock = AudioClockSignalList
type AudioClockSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("synced", Gst.Clock.ClockSyncedSignalInfo)] :: [(Symbol, *)])

#endif

-- method AudioClock::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the clock"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface
--                 Name { namespace = "GstAudio" , name = "AudioClockGetTimeFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a function" , sinceVersion = Nothing }
--           , argScope = ScopeTypeNotified
--           , argClosure = 2
--           , argDestroy = 3
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destroy_notify"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GDestroyNotify for @user_data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GstAudio" , name = "AudioClock" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_clock_new" gst_audio_clock_new :: 
    CString ->                              -- name : TBasicType TUTF8
    FunPtr GstAudio.Callbacks.C_AudioClockGetTimeFunc -> -- func : TInterface (Name {namespace = "GstAudio", name = "AudioClockGetTimeFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO (Ptr AudioClock)

-- | Create a new t'GI.GstAudio.Objects.AudioClock.AudioClock' instance. Whenever the clock time should be
-- calculated it will call /@func@/ with /@userData@/. When /@func@/ returns
-- 'GI.Gst.Constants.CLOCK_TIME_NONE', the clock will return the last reported time.
audioClockNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@name@/: the name of the clock
    -> GstAudio.Callbacks.AudioClockGetTimeFunc
    -- ^ /@func@/: a function
    -> m AudioClock
    -- ^ __Returns:__ a new t'GI.GstAudio.Objects.AudioClock.AudioClock' casted to a t'GI.Gst.Objects.Clock.Clock'.
audioClockNew :: Text -> AudioClockGetTimeFunc -> m AudioClock
audioClockNew name :: Text
name func :: AudioClockGetTimeFunc
func = IO AudioClock -> m AudioClock
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioClock -> m AudioClock) -> IO AudioClock -> m AudioClock
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    FunPtr C_AudioClockGetTimeFunc
func' <- C_AudioClockGetTimeFunc -> IO (FunPtr C_AudioClockGetTimeFunc)
GstAudio.Callbacks.mk_AudioClockGetTimeFunc (Maybe (Ptr (FunPtr C_AudioClockGetTimeFunc))
-> AudioClockGetTimeFunc_WithClosures -> C_AudioClockGetTimeFunc
GstAudio.Callbacks.wrap_AudioClockGetTimeFunc Maybe (Ptr (FunPtr C_AudioClockGetTimeFunc))
forall a. Maybe a
Nothing (AudioClockGetTimeFunc -> AudioClockGetTimeFunc_WithClosures
GstAudio.Callbacks.drop_closures_AudioClockGetTimeFunc AudioClockGetTimeFunc
func))
    let userData :: Ptr ()
userData = FunPtr C_AudioClockGetTimeFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_AudioClockGetTimeFunc
func'
    let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
    Ptr AudioClock
result <- CString
-> FunPtr C_AudioClockGetTimeFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO (Ptr AudioClock)
gst_audio_clock_new CString
name' FunPtr C_AudioClockGetTimeFunc
func' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify
    Text -> Ptr AudioClock -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "audioClockNew" Ptr AudioClock
result
    AudioClock
result' <- ((ManagedPtr AudioClock -> AudioClock)
-> Ptr AudioClock -> IO AudioClock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr AudioClock -> AudioClock
AudioClock) Ptr AudioClock
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    AudioClock -> IO AudioClock
forall (m :: * -> *) a. Monad m => a -> m a
return AudioClock
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method AudioClock::adjust
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clock"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioClock" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioClock" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "time"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstClockTime" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_clock_adjust" gst_audio_clock_adjust :: 
    Ptr AudioClock ->                       -- clock : TInterface (Name {namespace = "GstAudio", name = "AudioClock"})
    Word64 ->                               -- time : TBasicType TUInt64
    IO Word64

-- | Adjust /@time@/ with the internal offset of the audio clock.
audioClockAdjust ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioClock a) =>
    a
    -- ^ /@clock@/: a t'GI.GstAudio.Objects.AudioClock.AudioClock'
    -> Word64
    -- ^ /@time@/: a @/GstClockTime/@
    -> m Word64
    -- ^ __Returns:__ /@time@/ adjusted with the internal offset.
audioClockAdjust :: a -> Word64 -> m Word64
audioClockAdjust clock :: a
clock time :: Word64
time = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr AudioClock
clock' <- a -> IO (Ptr AudioClock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clock
    Word64
result <- Ptr AudioClock -> Word64 -> IO Word64
gst_audio_clock_adjust Ptr AudioClock
clock' Word64
time
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clock
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data AudioClockAdjustMethodInfo
instance (signature ~ (Word64 -> m Word64), MonadIO m, IsAudioClock a) => O.MethodInfo AudioClockAdjustMethodInfo a signature where
    overloadedMethod = audioClockAdjust

#endif

-- method AudioClock::get_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clock"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioClock" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioClock" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_clock_get_time" gst_audio_clock_get_time :: 
    Ptr AudioClock ->                       -- clock : TInterface (Name {namespace = "GstAudio", name = "AudioClock"})
    IO Word64

-- | Report the time as returned by the t'GI.GstAudio.Callbacks.AudioClockGetTimeFunc' without applying
-- any offsets.
audioClockGetTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioClock a) =>
    a
    -- ^ /@clock@/: a t'GI.GstAudio.Objects.AudioClock.AudioClock'
    -> m Word64
    -- ^ __Returns:__ the time as reported by the time function of the audio clock
audioClockGetTime :: a -> m Word64
audioClockGetTime clock :: a
clock = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr AudioClock
clock' <- a -> IO (Ptr AudioClock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clock
    Word64
result <- Ptr AudioClock -> IO Word64
gst_audio_clock_get_time Ptr AudioClock
clock'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clock
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data AudioClockGetTimeMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsAudioClock a) => O.MethodInfo AudioClockGetTimeMethodInfo a signature where
    overloadedMethod = audioClockGetTime

#endif

-- method AudioClock::invalidate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clock"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioClock" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioClock" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_clock_invalidate" gst_audio_clock_invalidate :: 
    Ptr AudioClock ->                       -- clock : TInterface (Name {namespace = "GstAudio", name = "AudioClock"})
    IO ()

-- | Invalidate the clock function. Call this function when the provided
-- t'GI.GstAudio.Callbacks.AudioClockGetTimeFunc' cannot be called anymore, for example, when the
-- user_data becomes invalid.
-- 
-- After calling this function, /@clock@/ will return the last returned time for
-- the rest of its lifetime.
audioClockInvalidate ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioClock a) =>
    a
    -- ^ /@clock@/: a t'GI.GstAudio.Objects.AudioClock.AudioClock'
    -> m ()
audioClockInvalidate :: a -> m ()
audioClockInvalidate clock :: a
clock = 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 AudioClock
clock' <- a -> IO (Ptr AudioClock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clock
    Ptr AudioClock -> IO ()
gst_audio_clock_invalidate Ptr AudioClock
clock'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clock
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AudioClockInvalidateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAudioClock a) => O.MethodInfo AudioClockInvalidateMethodInfo a signature where
    overloadedMethod = audioClockInvalidate

#endif

-- method AudioClock::reset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clock"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioClock" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioClock" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "time"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstClockTime" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_clock_reset" gst_audio_clock_reset :: 
    Ptr AudioClock ->                       -- clock : TInterface (Name {namespace = "GstAudio", name = "AudioClock"})
    Word64 ->                               -- time : TBasicType TUInt64
    IO ()

-- | Inform /@clock@/ that future calls to t'GI.GstAudio.Callbacks.AudioClockGetTimeFunc' will return values
-- starting from /@time@/. The clock will update an internal offset to make sure that
-- future calls to internal_time will return an increasing result as required by
-- the t'GI.Gst.Objects.Clock.Clock' object.
audioClockReset ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioClock a) =>
    a
    -- ^ /@clock@/: a t'GI.GstAudio.Objects.AudioClock.AudioClock'
    -> Word64
    -- ^ /@time@/: a @/GstClockTime/@
    -> m ()
audioClockReset :: a -> Word64 -> m ()
audioClockReset clock :: a
clock time :: Word64
time = 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 AudioClock
clock' <- a -> IO (Ptr AudioClock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clock
    Ptr AudioClock -> Word64 -> IO ()
gst_audio_clock_reset Ptr AudioClock
clock' Word64
time
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clock
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AudioClockResetMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsAudioClock a) => O.MethodInfo AudioClockResetMethodInfo a signature where
    overloadedMethod = audioClockReset

#endif