{-# 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(..)                      ,
    noVideoConverter                        ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

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

-- | Memory-managed wrapper type.
newtype VideoConverter = VideoConverter (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)
-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance WrappedPtr VideoConverter where
    wrappedPtrCalloc :: IO (Ptr VideoConverter)
wrappedPtrCalloc = Ptr VideoConverter -> IO (Ptr VideoConverter)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VideoConverter
forall a. Ptr a
nullPtr
    wrappedPtrCopy :: VideoConverter -> IO VideoConverter
wrappedPtrCopy = VideoConverter -> IO VideoConverter
forall (m :: * -> *) a. Monad m => a -> m a
return
    wrappedPtrFree :: Maybe (GDestroyNotify VideoConverter)
wrappedPtrFree = Maybe (GDestroyNotify VideoConverter)
forall a. Maybe a
Nothing

-- | A convenience alias for `Nothing` :: `Maybe` `VideoConverter`.
noVideoConverter :: Maybe VideoConverter
noVideoConverter :: Maybe VideoConverter
noVideoConverter = Maybe VideoConverter
forall a. Maybe a
Nothing


#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 :: VideoConverter -> VideoFrame -> VideoFrame -> m ()
videoConverterFrame convert :: VideoConverter
convert src :: VideoFrame
src dest :: 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.MethodInfo VideoConverterFrameMethodInfo VideoConverter signature where
    overloadedMethod = 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 :: VideoConverter -> m ()
videoConverterFree convert :: 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.MethodInfo VideoConverterFreeMethodInfo VideoConverter signature where
    overloadedMethod = 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 :: VideoConverter -> m Structure
videoConverterGetConfig convert :: 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 "videoConverterGetConfig" Ptr Structure
result
    Structure
result' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, BoxedObject 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.MethodInfo VideoConverterGetConfigMethodInfo VideoConverter signature where
    overloadedMethod = 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 configuraion 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 :: VideoConverter -> Structure -> m Bool
videoConverterSetConfig convert :: VideoConverter
convert config :: 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, BoxedObject 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
/= 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.MethodInfo VideoConverterSetConfigMethodInfo VideoConverter signature where
    overloadedMethod = 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.MethodInfo 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

#endif