gi-gstbase-1.0.18: GI/GstBase/Structs/BaseParseFrame.hs

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

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.
-}

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

module GI.GstBase.Structs.BaseParseFrame
    ( 

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


 -- * Methods
-- ** copy #method:copy#

#if ENABLE_OVERLOADING
    BaseParseFrameCopyMethodInfo            ,
#endif
    baseParseFrameCopy                      ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    BaseParseFrameFreeMethodInfo            ,
#endif
    baseParseFrameFree                      ,


-- ** init #method:init#

#if ENABLE_OVERLOADING
    BaseParseFrameInitMethodInfo            ,
#endif
    baseParseFrameInit                      ,


-- ** new #method:new#

    baseParseFrameNew                       ,




 -- * Properties
-- ** buffer #attr:buffer#
{- | input data to be parsed for frames.
-}
#if ENABLE_OVERLOADING
    baseParseFrame_buffer                   ,
#endif
    clearBaseParseFrameBuffer               ,
    getBaseParseFrameBuffer                 ,
    setBaseParseFrameBuffer                 ,


-- ** flags #attr:flags#
{- | a combination of input and output 'GI.GstBase.Flags.BaseParseFrameFlags' that
 convey additional context to subclass or allow subclass to tune
 subsequent 'GI.GstBase.Objects.BaseParse.BaseParse' actions.
-}
#if ENABLE_OVERLOADING
    baseParseFrame_flags                    ,
#endif
    getBaseParseFrameFlags                  ,
    setBaseParseFrameFlags                  ,


-- ** offset #attr:offset#
{- | media specific offset of input frame
  Note that a converter may have a different one on the frame\'s buffer.
-}
#if ENABLE_OVERLOADING
    baseParseFrame_offset                   ,
#endif
    getBaseParseFrameOffset                 ,
    setBaseParseFrameOffset                 ,


-- ** outBuffer #attr:outBuffer#
{- | output data.
-}
#if ENABLE_OVERLOADING
    baseParseFrame_outBuffer                ,
#endif
    clearBaseParseFrameOutBuffer            ,
    getBaseParseFrameOutBuffer              ,
    setBaseParseFrameOutBuffer              ,


-- ** overhead #attr:overhead#
{- | subclass can set this to indicates the metadata overhead
  for the given frame, which is then used to enable more accurate bitrate
  computations. If this is -1, it is assumed that this frame should be
  skipped in bitrate calculation.
-}
#if ENABLE_OVERLOADING
    baseParseFrame_overhead                 ,
#endif
    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.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.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.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.GstBase.Flags as GstBase.Flags

-- | Memory-managed wrapper type.
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


-- | A convenience alias for `Nothing` :: `Maybe` `BaseParseFrame`.
noBaseParseFrame :: Maybe BaseParseFrame
noBaseParseFrame = Nothing

{- |
Get the value of the “@buffer@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' baseParseFrame #buffer
@
-}
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

{- |
Set the value of the “@buffer@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' baseParseFrame [ #buffer 'Data.GI.Base.Attributes.:=' value ]
@
-}
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)

{- |
Set the value of the “@buffer@” 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' #buffer
@
-}
clearBaseParseFrameBuffer :: MonadIO m => BaseParseFrame -> m ()
clearBaseParseFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if ENABLE_OVERLOADING
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

#endif


{- |
Get the value of the “@out_buffer@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' baseParseFrame #outBuffer
@
-}
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

{- |
Set the value of the “@out_buffer@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' baseParseFrame [ #outBuffer 'Data.GI.Base.Attributes.:=' value ]
@
-}
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)

{- |
Set the value of the “@out_buffer@” 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' #outBuffer
@
-}
clearBaseParseFrameOutBuffer :: MonadIO m => BaseParseFrame -> m ()
clearBaseParseFrameOutBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if ENABLE_OVERLOADING
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

#endif


{- |
Get the value of the “@flags@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' baseParseFrame #flags
@
-}
getBaseParseFrameFlags :: MonadIO m => BaseParseFrame -> m Word32
getBaseParseFrameFlags s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word32
    return val

{- |
Set the value of the “@flags@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' baseParseFrame [ #flags 'Data.GI.Base.Attributes.:=' value ]
@
-}
setBaseParseFrameFlags :: MonadIO m => BaseParseFrame -> Word32 -> m ()
setBaseParseFrameFlags s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Word32)

#if ENABLE_OVERLOADING
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

#endif


{- |
Get the value of the “@offset@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' baseParseFrame #offset
@
-}
getBaseParseFrameOffset :: MonadIO m => BaseParseFrame -> m Word64
getBaseParseFrameOffset s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word64
    return val

{- |
Set the value of the “@offset@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' baseParseFrame [ #offset 'Data.GI.Base.Attributes.:=' value ]
@
-}
setBaseParseFrameOffset :: MonadIO m => BaseParseFrame -> Word64 -> m ()
setBaseParseFrameOffset s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word64)

#if ENABLE_OVERLOADING
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

#endif


{- |
Get the value of the “@overhead@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' baseParseFrame #overhead
@
-}
getBaseParseFrameOverhead :: MonadIO m => BaseParseFrame -> m Int32
getBaseParseFrameOverhead s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Int32
    return val

{- |
Set the value of the “@overhead@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' baseParseFrame [ #overhead 'Data.GI.Base.Attributes.:=' value ]
@
-}
setBaseParseFrameOverhead :: MonadIO m => BaseParseFrame -> Int32 -> m ()
setBaseParseFrameOverhead s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Int32)

#if ENABLE_OVERLOADING
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

#endif



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

-- 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'

#if ENABLE_OVERLOADING
#endif

-- method BaseParseFrame::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBaseParseFrame", 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_copy" gst_base_parse_frame_copy :: 
    Ptr BaseParseFrame ->                   -- frame : TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"})
    IO (Ptr BaseParseFrame)

{- |
Copies a 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame'.
-}
baseParseFrameCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BaseParseFrame
    {- ^ /@frame@/: a 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame' -}
    -> m BaseParseFrame
    {- ^ __Returns:__ A copy of /@frame@/ -}
baseParseFrameCopy frame = liftIO $ do
    frame' <- unsafeManagedPtrGetPtr frame
    result <- gst_base_parse_frame_copy frame'
    checkUnexpectedReturnNULL "baseParseFrameCopy" result
    result' <- (wrapBoxed BaseParseFrame) result
    touchManagedPtr frame
    return result'

#if ENABLE_OVERLOADING
data BaseParseFrameCopyMethodInfo
instance (signature ~ (m BaseParseFrame), MonadIO m) => O.MethodInfo BaseParseFrameCopyMethodInfo BaseParseFrame signature where
    overloadedMethod _ = baseParseFrameCopy

#endif

-- method BaseParseFrame::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #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_free" gst_base_parse_frame_free :: 
    Ptr BaseParseFrame ->                   -- frame : TInterface (Name {namespace = "GstBase", name = "BaseParseFrame"})
    IO ()

{- |
Frees the provided /@frame@/.
-}
baseParseFrameFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BaseParseFrame
    {- ^ /@frame@/: A 'GI.GstBase.Structs.BaseParseFrame.BaseParseFrame' -}
    -> m ()
baseParseFrameFree frame = liftIO $ do
    frame' <- unsafeManagedPtrGetPtr frame
    gst_base_parse_frame_free frame'
    touchManagedPtr frame
    return ()

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

#endif

-- 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 ()

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

#endif

#if ENABLE_OVERLOADING
type family ResolveBaseParseFrameMethod (t :: Symbol) (o :: *) :: * where
    ResolveBaseParseFrameMethod "copy" o = BaseParseFrameCopyMethodInfo
    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) => OL.IsLabel t (BaseParseFrame -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif