{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Extra data passed to a video transform t'GI.Gst.Callbacks.MetaTransformFunction' such as:
-- \"gst-video-scale\".

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

module GI.GstVideo.Structs.VideoMetaTransform
    ( 

-- * Exported types
    VideoMetaTransform(..)                  ,
    newZeroVideoMetaTransform               ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveVideoMetaTransformMethod         ,
#endif

-- ** scaleGetQuark #method:scaleGetQuark#

    videoMetaTransformScaleGetQuark         ,




 -- * Properties


-- ** inInfo #attr:inInfo#
-- | the input t'GI.GstVideo.Structs.VideoInfo.VideoInfo'

    clearVideoMetaTransformInInfo           ,
    getVideoMetaTransformInInfo             ,
    setVideoMetaTransformInInfo             ,
#if defined(ENABLE_OVERLOADING)
    videoMetaTransform_inInfo               ,
#endif


-- ** outInfo #attr:outInfo#
-- | the output t'GI.GstVideo.Structs.VideoInfo.VideoInfo'

    clearVideoMetaTransformOutInfo          ,
    getVideoMetaTransformOutInfo            ,
    setVideoMetaTransformOutInfo            ,
#if defined(ENABLE_OVERLOADING)
    videoMetaTransform_outInfo              ,
#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.GHashTable as B.GHT
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.Kind as DK
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 {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo

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

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

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


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

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


-- | Get the value of the “@in_info@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMetaTransform #inInfo
-- @
getVideoMetaTransformInInfo :: MonadIO m => VideoMetaTransform -> m (Maybe GstVideo.VideoInfo.VideoInfo)
getVideoMetaTransformInInfo :: forall (m :: * -> *).
MonadIO m =>
VideoMetaTransform -> m (Maybe VideoInfo)
getVideoMetaTransformInInfo VideoMetaTransform
s = IO (Maybe VideoInfo) -> m (Maybe VideoInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoInfo) -> m (Maybe VideoInfo))
-> IO (Maybe VideoInfo) -> m (Maybe VideoInfo)
forall a b. (a -> b) -> a -> b
$ VideoMetaTransform
-> (Ptr VideoMetaTransform -> IO (Maybe VideoInfo))
-> IO (Maybe VideoInfo)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMetaTransform
s ((Ptr VideoMetaTransform -> IO (Maybe VideoInfo))
 -> IO (Maybe VideoInfo))
-> (Ptr VideoMetaTransform -> IO (Maybe VideoInfo))
-> IO (Maybe VideoInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMetaTransform
ptr -> do
    Ptr VideoInfo
val <- Ptr (Ptr VideoInfo) -> IO (Ptr VideoInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMetaTransform
ptr Ptr VideoMetaTransform -> Int -> Ptr (Ptr VideoInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr GstVideo.VideoInfo.VideoInfo)
    Maybe VideoInfo
result <- Ptr VideoInfo
-> (Ptr VideoInfo -> IO VideoInfo) -> IO (Maybe VideoInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr VideoInfo
val ((Ptr VideoInfo -> IO VideoInfo) -> IO (Maybe VideoInfo))
-> (Ptr VideoInfo -> IO VideoInfo) -> IO (Maybe VideoInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoInfo
val' -> do
        VideoInfo
val'' <- ((ManagedPtr VideoInfo -> VideoInfo)
-> Ptr VideoInfo -> IO VideoInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VideoInfo -> VideoInfo
GstVideo.VideoInfo.VideoInfo) Ptr VideoInfo
val'
        VideoInfo -> IO VideoInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoInfo
val''
    Maybe VideoInfo -> IO (Maybe VideoInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoInfo
result

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

-- | Set the value of the “@in_info@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #inInfo
-- @
clearVideoMetaTransformInInfo :: MonadIO m => VideoMetaTransform -> m ()
clearVideoMetaTransformInInfo :: forall (m :: * -> *). MonadIO m => VideoMetaTransform -> m ()
clearVideoMetaTransformInInfo VideoMetaTransform
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMetaTransform -> (Ptr VideoMetaTransform -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMetaTransform
s ((Ptr VideoMetaTransform -> IO ()) -> IO ())
-> (Ptr VideoMetaTransform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMetaTransform
ptr -> do
    Ptr (Ptr VideoInfo) -> Ptr VideoInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMetaTransform
ptr Ptr VideoMetaTransform -> Int -> Ptr (Ptr VideoInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr VideoInfo
forall a. Ptr a
FP.nullPtr :: Ptr GstVideo.VideoInfo.VideoInfo)

#if defined(ENABLE_OVERLOADING)
data VideoMetaTransformInInfoFieldInfo
instance AttrInfo VideoMetaTransformInInfoFieldInfo where
    type AttrBaseTypeConstraint VideoMetaTransformInInfoFieldInfo = (~) VideoMetaTransform
    type AttrAllowedOps VideoMetaTransformInInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoMetaTransformInInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo)
    type AttrTransferTypeConstraint VideoMetaTransformInInfoFieldInfo = (~)(Ptr GstVideo.VideoInfo.VideoInfo)
    type AttrTransferType VideoMetaTransformInInfoFieldInfo = (Ptr GstVideo.VideoInfo.VideoInfo)
    type AttrGetType VideoMetaTransformInInfoFieldInfo = Maybe GstVideo.VideoInfo.VideoInfo
    type AttrLabel VideoMetaTransformInInfoFieldInfo = "in_info"
    type AttrOrigin VideoMetaTransformInInfoFieldInfo = VideoMetaTransform
    attrGet = getVideoMetaTransformInInfo
    attrSet = setVideoMetaTransformInInfo
    attrConstruct = undefined
    attrClear = clearVideoMetaTransformInInfo
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoMetaTransform.inInfo"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoMetaTransform.html#g:attr:inInfo"
        })

videoMetaTransform_inInfo :: AttrLabelProxy "inInfo"
videoMetaTransform_inInfo = AttrLabelProxy

#endif


-- | Get the value of the “@out_info@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMetaTransform #outInfo
-- @
getVideoMetaTransformOutInfo :: MonadIO m => VideoMetaTransform -> m (Maybe GstVideo.VideoInfo.VideoInfo)
getVideoMetaTransformOutInfo :: forall (m :: * -> *).
MonadIO m =>
VideoMetaTransform -> m (Maybe VideoInfo)
getVideoMetaTransformOutInfo VideoMetaTransform
s = IO (Maybe VideoInfo) -> m (Maybe VideoInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoInfo) -> m (Maybe VideoInfo))
-> IO (Maybe VideoInfo) -> m (Maybe VideoInfo)
forall a b. (a -> b) -> a -> b
$ VideoMetaTransform
-> (Ptr VideoMetaTransform -> IO (Maybe VideoInfo))
-> IO (Maybe VideoInfo)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMetaTransform
s ((Ptr VideoMetaTransform -> IO (Maybe VideoInfo))
 -> IO (Maybe VideoInfo))
-> (Ptr VideoMetaTransform -> IO (Maybe VideoInfo))
-> IO (Maybe VideoInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMetaTransform
ptr -> do
    Ptr VideoInfo
val <- Ptr (Ptr VideoInfo) -> IO (Ptr VideoInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMetaTransform
ptr Ptr VideoMetaTransform -> Int -> Ptr (Ptr VideoInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr GstVideo.VideoInfo.VideoInfo)
    Maybe VideoInfo
result <- Ptr VideoInfo
-> (Ptr VideoInfo -> IO VideoInfo) -> IO (Maybe VideoInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr VideoInfo
val ((Ptr VideoInfo -> IO VideoInfo) -> IO (Maybe VideoInfo))
-> (Ptr VideoInfo -> IO VideoInfo) -> IO (Maybe VideoInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoInfo
val' -> do
        VideoInfo
val'' <- ((ManagedPtr VideoInfo -> VideoInfo)
-> Ptr VideoInfo -> IO VideoInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VideoInfo -> VideoInfo
GstVideo.VideoInfo.VideoInfo) Ptr VideoInfo
val'
        VideoInfo -> IO VideoInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoInfo
val''
    Maybe VideoInfo -> IO (Maybe VideoInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoInfo
result

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

-- | Set the value of the “@out_info@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #outInfo
-- @
clearVideoMetaTransformOutInfo :: MonadIO m => VideoMetaTransform -> m ()
clearVideoMetaTransformOutInfo :: forall (m :: * -> *). MonadIO m => VideoMetaTransform -> m ()
clearVideoMetaTransformOutInfo VideoMetaTransform
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMetaTransform -> (Ptr VideoMetaTransform -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMetaTransform
s ((Ptr VideoMetaTransform -> IO ()) -> IO ())
-> (Ptr VideoMetaTransform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMetaTransform
ptr -> do
    Ptr (Ptr VideoInfo) -> Ptr VideoInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMetaTransform
ptr Ptr VideoMetaTransform -> Int -> Ptr (Ptr VideoInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr VideoInfo
forall a. Ptr a
FP.nullPtr :: Ptr GstVideo.VideoInfo.VideoInfo)

#if defined(ENABLE_OVERLOADING)
data VideoMetaTransformOutInfoFieldInfo
instance AttrInfo VideoMetaTransformOutInfoFieldInfo where
    type AttrBaseTypeConstraint VideoMetaTransformOutInfoFieldInfo = (~) VideoMetaTransform
    type AttrAllowedOps VideoMetaTransformOutInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoMetaTransformOutInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo)
    type AttrTransferTypeConstraint VideoMetaTransformOutInfoFieldInfo = (~)(Ptr GstVideo.VideoInfo.VideoInfo)
    type AttrTransferType VideoMetaTransformOutInfoFieldInfo = (Ptr GstVideo.VideoInfo.VideoInfo)
    type AttrGetType VideoMetaTransformOutInfoFieldInfo = Maybe GstVideo.VideoInfo.VideoInfo
    type AttrLabel VideoMetaTransformOutInfoFieldInfo = "out_info"
    type AttrOrigin VideoMetaTransformOutInfoFieldInfo = VideoMetaTransform
    attrGet = getVideoMetaTransformOutInfo
    attrSet = setVideoMetaTransformOutInfo
    attrConstruct = undefined
    attrClear = clearVideoMetaTransformOutInfo
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoMetaTransform.outInfo"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoMetaTransform.html#g:attr:outInfo"
        })

videoMetaTransform_outInfo :: AttrLabelProxy "outInfo"
videoMetaTransform_outInfo = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoMetaTransform
type instance O.AttributeList VideoMetaTransform = VideoMetaTransformAttributeList
type VideoMetaTransformAttributeList = ('[ '("inInfo", VideoMetaTransformInInfoFieldInfo), '("outInfo", VideoMetaTransformOutInfoFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method VideoMetaTransform::scale_get_quark
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_meta_transform_scale_get_quark" gst_video_meta_transform_scale_get_quark :: 
    IO Word32

-- | Get the @/GQuark/@ for the \"gst-video-scale\" metadata transform operation.
videoMetaTransformScaleGetQuark ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Word32
    -- ^ __Returns:__ a @/GQuark/@
videoMetaTransformScaleGetQuark :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
videoMetaTransformScaleGetQuark  = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Word32
result <- IO Word32
gst_video_meta_transform_scale_get_quark
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoMetaTransformMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveVideoMetaTransformMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif