{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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                            ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addControlBinding]("GI.Gst.Objects.Object#g:method:addControlBinding"), [addObservation]("GI.Gst.Objects.Clock#g:method:addObservation"), [addObservationUnapplied]("GI.Gst.Objects.Clock#g:method:addObservationUnapplied"), [adjust]("GI.GstAudio.Objects.AudioClock#g:method:adjust"), [adjustUnlocked]("GI.Gst.Objects.Clock#g:method:adjustUnlocked"), [adjustWithCalibration]("GI.Gst.Objects.Clock#g:method:adjustWithCalibration"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [defaultError]("GI.Gst.Objects.Object#g:method:defaultError"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasActiveControlBindings]("GI.Gst.Objects.Object#g:method:hasActiveControlBindings"), [hasAncestor]("GI.Gst.Objects.Object#g:method:hasAncestor"), [hasAsAncestor]("GI.Gst.Objects.Object#g:method:hasAsAncestor"), [hasAsParent]("GI.Gst.Objects.Object#g:method:hasAsParent"), [invalidate]("GI.GstAudio.Objects.AudioClock#g:method:invalidate"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isSynced]("GI.Gst.Objects.Clock#g:method:isSynced"), [newPeriodicId]("GI.Gst.Objects.Clock#g:method:newPeriodicId"), [newSingleShotId]("GI.Gst.Objects.Clock#g:method:newSingleShotId"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [periodicIdReinit]("GI.Gst.Objects.Clock#g:method:periodicIdReinit"), [ref]("GI.Gst.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeControlBinding]("GI.Gst.Objects.Object#g:method:removeControlBinding"), [reset]("GI.GstAudio.Objects.AudioClock#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [singleShotIdReinit]("GI.Gst.Objects.Clock#g:method:singleShotIdReinit"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [suggestNextSync]("GI.Gst.Objects.Object#g:method:suggestNextSync"), [syncValues]("GI.Gst.Objects.Object#g:method:syncValues"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unadjustUnlocked]("GI.Gst.Objects.Clock#g:method:unadjustUnlocked"), [unadjustWithCalibration]("GI.Gst.Objects.Clock#g:method:unadjustWithCalibration"), [unparent]("GI.Gst.Objects.Object#g:method:unparent"), [unref]("GI.Gst.Objects.Object#g:method:unref"), [waitForSync]("GI.Gst.Objects.Clock#g:method:waitForSync"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getCalibration]("GI.Gst.Objects.Clock#g:method:getCalibration"), [getControlBinding]("GI.Gst.Objects.Object#g:method:getControlBinding"), [getControlRate]("GI.Gst.Objects.Object#g:method:getControlRate"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGValueArray]("GI.Gst.Objects.Object#g:method:getGValueArray"), [getInternalTime]("GI.Gst.Objects.Clock#g:method:getInternalTime"), [getMaster]("GI.Gst.Objects.Clock#g:method:getMaster"), [getName]("GI.Gst.Objects.Object#g:method:getName"), [getParent]("GI.Gst.Objects.Object#g:method:getParent"), [getPathString]("GI.Gst.Objects.Object#g:method:getPathString"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getResolution]("GI.Gst.Objects.Clock#g:method:getResolution"), [getTime]("GI.GstAudio.Objects.AudioClock#g:method:getTime"), [getTimeout]("GI.Gst.Objects.Clock#g:method:getTimeout"), [getValue]("GI.Gst.Objects.Object#g:method:getValue").
-- 
-- ==== Setters
-- [setCalibration]("GI.Gst.Objects.Clock#g:method:setCalibration"), [setControlBindingDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingDisabled"), [setControlBindingsDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingsDisabled"), [setControlRate]("GI.Gst.Objects.Object#g:method:setControlRate"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setMaster]("GI.Gst.Objects.Clock#g:method:setMaster"), [setName]("GI.Gst.Objects.Object#g:method:setName"), [setParent]("GI.Gst.Objects.Object#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setResolution]("GI.Gst.Objects.Clock#g:method:setResolution"), [setSynced]("GI.Gst.Objects.Clock#g:method:setSynced"), [setTimeout]("GI.Gst.Objects.Clock#g:method:setTimeout").

#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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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 Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R

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 (SP.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)

instance SP.ManagedPtrNewtype AudioClock where
    toManagedPtr :: AudioClock -> ManagedPtr AudioClock
toManagedPtr (AudioClock ManagedPtr AudioClock
p) = ManagedPtr AudioClock
p

foreign import ccall "gst_audio_clock_get_type"
    c_gst_audio_clock_get_type :: IO B.Types.GType

instance B.Types.TypedObject AudioClock where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_clock_get_type

instance B.Types.GObject AudioClock

-- | Type class for types which can be safely cast to `AudioClock`, for instance with `toAudioClock`.
class (SP.GObject o, O.IsDescendantOf AudioClock o) => IsAudioClock o
instance (SP.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 :: (MIO.MonadIO m, IsAudioClock o) => o -> m AudioClock
toAudioClock :: forall (m :: * -> *) o.
(MonadIO m, IsAudioClock o) =>
o -> m AudioClock
toAudioClock = IO AudioClock -> m AudioClock
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr AudioClock -> AudioClock
AudioClock

-- | Convert 'AudioClock' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe AudioClock) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_audio_clock_get_type
    gvalueSet_ :: Ptr GValue -> Maybe AudioClock -> IO ()
gvalueSet_ Ptr GValue
gv Maybe AudioClock
P.Nothing = Ptr GValue -> Ptr AudioClock -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr AudioClock
forall a. Ptr a
FP.nullPtr :: FP.Ptr AudioClock)
    gvalueSet_ Ptr GValue
gv (P.Just AudioClock
obj) = AudioClock -> (Ptr AudioClock -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AudioClock
obj (Ptr GValue -> Ptr AudioClock -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe AudioClock)
gvalueGet_ Ptr GValue
gv = do
        Ptr AudioClock
ptr <- Ptr GValue -> IO (Ptr AudioClock)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr AudioClock)
        if Ptr AudioClock
ptr Ptr AudioClock -> Ptr AudioClock -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr AudioClock
forall a. Ptr a
FP.nullPtr
        then AudioClock -> Maybe AudioClock
forall a. a -> Maybe a
P.Just (AudioClock -> Maybe AudioClock)
-> IO AudioClock -> IO (Maybe AudioClock)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
        else Maybe AudioClock -> IO (Maybe AudioClock)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AudioClock
forall a. Maybe a
P.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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveAudioClockMethod t AudioClock, O.OverloadedMethod info AudioClock p, R.HasField t AudioClock p) => R.HasField t AudioClock p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveAudioClockMethod t AudioClock, O.OverloadedMethodInfo info AudioClock) => OL.IsLabel t (O.MethodProxy info AudioClock) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> AudioClockGetTimeFunc -> m AudioClock
audioClockNew Text
name 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 ())
SP.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 Text
"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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAudioClock a) =>
a -> Word64 -> m Word64
audioClockAdjust a
clock 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.OverloadedMethod AudioClockAdjustMethodInfo a signature where
    overloadedMethod = audioClockAdjust

instance O.OverloadedMethodInfo AudioClockAdjustMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Objects.AudioClock.audioClockAdjust",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Objects-AudioClock.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAudioClock a) =>
a -> m Word64
audioClockGetTime 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.OverloadedMethod AudioClockGetTimeMethodInfo a signature where
    overloadedMethod = audioClockGetTime

instance O.OverloadedMethodInfo AudioClockGetTimeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Objects.AudioClock.audioClockGetTime",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Objects-AudioClock.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAudioClock a) =>
a -> m ()
audioClockInvalidate 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.OverloadedMethod AudioClockInvalidateMethodInfo a signature where
    overloadedMethod = audioClockInvalidate

instance O.OverloadedMethodInfo AudioClockInvalidateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Objects.AudioClock.audioClockInvalidate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Objects-AudioClock.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAudioClock a) =>
a -> Word64 -> m ()
audioClockReset a
clock 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.OverloadedMethod AudioClockResetMethodInfo a signature where
    overloadedMethod = audioClockReset

instance O.OverloadedMethodInfo AudioClockResetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Objects.AudioClock.audioClockReset",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Objects-AudioClock.html#v:audioClockReset"
        })


#endif