{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Content light level information specified in CEA-861.3, Appendix A.
-- 
-- /Since: 1.18/

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

module GI.GstVideo.Structs.VideoContentLightLevel
    ( 

-- * Exported types
    VideoContentLightLevel(..)              ,
    newZeroVideoContentLightLevel           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addToCaps]("GI.GstVideo.Structs.VideoContentLightLevel#g:method:addToCaps"), [fromCaps]("GI.GstVideo.Structs.VideoContentLightLevel#g:method:fromCaps"), [fromString]("GI.GstVideo.Structs.VideoContentLightLevel#g:method:fromString"), [init]("GI.GstVideo.Structs.VideoContentLightLevel#g:method:init"), [toString]("GI.GstVideo.Structs.VideoContentLightLevel#g:method:toString").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveVideoContentLightLevelMethod     ,
#endif

-- ** addToCaps #method:addToCaps#

#if defined(ENABLE_OVERLOADING)
    VideoContentLightLevelAddToCapsMethodInfo,
#endif
    videoContentLightLevelAddToCaps         ,


-- ** fromCaps #method:fromCaps#

#if defined(ENABLE_OVERLOADING)
    VideoContentLightLevelFromCapsMethodInfo,
#endif
    videoContentLightLevelFromCaps          ,


-- ** fromString #method:fromString#

#if defined(ENABLE_OVERLOADING)
    VideoContentLightLevelFromStringMethodInfo,
#endif
    videoContentLightLevelFromString        ,


-- ** init #method:init#

#if defined(ENABLE_OVERLOADING)
    VideoContentLightLevelInitMethodInfo    ,
#endif
    videoContentLightLevelInit              ,


-- ** toString #method:toString#

#if defined(ENABLE_OVERLOADING)
    VideoContentLightLevelToStringMethodInfo,
#endif
    videoContentLightLevelToString          ,




 -- * Properties


-- ** maxContentLightLevel #attr:maxContentLightLevel#
-- | the maximum content light level
--   (abbreviated to MaxCLL) in candelas per square meter (cd\/m^2 and nit)

    getVideoContentLightLevelMaxContentLightLevel,
    setVideoContentLightLevelMaxContentLightLevel,
#if defined(ENABLE_OVERLOADING)
    videoContentLightLevel_maxContentLightLevel,
#endif


-- ** maxFrameAverageLightLevel #attr:maxFrameAverageLightLevel#
-- | the maximum frame average light level
--   (abbreviated to MaxFLL) in candelas per square meter (cd\/m^2 and nit)

    getVideoContentLightLevelMaxFrameAverageLightLevel,
    setVideoContentLightLevelMaxFrameAverageLightLevel,
#if defined(ENABLE_OVERLOADING)
    videoContentLightLevel_maxFrameAverageLightLevel,
#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.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.Caps as Gst.Caps

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

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

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


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

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


-- | Get the value of the “@max_content_light_level@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoContentLightLevel #maxContentLightLevel
-- @
getVideoContentLightLevelMaxContentLightLevel :: MonadIO m => VideoContentLightLevel -> m Word16
getVideoContentLightLevelMaxContentLightLevel :: forall (m :: * -> *).
MonadIO m =>
VideoContentLightLevel -> m Word16
getVideoContentLightLevelMaxContentLightLevel VideoContentLightLevel
s = IO Word16 -> m Word16
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ VideoContentLightLevel
-> (Ptr VideoContentLightLevel -> IO Word16) -> IO Word16
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoContentLightLevel
s ((Ptr VideoContentLightLevel -> IO Word16) -> IO Word16)
-> (Ptr VideoContentLightLevel -> IO Word16) -> IO Word16
forall a b. (a -> b) -> a -> b
$ \Ptr VideoContentLightLevel
ptr -> do
    Word16
val <- Ptr Word16 -> IO Word16
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoContentLightLevel
ptr Ptr VideoContentLightLevel -> Int -> Ptr Word16
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Word16
    Word16 -> IO Word16
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
val

-- | Set the value of the “@max_content_light_level@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoContentLightLevel [ #maxContentLightLevel 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoContentLightLevelMaxContentLightLevel :: MonadIO m => VideoContentLightLevel -> Word16 -> m ()
setVideoContentLightLevelMaxContentLightLevel :: forall (m :: * -> *).
MonadIO m =>
VideoContentLightLevel -> Word16 -> m ()
setVideoContentLightLevelMaxContentLightLevel VideoContentLightLevel
s Word16
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoContentLightLevel
-> (Ptr VideoContentLightLevel -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoContentLightLevel
s ((Ptr VideoContentLightLevel -> IO ()) -> IO ())
-> (Ptr VideoContentLightLevel -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoContentLightLevel
ptr -> do
    Ptr Word16 -> Word16 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoContentLightLevel
ptr Ptr VideoContentLightLevel -> Int -> Ptr Word16
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Word16
val :: Word16)

#if defined(ENABLE_OVERLOADING)
data VideoContentLightLevelMaxContentLightLevelFieldInfo
instance AttrInfo VideoContentLightLevelMaxContentLightLevelFieldInfo where
    type AttrBaseTypeConstraint VideoContentLightLevelMaxContentLightLevelFieldInfo = (~) VideoContentLightLevel
    type AttrAllowedOps VideoContentLightLevelMaxContentLightLevelFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoContentLightLevelMaxContentLightLevelFieldInfo = (~) Word16
    type AttrTransferTypeConstraint VideoContentLightLevelMaxContentLightLevelFieldInfo = (~)Word16
    type AttrTransferType VideoContentLightLevelMaxContentLightLevelFieldInfo = Word16
    type AttrGetType VideoContentLightLevelMaxContentLightLevelFieldInfo = Word16
    type AttrLabel VideoContentLightLevelMaxContentLightLevelFieldInfo = "max_content_light_level"
    type AttrOrigin VideoContentLightLevelMaxContentLightLevelFieldInfo = VideoContentLightLevel
    attrGet = getVideoContentLightLevelMaxContentLightLevel
    attrSet = setVideoContentLightLevelMaxContentLightLevel
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoContentLightLevel_maxContentLightLevel :: AttrLabelProxy "maxContentLightLevel"
videoContentLightLevel_maxContentLightLevel = AttrLabelProxy

#endif


-- | Get the value of the “@max_frame_average_light_level@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoContentLightLevel #maxFrameAverageLightLevel
-- @
getVideoContentLightLevelMaxFrameAverageLightLevel :: MonadIO m => VideoContentLightLevel -> m Word16
getVideoContentLightLevelMaxFrameAverageLightLevel :: forall (m :: * -> *).
MonadIO m =>
VideoContentLightLevel -> m Word16
getVideoContentLightLevelMaxFrameAverageLightLevel VideoContentLightLevel
s = IO Word16 -> m Word16
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ VideoContentLightLevel
-> (Ptr VideoContentLightLevel -> IO Word16) -> IO Word16
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoContentLightLevel
s ((Ptr VideoContentLightLevel -> IO Word16) -> IO Word16)
-> (Ptr VideoContentLightLevel -> IO Word16) -> IO Word16
forall a b. (a -> b) -> a -> b
$ \Ptr VideoContentLightLevel
ptr -> do
    Word16
val <- Ptr Word16 -> IO Word16
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoContentLightLevel
ptr Ptr VideoContentLightLevel -> Int -> Ptr Word16
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
2) :: IO Word16
    Word16 -> IO Word16
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
val

-- | Set the value of the “@max_frame_average_light_level@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoContentLightLevel [ #maxFrameAverageLightLevel 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoContentLightLevelMaxFrameAverageLightLevel :: MonadIO m => VideoContentLightLevel -> Word16 -> m ()
setVideoContentLightLevelMaxFrameAverageLightLevel :: forall (m :: * -> *).
MonadIO m =>
VideoContentLightLevel -> Word16 -> m ()
setVideoContentLightLevelMaxFrameAverageLightLevel VideoContentLightLevel
s Word16
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoContentLightLevel
-> (Ptr VideoContentLightLevel -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoContentLightLevel
s ((Ptr VideoContentLightLevel -> IO ()) -> IO ())
-> (Ptr VideoContentLightLevel -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoContentLightLevel
ptr -> do
    Ptr Word16 -> Word16 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoContentLightLevel
ptr Ptr VideoContentLightLevel -> Int -> Ptr Word16
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
2) (Word16
val :: Word16)

#if defined(ENABLE_OVERLOADING)
data VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo
instance AttrInfo VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo where
    type AttrBaseTypeConstraint VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo = (~) VideoContentLightLevel
    type AttrAllowedOps VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo = (~) Word16
    type AttrTransferTypeConstraint VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo = (~)Word16
    type AttrTransferType VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo = Word16
    type AttrGetType VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo = Word16
    type AttrLabel VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo = "max_frame_average_light_level"
    type AttrOrigin VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo = VideoContentLightLevel
    attrGet = getVideoContentLightLevelMaxFrameAverageLightLevel
    attrSet = setVideoContentLightLevelMaxFrameAverageLightLevel
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoContentLightLevel_maxFrameAverageLightLevel :: AttrLabelProxy "maxFrameAverageLightLevel"
videoContentLightLevel_maxFrameAverageLightLevel = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoContentLightLevel
type instance O.AttributeList VideoContentLightLevel = VideoContentLightLevelAttributeList
type VideoContentLightLevelAttributeList = ('[ '("maxContentLightLevel", VideoContentLightLevelMaxContentLightLevelFieldInfo), '("maxFrameAverageLightLevel", VideoContentLightLevelMaxFrameAverageLightLevelFieldInfo)] :: [(Symbol, *)])
#endif

-- method VideoContentLightLevel::add_to_caps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "linfo"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoContentLightLevel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoContentLightLevel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstCaps" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_content_light_level_add_to_caps" gst_video_content_light_level_add_to_caps :: 
    Ptr VideoContentLightLevel ->           -- linfo : TInterface (Name {namespace = "GstVideo", name = "VideoContentLightLevel"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO CInt

-- | Parse /@caps@/ and update /@linfo@/
-- 
-- /Since: 1.18/
videoContentLightLevelAddToCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoContentLightLevel
    -- ^ /@linfo@/: a t'GI.GstVideo.Structs.VideoContentLightLevel.VideoContentLightLevel'
    -> Gst.Caps.Caps
    -- ^ /@caps@/: a t'GI.Gst.Structs.Caps.Caps'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@linfo@/ was successfully set to /@caps@/
videoContentLightLevelAddToCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoContentLightLevel -> Caps -> m Bool
videoContentLightLevelAddToCaps VideoContentLightLevel
linfo Caps
caps = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoContentLightLevel
linfo' <- VideoContentLightLevel -> IO (Ptr VideoContentLightLevel)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoContentLightLevel
linfo
    Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    CInt
result <- Ptr VideoContentLightLevel -> Ptr Caps -> IO CInt
gst_video_content_light_level_add_to_caps Ptr VideoContentLightLevel
linfo' Ptr Caps
caps'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoContentLightLevel -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoContentLightLevel
linfo
    Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data VideoContentLightLevelAddToCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m) => O.OverloadedMethod VideoContentLightLevelAddToCapsMethodInfo VideoContentLightLevel signature where
    overloadedMethod = videoContentLightLevelAddToCaps

instance O.OverloadedMethodInfo VideoContentLightLevelAddToCapsMethodInfo VideoContentLightLevel where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoContentLightLevel.videoContentLightLevelAddToCaps",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoContentLightLevel.html#v:videoContentLightLevelAddToCaps"
        }


#endif

-- method VideoContentLightLevel::from_caps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "linfo"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoContentLightLevel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoContentLightLevel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstCaps" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_content_light_level_from_caps" gst_video_content_light_level_from_caps :: 
    Ptr VideoContentLightLevel ->           -- linfo : TInterface (Name {namespace = "GstVideo", name = "VideoContentLightLevel"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO CInt

-- | Parse /@caps@/ and update /@linfo@/
-- 
-- /Since: 1.18/
videoContentLightLevelFromCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoContentLightLevel
    -- ^ /@linfo@/: a t'GI.GstVideo.Structs.VideoContentLightLevel.VideoContentLightLevel'
    -> Gst.Caps.Caps
    -- ^ /@caps@/: a t'GI.Gst.Structs.Caps.Caps'
    -> m Bool
    -- ^ __Returns:__ if /@caps@/ has t'GI.GstVideo.Structs.VideoContentLightLevel.VideoContentLightLevel' and could be parsed
videoContentLightLevelFromCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoContentLightLevel -> Caps -> m Bool
videoContentLightLevelFromCaps VideoContentLightLevel
linfo Caps
caps = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoContentLightLevel
linfo' <- VideoContentLightLevel -> IO (Ptr VideoContentLightLevel)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoContentLightLevel
linfo
    Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    CInt
result <- Ptr VideoContentLightLevel -> Ptr Caps -> IO CInt
gst_video_content_light_level_from_caps Ptr VideoContentLightLevel
linfo' Ptr Caps
caps'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoContentLightLevel -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoContentLightLevel
linfo
    Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data VideoContentLightLevelFromCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m) => O.OverloadedMethod VideoContentLightLevelFromCapsMethodInfo VideoContentLightLevel signature where
    overloadedMethod = videoContentLightLevelFromCaps

instance O.OverloadedMethodInfo VideoContentLightLevelFromCapsMethodInfo VideoContentLightLevel where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoContentLightLevel.videoContentLightLevelFromCaps",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoContentLightLevel.html#v:videoContentLightLevelFromCaps"
        }


#endif

-- method VideoContentLightLevel::from_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "linfo"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoContentLightLevel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoContentLightLevel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "level"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a content-light-level string from caps"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_content_light_level_from_string" gst_video_content_light_level_from_string :: 
    Ptr VideoContentLightLevel ->           -- linfo : TInterface (Name {namespace = "GstVideo", name = "VideoContentLightLevel"})
    CString ->                              -- level : TBasicType TUTF8
    IO CInt

-- | Parse the value of content-light-level caps field and update /@minfo@/
-- with the parsed values.
-- 
-- /Since: 1.18/
videoContentLightLevelFromString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoContentLightLevel
    -- ^ /@linfo@/: a t'GI.GstVideo.Structs.VideoContentLightLevel.VideoContentLightLevel'
    -> T.Text
    -- ^ /@level@/: a content-light-level string from caps
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@linfo@/ points to valid t'GI.GstVideo.Structs.VideoContentLightLevel.VideoContentLightLevel'.
videoContentLightLevelFromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoContentLightLevel -> Text -> m Bool
videoContentLightLevelFromString VideoContentLightLevel
linfo Text
level = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoContentLightLevel
linfo' <- VideoContentLightLevel -> IO (Ptr VideoContentLightLevel)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoContentLightLevel
linfo
    CString
level' <- Text -> IO CString
textToCString Text
level
    CInt
result <- Ptr VideoContentLightLevel -> CString -> IO CInt
gst_video_content_light_level_from_string Ptr VideoContentLightLevel
linfo' CString
level'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoContentLightLevel -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoContentLightLevel
linfo
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
level'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data VideoContentLightLevelFromStringMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod VideoContentLightLevelFromStringMethodInfo VideoContentLightLevel signature where
    overloadedMethod = videoContentLightLevelFromString

instance O.OverloadedMethodInfo VideoContentLightLevelFromStringMethodInfo VideoContentLightLevel where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoContentLightLevel.videoContentLightLevelFromString",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoContentLightLevel.html#v:videoContentLightLevelFromString"
        }


#endif

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

foreign import ccall "gst_video_content_light_level_init" gst_video_content_light_level_init :: 
    Ptr VideoContentLightLevel ->           -- linfo : TInterface (Name {namespace = "GstVideo", name = "VideoContentLightLevel"})
    IO ()

-- | Initialize /@linfo@/
-- 
-- /Since: 1.18/
videoContentLightLevelInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoContentLightLevel
    -- ^ /@linfo@/: a t'GI.GstVideo.Structs.VideoContentLightLevel.VideoContentLightLevel'
    -> m ()
videoContentLightLevelInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoContentLightLevel -> m ()
videoContentLightLevelInit VideoContentLightLevel
linfo = 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 VideoContentLightLevel
linfo' <- VideoContentLightLevel -> IO (Ptr VideoContentLightLevel)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoContentLightLevel
linfo
    Ptr VideoContentLightLevel -> IO ()
gst_video_content_light_level_init Ptr VideoContentLightLevel
linfo'
    VideoContentLightLevel -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoContentLightLevel
linfo
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoContentLightLevelInitMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VideoContentLightLevelInitMethodInfo VideoContentLightLevel signature where
    overloadedMethod = videoContentLightLevelInit

instance O.OverloadedMethodInfo VideoContentLightLevelInitMethodInfo VideoContentLightLevel where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoContentLightLevel.videoContentLightLevelInit",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoContentLightLevel.html#v:videoContentLightLevelInit"
        }


#endif

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

foreign import ccall "gst_video_content_light_level_to_string" gst_video_content_light_level_to_string :: 
    Ptr VideoContentLightLevel ->           -- linfo : TInterface (Name {namespace = "GstVideo", name = "VideoContentLightLevel"})
    IO CString

-- | Convert /@linfo@/ to its string representation.
-- 
-- /Since: 1.18/
videoContentLightLevelToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoContentLightLevel
    -- ^ /@linfo@/: a t'GI.GstVideo.Structs.VideoContentLightLevel.VideoContentLightLevel'
    -> m T.Text
    -- ^ __Returns:__ a string representation of /@linfo@/.
videoContentLightLevelToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoContentLightLevel -> m Text
videoContentLightLevelToString VideoContentLightLevel
linfo = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoContentLightLevel
linfo' <- VideoContentLightLevel -> IO (Ptr VideoContentLightLevel)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoContentLightLevel
linfo
    CString
result <- Ptr VideoContentLightLevel -> IO CString
gst_video_content_light_level_to_string Ptr VideoContentLightLevel
linfo'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoContentLightLevelToString" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    VideoContentLightLevel -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoContentLightLevel
linfo
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data VideoContentLightLevelToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod VideoContentLightLevelToStringMethodInfo VideoContentLightLevel signature where
    overloadedMethod = videoContentLightLevelToString

instance O.OverloadedMethodInfo VideoContentLightLevelToStringMethodInfo VideoContentLightLevel where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoContentLightLevel.videoContentLightLevelToString",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoContentLightLevel.html#v:videoContentLightLevelToString"
        }


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoContentLightLevelMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoContentLightLevelMethod "addToCaps" o = VideoContentLightLevelAddToCapsMethodInfo
    ResolveVideoContentLightLevelMethod "fromCaps" o = VideoContentLightLevelFromCapsMethodInfo
    ResolveVideoContentLightLevelMethod "fromString" o = VideoContentLightLevelFromStringMethodInfo
    ResolveVideoContentLightLevelMethod "init" o = VideoContentLightLevelInitMethodInfo
    ResolveVideoContentLightLevelMethod "toString" o = VideoContentLightLevelToStringMethodInfo
    ResolveVideoContentLightLevelMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif