{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.GstVideo.Structs.VideoConverter
    ( 

-- * Exported types
    VideoConverter(..)                      ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [frame]("GI.GstVideo.Structs.VideoConverter#g:method:frame"), [free]("GI.GstVideo.Structs.VideoConverter#g:method:free").
-- 
-- ==== Getters
-- [getConfig]("GI.GstVideo.Structs.VideoConverter#g:method:getConfig").
-- 
-- ==== Setters
-- [setConfig]("GI.GstVideo.Structs.VideoConverter#g:method:setConfig").

#if defined(ENABLE_OVERLOADING)
    ResolveVideoConverterMethod             ,
#endif

-- ** frame #method:frame#

#if defined(ENABLE_OVERLOADING)
    VideoConverterFrameMethodInfo           ,
#endif
    videoConverterFrame                     ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    VideoConverterFreeMethodInfo            ,
#endif
    videoConverterFree                      ,


-- ** getConfig #method:getConfig#

#if defined(ENABLE_OVERLOADING)
    VideoConverterGetConfigMethodInfo       ,
#endif
    videoConverterGetConfig                 ,


-- ** setConfig #method:setConfig#

#if defined(ENABLE_OVERLOADING)
    VideoConverterSetConfigMethodInfo       ,
#endif
    videoConverterSetConfig                 ,




    ) 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.Structure as Gst.Structure
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFrame as GstVideo.VideoFrame

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

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

-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance BoxedPtr VideoConverter where
    boxedPtrCopy :: VideoConverter -> IO VideoConverter
boxedPtrCopy = VideoConverter -> IO VideoConverter
forall (m :: * -> *) a. Monad m => a -> m a
return
    boxedPtrFree :: VideoConverter -> IO ()
boxedPtrFree = \VideoConverter
_x -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoConverter
type instance O.AttributeList VideoConverter = VideoConverterAttributeList
type VideoConverterAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method VideoConverter::frame
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "convert"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoConverter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoConverter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "src"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "VideoFrame" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoFrame" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dest"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "VideoFrame" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoFrame" , 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_converter_frame" gst_video_converter_frame :: 
    Ptr VideoConverter ->                   -- convert : TInterface (Name {namespace = "GstVideo", name = "VideoConverter"})
    Ptr GstVideo.VideoFrame.VideoFrame ->   -- src : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"})
    Ptr GstVideo.VideoFrame.VideoFrame ->   -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"})
    IO ()

-- | Convert the pixels of /@src@/ into /@dest@/ using /@convert@/.
-- 
-- /Since: 1.6/
videoConverterFrame ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoConverter
    -- ^ /@convert@/: a t'GI.GstVideo.Structs.VideoConverter.VideoConverter'
    -> GstVideo.VideoFrame.VideoFrame
    -- ^ /@src@/: a t'GI.GstVideo.Structs.VideoFrame.VideoFrame'
    -> GstVideo.VideoFrame.VideoFrame
    -- ^ /@dest@/: a t'GI.GstVideo.Structs.VideoFrame.VideoFrame'
    -> m ()
videoConverterFrame :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoConverter -> VideoFrame -> VideoFrame -> m ()
videoConverterFrame VideoConverter
convert VideoFrame
src VideoFrame
dest = 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 VideoConverter
convert' <- VideoConverter -> IO (Ptr VideoConverter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoConverter
convert
    Ptr VideoFrame
src' <- VideoFrame -> IO (Ptr VideoFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoFrame
src
    Ptr VideoFrame
dest' <- VideoFrame -> IO (Ptr VideoFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoFrame
dest
    Ptr VideoConverter -> Ptr VideoFrame -> Ptr VideoFrame -> IO ()
gst_video_converter_frame Ptr VideoConverter
convert' Ptr VideoFrame
src' Ptr VideoFrame
dest'
    VideoConverter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoConverter
convert
    VideoFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoFrame
src
    VideoFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoFrame
dest
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoConverterFrameMethodInfo
instance (signature ~ (GstVideo.VideoFrame.VideoFrame -> GstVideo.VideoFrame.VideoFrame -> m ()), MonadIO m) => O.OverloadedMethod VideoConverterFrameMethodInfo VideoConverter signature where
    overloadedMethod = videoConverterFrame

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


#endif

-- method VideoConverter::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "convert"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoConverter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoConverter"
--                 , 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_converter_free" gst_video_converter_free :: 
    Ptr VideoConverter ->                   -- convert : TInterface (Name {namespace = "GstVideo", name = "VideoConverter"})
    IO ()

-- | Free /@convert@/
-- 
-- /Since: 1.6/
videoConverterFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoConverter
    -- ^ /@convert@/: a t'GI.GstVideo.Structs.VideoConverter.VideoConverter'
    -> m ()
videoConverterFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoConverter -> m ()
videoConverterFree VideoConverter
convert = 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 VideoConverter
convert' <- VideoConverter -> IO (Ptr VideoConverter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoConverter
convert
    Ptr VideoConverter -> IO ()
gst_video_converter_free Ptr VideoConverter
convert'
    VideoConverter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoConverter
convert
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoConverterFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VideoConverterFreeMethodInfo VideoConverter signature where
    overloadedMethod = videoConverterFree

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


#endif

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

foreign import ccall "gst_video_converter_get_config" gst_video_converter_get_config :: 
    Ptr VideoConverter ->                   -- convert : TInterface (Name {namespace = "GstVideo", name = "VideoConverter"})
    IO (Ptr Gst.Structure.Structure)

-- | Get the current configuration of /@convert@/.
videoConverterGetConfig ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoConverter
    -- ^ /@convert@/: a t'GI.GstVideo.Structs.VideoConverter.VideoConverter'
    -> m Gst.Structure.Structure
    -- ^ __Returns:__ a t'GI.Gst.Structs.Structure.Structure' that remains valid for as long as /@convert@/ is valid
    --   or until 'GI.GstVideo.Structs.VideoConverter.videoConverterSetConfig' is called.
videoConverterGetConfig :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoConverter -> m Structure
videoConverterGetConfig VideoConverter
convert = IO Structure -> m Structure
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Structure -> m Structure) -> IO Structure -> m Structure
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoConverter
convert' <- VideoConverter -> IO (Ptr VideoConverter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoConverter
convert
    Ptr Structure
result <- Ptr VideoConverter -> IO (Ptr Structure)
gst_video_converter_get_config Ptr VideoConverter
convert'
    Text -> Ptr Structure -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoConverterGetConfig" Ptr Structure
result
    Structure
result' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
result
    VideoConverter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoConverter
convert
    Structure -> IO Structure
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
result'

#if defined(ENABLE_OVERLOADING)
data VideoConverterGetConfigMethodInfo
instance (signature ~ (m Gst.Structure.Structure), MonadIO m) => O.OverloadedMethod VideoConverterGetConfigMethodInfo VideoConverter signature where
    overloadedMethod = videoConverterGetConfig

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


#endif

-- method VideoConverter::set_config
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "convert"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoConverter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoConverter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "config"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "Structure" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstStructure" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_converter_set_config" gst_video_converter_set_config :: 
    Ptr VideoConverter ->                   -- convert : TInterface (Name {namespace = "GstVideo", name = "VideoConverter"})
    Ptr Gst.Structure.Structure ->          -- config : TInterface (Name {namespace = "Gst", name = "Structure"})
    IO CInt

-- | Set /@config@/ as extra configuration for /@convert@/.
-- 
-- If the parameters in /@config@/ can not be set exactly, this function returns
-- 'P.False' and will try to update as much state as possible. The new state can
-- then be retrieved and refined with 'GI.GstVideo.Structs.VideoConverter.videoConverterGetConfig'.
-- 
-- Look at the @GST_VIDEO_CONVERTER_OPT_*@ fields to check valid configuration
-- option and values.
-- 
-- /Since: 1.6/
videoConverterSetConfig ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoConverter
    -- ^ /@convert@/: a t'GI.GstVideo.Structs.VideoConverter.VideoConverter'
    -> Gst.Structure.Structure
    -- ^ /@config@/: a t'GI.Gst.Structs.Structure.Structure'
    -> m Bool
    -- ^ __Returns:__ 'P.True' when /@config@/ could be set.
videoConverterSetConfig :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoConverter -> Structure -> m Bool
videoConverterSetConfig VideoConverter
convert Structure
config = 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 VideoConverter
convert' <- VideoConverter -> IO (Ptr VideoConverter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoConverter
convert
    Ptr Structure
config' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
config
    CInt
result <- Ptr VideoConverter -> Ptr Structure -> IO CInt
gst_video_converter_set_config Ptr VideoConverter
convert' Ptr Structure
config'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoConverter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoConverter
convert
    Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
config
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data VideoConverterSetConfigMethodInfo
instance (signature ~ (Gst.Structure.Structure -> m Bool), MonadIO m) => O.OverloadedMethod VideoConverterSetConfigMethodInfo VideoConverter signature where
    overloadedMethod = videoConverterSetConfig

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


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoConverterMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoConverterMethod "frame" o = VideoConverterFrameMethodInfo
    ResolveVideoConverterMethod "free" o = VideoConverterFreeMethodInfo
    ResolveVideoConverterMethod "getConfig" o = VideoConverterGetConfigMethodInfo
    ResolveVideoConverterMethod "setConfig" o = VideoConverterSetConfigMethodInfo
    ResolveVideoConverterMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif