{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

Frame (context) data passed to each frame parsing virtual methods.  In
addition to providing the data to be checked for a valid frame or an already
identified frame, it conveys additional metadata or control information
from and to the subclass w.r.t. the particular frame in question (rather
than global parameters).  Some of these may apply to each parsing stage, others
only to some a particular one.  These parameters are effectively zeroed at start
of each frame\'s processing, i.e. parsing virtual method invocation sequence.
-}

module GI.GstBase.Structs.BaseParseFrame
    ( 

-- * Exported types
    BaseParseFrame(..)                      ,
    newZeroBaseParseFrame                   ,
    noBaseParseFrame                        ,


 -- * Methods
-- ** free #method:free#
    BaseParseFrameFreeMethodInfo            ,
    baseParseFrameFree                      ,


-- ** init #method:init#
    BaseParseFrameInitMethodInfo            ,
    baseParseFrameInit                      ,


-- ** new #method:new#
    baseParseFrameNew                       ,




 -- * Properties
-- ** buffer #attr:buffer#
    baseParseFrame_buffer                   ,
    clearBaseParseFrameBuffer               ,
    getBaseParseFrameBuffer                 ,
    setBaseParseFrameBuffer                 ,


-- ** flags #attr:flags#
    baseParseFrame_flags                    ,
    getBaseParseFrameFlags                  ,
    setBaseParseFrameFlags                  ,


-- ** offset #attr:offset#
    baseParseFrame_offset                   ,
    getBaseParseFrameOffset                 ,
    setBaseParseFrameOffset                 ,


-- ** outBuffer #attr:outBuffer#
    baseParseFrame_outBuffer                ,
    clearBaseParseFrameOutBuffer            ,
    getBaseParseFrameOutBuffer              ,
    setBaseParseFrameOutBuffer              ,


-- ** overhead #attr:overhead#
    baseParseFrame_overhead                 ,
    getBaseParseFrameOverhead               ,
    setBaseParseFrameOverhead               ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.Gst.Structs.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.GstBase.Flags as GstBase.Flags

newtype BaseParseFrame = BaseParseFrame (ManagedPtr BaseParseFrame)
foreign import ccall "gst_base_parse_frame_get_type" c_gst_base_parse_frame_get_type :: 
    IO GType

instance BoxedObject BaseParseFrame where
    boxedType _ = c_gst_base_parse_frame_get_type

-- | Construct a `BaseParseFrame` struct initialized to zero.
newZeroBaseParseFrame :: MonadIO m => m BaseParseFrame
newZeroBaseParseFrame = liftIO $ callocBoxedBytes 72 >>= wrapBoxed BaseParseFrame

instance tag ~ 'AttrSet => Constructible BaseParseFrame tag where
    new _ attrs = do
        o <- newZeroBaseParseFrame
        GI.Attributes.set o attrs
        return o


noBaseParseFrame :: Maybe BaseParseFrame
noBaseParseFrame = Nothing

getBaseParseFrameBuffer :: MonadIO m => BaseParseFrame -> m (Maybe Gst.Buffer.Buffer)
getBaseParseFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gst.Buffer.Buffer)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed Gst.Buffer.Buffer) val'
        return val''
    return result

setBaseParseFrameBuffer :: MonadIO m => BaseParseFrame -> Ptr Gst.Buffer.Buffer -> m ()
setBaseParseFrameBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Ptr Gst.Buffer.Buffer)

clearBaseParseFrameBuffer :: MonadIO m => BaseParseFrame -> m ()
clearBaseParseFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

data BaseParseFrameBufferFieldInfo
instance AttrInfo BaseParseFrameBufferFieldInfo where
    type AttrAllowedOps BaseParseFrameBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BaseParseFrameBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrBaseTypeConstraint BaseParseFrameBufferFieldInfo = (~) BaseParseFrame
    type AttrGetType BaseParseFrameBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel BaseParseFrameBufferFieldInfo = "buffer"
    type AttrOrigin BaseParseFrameBufferFieldInfo = BaseParseFrame
    attrGet _ = getBaseParseFrameBuffer
    attrSet _ = setBaseParseFrameBuffer
    attrConstruct = undefined
    attrClear _ = clearBaseParseFrameBuffer

baseParseFrame_buffer :: AttrLabelProxy "buffer"
baseParseFrame_buffer = AttrLabelProxy


getBaseParseFrameOutBuffer :: MonadIO m => BaseParseFrame -> m (Maybe Gst.Buffer.Buffer)
getBaseParseFrameOutBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gst.Buffer.Buffer)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed Gst.Buffer.Buffer) val'
        return val''
    return result

setBaseParseFrameOutBuffer :: MonadIO m => BaseParseFrame -> Ptr Gst.Buffer.Buffer -> m ()
setBaseParseFrameOutBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Ptr Gst.Buffer.Buffer)

clearBaseParseFrameOutBuffer :: MonadIO m => BaseParseFrame -> m ()
clearBaseParseFrameOutBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

data BaseParseFrameOutBufferFieldInfo
instance AttrInfo BaseParseFrameOutBufferFieldInfo where
    type AttrAllowedOps BaseParseFrameOutBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BaseParseFrameOutBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrBaseTypeConstraint BaseParseFrameOutBufferFieldInfo = (~) BaseParseFrame
    type AttrGetType BaseParseFrameOutBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel BaseParseFrameOutBufferFieldInfo = "out_buffer"
    type AttrOrigin BaseParseFrameOutBufferFieldInfo = BaseParseFrame
    attrGet _ = getBaseParseFrameOutBuffer
    attrSet _ = setBaseParseFrameOutBuffer
    attrConstruct = undefined
    attrClear _ = clearBaseParseFrameOutBuffer

baseParseFrame_outBuffer :: AttrLabelProxy "outBuffer"
baseParseFrame_outBuffer = AttrLabelProxy


getBaseParseFrameFlags :: MonadIO m => BaseParseFrame -> m Word32
getBaseParseFrameFlags s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word32
    return val

setBaseParseFrameFlags :: MonadIO m => BaseParseFrame -> Word32 -> m ()
setBaseParseFrameFlags s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Word32)

data BaseParseFrameFlagsFieldInfo
instance AttrInfo BaseParseFrameFlagsFieldInfo where
    type AttrAllowedOps BaseParseFrameFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BaseParseFrameFlagsFieldInfo = (~) Word32
    type AttrBaseTypeConstraint BaseParseFrameFlagsFieldInfo = (~) BaseParseFrame
    type AttrGetType BaseParseFrameFlagsFieldInfo = Word32
    type AttrLabel BaseParseFrameFlagsFieldInfo = "flags"
    type AttrOrigin BaseParseFrameFlagsFieldInfo = BaseParseFrame
    attrGet _ = getBaseParseFrameFlags
    attrSet _ = setBaseParseFrameFlags
    attrConstruct = undefined
    attrClear _ = undefined

baseParseFrame_flags :: AttrLabelProxy "flags"
baseParseFrame_flags = AttrLabelProxy


getBaseParseFrameOffset :: MonadIO m => BaseParseFrame -> m Word64
getBaseParseFrameOffset s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word64
    return val

setBaseParseFrameOffset :: MonadIO m => BaseParseFrame -> Word64 -> m ()
setBaseParseFrameOffset s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word64)

data BaseParseFrameOffsetFieldInfo
instance AttrInfo BaseParseFrameOffsetFieldInfo where
    type AttrAllowedOps BaseParseFrameOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BaseParseFrameOffsetFieldInfo = (~) Word64
    type AttrBaseTypeConstraint BaseParseFrameOffsetFieldInfo = (~) BaseParseFrame
    type AttrGetType BaseParseFrameOffsetFieldInfo = Word64
    type AttrLabel BaseParseFrameOffsetFieldInfo = "offset"
    type AttrOrigin BaseParseFrameOffsetFieldInfo = BaseParseFrame
    attrGet _ = getBaseParseFrameOffset
    attrSet _ = setBaseParseFrameOffset
    attrConstruct = undefined
    attrClear _ = undefined

baseParseFrame_offset :: AttrLabelProxy "offset"
baseParseFrame_offset = AttrLabelProxy


getBaseParseFrameOverhead :: MonadIO m => BaseParseFrame -> m Int32
getBaseParseFrameOverhead s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Int32
    return val

setBaseParseFrameOverhead :: MonadIO m => BaseParseFrame -> Int32 -> m ()
setBaseParseFrameOverhead s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Int32)

data BaseParseFrameOverheadFieldInfo
instance AttrInfo BaseParseFrameOverheadFieldInfo where
    type AttrAllowedOps BaseParseFrameOverheadFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BaseParseFrameOverheadFieldInfo = (~) Int32
    type AttrBaseTypeConstraint BaseParseFrameOverheadFieldInfo = (~) BaseParseFrame
    type AttrGetType BaseParseFrameOverheadFieldInfo = Int32
    type AttrLabel BaseParseFrameOverheadFieldInfo = "overhead"
    type AttrOrigin BaseParseFrameOverheadFieldInfo = BaseParseFrame
    attrGet _ = getBaseParseFrameOverhead
    attrSet _ = setBaseParseFrameOverhead
    attrConstruct = undefined
    attrClear _ = undefined

baseParseFrame_overhead :: AttrLabelProxy "overhead"
baseParseFrame_overhead = AttrLabelProxy



instance O.HasAttributeList BaseParseFrame
type instance O.AttributeList BaseParseFrame = BaseParseFrameAttributeList
type BaseParseFrameAttributeList = ('[ '("buffer", BaseParseFrameBufferFieldInfo), '("outBuffer", BaseParseFrameOutBufferFieldInfo), '("flags", BaseParseFrameFlagsFieldInfo), '("offset", BaseParseFrameOffsetFieldInfo), '("overhead", BaseParseFrameOverheadFieldInfo)] :: [(Symbol, *)])

-- method BaseParseFrame::new
-- method type : Constructor
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrameFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overhead", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in this frame which should be counted as\n    metadata overhead, ie. not used to calculate the average bitrate.\n    Set to -1 to mark the entire frame as metadata. If in doubt, set to 0.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_base_parse_frame_new" gst_base_parse_frame_new :: 
    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "GstBase", name = "BaseParseFrameFlags"})
    Int32 ->                                -- overhead : TBasicType TInt
    IO (Ptr BaseParseFrame)

{- |
Allocates a new 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'. This function is mainly for bindings,
elements written in C should usually allocate the frame on the stack and
then use 'GI.GstBase.Structs.BaseParseFrame.baseParseFrameInit' to initialise it.
-}
baseParseFrameNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gst.Buffer.Buffer
    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}
    -> [GstBase.Flags.BaseParseFrameFlags]
    {- ^ /@flags@/: the flags -}
    -> Int32
    {- ^ /@overhead@/: number of bytes in this frame which should be counted as
    metadata overhead, ie. not used to calculate the average bitrate.
    Set to -1 to mark the entire frame as metadata. If in doubt, set to 0. -}
    -> m BaseParseFrame
    {- ^ __Returns:__ a newly-allocated 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'. Free with
    'GI.GstBase.Structs.BaseParseFrame.baseParseFrameFree' when no longer needed. -}
baseParseFrameNew buffer flags overhead = liftIO $ do
    buffer' <- unsafeManagedPtrGetPtr buffer
    let flags' = gflagsToWord flags
    result <- gst_base_parse_frame_new buffer' flags' overhead
    checkUnexpectedReturnNULL "baseParseFrameNew" result
    result' <- (wrapBoxed BaseParseFrame) result
    touchManagedPtr buffer
    return result'

-- method BaseParseFrame::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_base_parse_frame_free" gst_base_parse_frame_free :: 
    Ptr BaseParseFrame ->                   -- frame : TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"})
    IO ()

{- |
/No description available in the introspection data./
-}
baseParseFrameFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BaseParseFrame
    -> m ()
baseParseFrameFree frame = liftIO $ do
    frame' <- unsafeManagedPtrGetPtr frame
    gst_base_parse_frame_free frame'
    touchManagedPtr frame
    return ()

data BaseParseFrameFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BaseParseFrameFreeMethodInfo BaseParseFrame signature where
    overloadedMethod _ = baseParseFrameFree

-- method BaseParseFrame::init
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstBaseParseFrame.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_base_parse_frame_init" gst_base_parse_frame_init :: 
    Ptr BaseParseFrame ->                   -- frame : TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"})
    IO ()

{- |
Sets a 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame' to initial state.  Currently this means
all public fields are zero-ed and a private flag is set to make
sure 'GI.GstBase.Structs.BaseParseFrame.baseParseFrameFree' only frees the contents but not
the actual frame. Use this function to initialise a 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'
allocated on the stack.
-}
baseParseFrameInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BaseParseFrame
    {- ^ /@frame@/: 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'. -}
    -> m ()
baseParseFrameInit frame = liftIO $ do
    frame' <- unsafeManagedPtrGetPtr frame
    gst_base_parse_frame_init frame'
    touchManagedPtr frame
    return ()

data BaseParseFrameInitMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BaseParseFrameInitMethodInfo BaseParseFrame signature where
    overloadedMethod _ = baseParseFrameInit

type family ResolveBaseParseFrameMethod (t :: Symbol) (o :: *) :: * where
    ResolveBaseParseFrameMethod "free" o = BaseParseFrameFreeMethodInfo
    ResolveBaseParseFrameMethod "init" o = BaseParseFrameInitMethodInfo
    ResolveBaseParseFrameMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBaseParseFrameMethod t BaseParseFrame, O.MethodInfo info BaseParseFrame p) => O.IsLabelProxy t (BaseParseFrame -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveBaseParseFrameMethod t BaseParseFrame, O.MethodInfo info BaseParseFrame p) => O.IsLabel t (BaseParseFrame -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif