{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Extra buffer metadata describing the GstVideoTimeCode of the frame.
-- 
-- Each frame is assumed to have its own timecode, i.e. they are not
-- automatically incremented\/interpolated.
-- 
-- /Since: 1.10/

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

module GI.GstVideo.Structs.VideoTimeCodeMeta
    ( 

-- * Exported types
    VideoTimeCodeMeta(..)                   ,
    newZeroVideoTimeCodeMeta                ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveVideoTimeCodeMetaMethod          ,
#endif

-- ** getInfo #method:getInfo#

    videoTimeCodeMetaGetInfo                ,




 -- * Properties


-- ** meta #attr:meta#
-- | parent t'GI.Gst.Structs.Meta.Meta'

    getVideoTimeCodeMetaMeta                ,
#if defined(ENABLE_OVERLOADING)
    videoTimeCodeMeta_meta                  ,
#endif


-- ** tc #attr:tc#
-- | the GstVideoTimeCode to attach

    getVideoTimeCodeMetaTc                  ,
#if defined(ENABLE_OVERLOADING)
    videoTimeCodeMeta_tc                    ,
#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.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.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoTimeCode as GstVideo.VideoTimeCode

-- | Memory-managed wrapper type.
newtype VideoTimeCodeMeta = VideoTimeCodeMeta (SP.ManagedPtr VideoTimeCodeMeta)
    deriving (VideoTimeCodeMeta -> VideoTimeCodeMeta -> Bool
(VideoTimeCodeMeta -> VideoTimeCodeMeta -> Bool)
-> (VideoTimeCodeMeta -> VideoTimeCodeMeta -> Bool)
-> Eq VideoTimeCodeMeta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoTimeCodeMeta -> VideoTimeCodeMeta -> Bool
$c/= :: VideoTimeCodeMeta -> VideoTimeCodeMeta -> Bool
== :: VideoTimeCodeMeta -> VideoTimeCodeMeta -> Bool
$c== :: VideoTimeCodeMeta -> VideoTimeCodeMeta -> Bool
Eq)

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

instance BoxedPtr VideoTimeCodeMeta where
    boxedPtrCopy :: VideoTimeCodeMeta -> IO VideoTimeCodeMeta
boxedPtrCopy = \VideoTimeCodeMeta
p -> VideoTimeCodeMeta
-> (Ptr VideoTimeCodeMeta -> IO VideoTimeCodeMeta)
-> IO VideoTimeCodeMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoTimeCodeMeta
p (Int -> Ptr VideoTimeCodeMeta -> IO (Ptr VideoTimeCodeMeta)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 (Ptr VideoTimeCodeMeta -> IO (Ptr VideoTimeCodeMeta))
-> (Ptr VideoTimeCodeMeta -> IO VideoTimeCodeMeta)
-> Ptr VideoTimeCodeMeta
-> IO VideoTimeCodeMeta
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr VideoTimeCodeMeta -> VideoTimeCodeMeta)
-> Ptr VideoTimeCodeMeta -> IO VideoTimeCodeMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr VideoTimeCodeMeta -> VideoTimeCodeMeta
VideoTimeCodeMeta)
    boxedPtrFree :: VideoTimeCodeMeta -> IO ()
boxedPtrFree = \VideoTimeCodeMeta
x -> VideoTimeCodeMeta -> (Ptr VideoTimeCodeMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr VideoTimeCodeMeta
x Ptr VideoTimeCodeMeta -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr VideoTimeCodeMeta where
    boxedPtrCalloc :: IO (Ptr VideoTimeCodeMeta)
boxedPtrCalloc = Int -> IO (Ptr VideoTimeCodeMeta)
forall a. Int -> IO (Ptr a)
callocBytes Int
64


-- | Construct a `VideoTimeCodeMeta` struct initialized to zero.
newZeroVideoTimeCodeMeta :: MonadIO m => m VideoTimeCodeMeta
newZeroVideoTimeCodeMeta :: forall (m :: * -> *). MonadIO m => m VideoTimeCodeMeta
newZeroVideoTimeCodeMeta = IO VideoTimeCodeMeta -> m VideoTimeCodeMeta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoTimeCodeMeta -> m VideoTimeCodeMeta)
-> IO VideoTimeCodeMeta -> m VideoTimeCodeMeta
forall a b. (a -> b) -> a -> b
$ IO (Ptr VideoTimeCodeMeta)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr VideoTimeCodeMeta)
-> (Ptr VideoTimeCodeMeta -> IO VideoTimeCodeMeta)
-> IO VideoTimeCodeMeta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoTimeCodeMeta -> VideoTimeCodeMeta)
-> Ptr VideoTimeCodeMeta -> IO VideoTimeCodeMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr VideoTimeCodeMeta -> VideoTimeCodeMeta
VideoTimeCodeMeta

instance tag ~ 'AttrSet => Constructible VideoTimeCodeMeta tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr VideoTimeCodeMeta -> VideoTimeCodeMeta)
-> [AttrOp VideoTimeCodeMeta tag] -> m VideoTimeCodeMeta
new ManagedPtr VideoTimeCodeMeta -> VideoTimeCodeMeta
_ [AttrOp VideoTimeCodeMeta tag]
attrs = do
        VideoTimeCodeMeta
o <- m VideoTimeCodeMeta
forall (m :: * -> *). MonadIO m => m VideoTimeCodeMeta
newZeroVideoTimeCodeMeta
        VideoTimeCodeMeta -> [AttrOp VideoTimeCodeMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set VideoTimeCodeMeta
o [AttrOp VideoTimeCodeMeta tag]
[AttrOp VideoTimeCodeMeta 'AttrSet]
attrs
        VideoTimeCodeMeta -> m VideoTimeCodeMeta
forall (m :: * -> *) a. Monad m => a -> m a
return VideoTimeCodeMeta
o


-- | Get the value of the “@meta@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoTimeCodeMeta #meta
-- @
getVideoTimeCodeMetaMeta :: MonadIO m => VideoTimeCodeMeta -> m Gst.Meta.Meta
getVideoTimeCodeMetaMeta :: forall (m :: * -> *). MonadIO m => VideoTimeCodeMeta -> m Meta
getVideoTimeCodeMetaMeta VideoTimeCodeMeta
s = IO Meta -> m Meta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Meta -> m Meta) -> IO Meta -> m Meta
forall a b. (a -> b) -> a -> b
$ VideoTimeCodeMeta -> (Ptr VideoTimeCodeMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeMeta
s ((Ptr VideoTimeCodeMeta -> IO Meta) -> IO Meta)
-> (Ptr VideoTimeCodeMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr VideoTimeCodeMeta
ptr Ptr VideoTimeCodeMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.Meta.Meta)
    Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
val
    Meta -> IO Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeMetaMetaFieldInfo
instance AttrInfo VideoTimeCodeMetaMetaFieldInfo where
    type AttrBaseTypeConstraint VideoTimeCodeMetaMetaFieldInfo = (~) VideoTimeCodeMeta
    type AttrAllowedOps VideoTimeCodeMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint VideoTimeCodeMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType VideoTimeCodeMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType VideoTimeCodeMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel VideoTimeCodeMetaMetaFieldInfo = "meta"
    type AttrOrigin VideoTimeCodeMetaMetaFieldInfo = VideoTimeCodeMeta
    attrGet = getVideoTimeCodeMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeMeta.meta"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.25/docs/GI-GstVideo-Structs-VideoTimeCodeMeta.html#g:attr:meta"
        })

videoTimeCodeMeta_meta :: AttrLabelProxy "meta"
videoTimeCodeMeta_meta = AttrLabelProxy

#endif


-- | Get the value of the “@tc@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoTimeCodeMeta #tc
-- @
getVideoTimeCodeMetaTc :: MonadIO m => VideoTimeCodeMeta -> m GstVideo.VideoTimeCode.VideoTimeCode
getVideoTimeCodeMetaTc :: forall (m :: * -> *).
MonadIO m =>
VideoTimeCodeMeta -> m VideoTimeCode
getVideoTimeCodeMetaTc VideoTimeCodeMeta
s = IO VideoTimeCode -> m VideoTimeCode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoTimeCode -> m VideoTimeCode)
-> IO VideoTimeCode -> m VideoTimeCode
forall a b. (a -> b) -> a -> b
$ VideoTimeCodeMeta
-> (Ptr VideoTimeCodeMeta -> IO VideoTimeCode) -> IO VideoTimeCode
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeMeta
s ((Ptr VideoTimeCodeMeta -> IO VideoTimeCode) -> IO VideoTimeCode)
-> (Ptr VideoTimeCodeMeta -> IO VideoTimeCode) -> IO VideoTimeCode
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeMeta
ptr -> do
    let val :: Ptr VideoTimeCode
val = Ptr VideoTimeCodeMeta
ptr Ptr VideoTimeCodeMeta -> Int -> Ptr VideoTimeCode
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: (Ptr GstVideo.VideoTimeCode.VideoTimeCode)
    VideoTimeCode
val' <- ((ManagedPtr VideoTimeCode -> VideoTimeCode)
-> Ptr VideoTimeCode -> IO VideoTimeCode
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VideoTimeCode -> VideoTimeCode
GstVideo.VideoTimeCode.VideoTimeCode) Ptr VideoTimeCode
val
    VideoTimeCode -> IO VideoTimeCode
forall (m :: * -> *) a. Monad m => a -> m a
return VideoTimeCode
val'

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeMetaTcFieldInfo
instance AttrInfo VideoTimeCodeMetaTcFieldInfo where
    type AttrBaseTypeConstraint VideoTimeCodeMetaTcFieldInfo = (~) VideoTimeCodeMeta
    type AttrAllowedOps VideoTimeCodeMetaTcFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeMetaTcFieldInfo = (~) (Ptr GstVideo.VideoTimeCode.VideoTimeCode)
    type AttrTransferTypeConstraint VideoTimeCodeMetaTcFieldInfo = (~)(Ptr GstVideo.VideoTimeCode.VideoTimeCode)
    type AttrTransferType VideoTimeCodeMetaTcFieldInfo = (Ptr GstVideo.VideoTimeCode.VideoTimeCode)
    type AttrGetType VideoTimeCodeMetaTcFieldInfo = GstVideo.VideoTimeCode.VideoTimeCode
    type AttrLabel VideoTimeCodeMetaTcFieldInfo = "tc"
    type AttrOrigin VideoTimeCodeMetaTcFieldInfo = VideoTimeCodeMeta
    attrGet = getVideoTimeCodeMetaTc
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeMeta.tc"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.25/docs/GI-GstVideo-Structs-VideoTimeCodeMeta.html#g:attr:tc"
        })

videoTimeCodeMeta_tc :: AttrLabelProxy "tc"
videoTimeCodeMeta_tc = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoTimeCodeMeta
type instance O.AttributeList VideoTimeCodeMeta = VideoTimeCodeMetaAttributeList
type VideoTimeCodeMetaAttributeList = ('[ '("meta", VideoTimeCodeMetaMetaFieldInfo), '("tc", VideoTimeCodeMetaTcFieldInfo)] :: [(Symbol, *)])
#endif

-- method VideoTimeCodeMeta::get_info
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "MetaInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_meta_get_info" gst_video_time_code_meta_get_info :: 
    IO (Ptr Gst.MetaInfo.MetaInfo)

-- | /No description available in the introspection data./
videoTimeCodeMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
videoTimeCodeMetaGetInfo :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MetaInfo
videoTimeCodeMetaGetInfo  = IO MetaInfo -> m MetaInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MetaInfo -> m MetaInfo) -> IO MetaInfo -> m MetaInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr MetaInfo
result <- IO (Ptr MetaInfo)
gst_video_time_code_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoTimeCodeMetaGetInfo" Ptr MetaInfo
result
    MetaInfo
result' <- ((ManagedPtr MetaInfo -> MetaInfo) -> Ptr MetaInfo -> IO MetaInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MetaInfo -> MetaInfo
Gst.MetaInfo.MetaInfo) Ptr MetaInfo
result
    MetaInfo -> IO MetaInfo
forall (m :: * -> *) a. Monad m => a -> m a
return MetaInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoTimeCodeMetaMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoTimeCodeMetaMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveVideoTimeCodeMetaMethod t VideoTimeCodeMeta, O.OverloadedMethod info VideoTimeCodeMeta p) => OL.IsLabel t (VideoTimeCodeMeta -> 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 ~ ResolveVideoTimeCodeMetaMethod t VideoTimeCodeMeta, O.OverloadedMethod info VideoTimeCodeMeta p, R.HasField t VideoTimeCodeMeta p) => R.HasField t VideoTimeCodeMeta p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveVideoTimeCodeMetaMethod t VideoTimeCodeMeta, O.OverloadedMethodInfo info VideoTimeCodeMeta) => OL.IsLabel t (O.MethodProxy info VideoTimeCodeMeta) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif