Memory.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)

GstMemory is a lightweight refcounted object that wraps a region of memory.
They are typically used to manage the data of a 'GI.Gst.Structs.Buffer.Buffer'.

A GstMemory object has an allocated region of memory of maxsize. The maximum
size does not change during the lifetime of the memory object. The memory
also has an offset and size property that specifies the valid range of memory
in the allocated region.

Memory is usually created by allocators with a 'GI.Gst.Objects.Allocator.allocatorAlloc'
method call. When 'Nothing' is used as the allocator, the default allocator will
be used.

New allocators can be registered with 'GI.Gst.Objects.Allocator.allocatorRegister'.
Allocators are identified by name and can be retrieved with
'GI.Gst.Objects.Allocator.allocatorFind'. 'GI.Gst.Objects.Allocator.allocatorSetDefault' can be used to change the
default allocator.

New memory can be created with 'GI.Gst.Structs.Memory.memoryNewWrapped' that wraps the memory
allocated elsewhere.

Refcounting of the memory block is performed with @/gst_memory_ref()/@ and
@/gst_memory_unref()/@.

The size of the memory can be retrieved and changed with
'GI.Gst.Structs.Memory.memoryGetSizes' and 'GI.Gst.Structs.Memory.memoryResize' respectively.

Getting access to the data of the memory is performed with 'GI.Gst.Structs.Memory.memoryMap'.
The call will return a pointer to offset bytes into the region of memory.
After the memory access is completed, 'GI.Gst.Structs.Memory.memoryUnmap' should be called.

Memory can be copied with 'GI.Gst.Structs.Memory.memoryCopy', which will return a writable
copy. 'GI.Gst.Structs.Memory.memoryShare' will create a new memory block that shares the
memory with an existing memory block at a custom offset and with a custom
size.

Memory can be efficiently merged when 'GI.Gst.Structs.Memory.memoryIsSpan' returns 'True'.
-}

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

module GI.Gst.Structs.Memory
    ( 

-- * Exported types
    Memory(..)                              ,
    newZeroMemory                           ,
    noMemory                                ,


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

#if ENABLE_OVERLOADING
    MemoryCopyMethodInfo                    ,
#endif
    memoryCopy                              ,


-- ** getSizes #method:getSizes#

#if ENABLE_OVERLOADING
    MemoryGetSizesMethodInfo                ,
#endif
    memoryGetSizes                          ,


-- ** isSpan #method:isSpan#

#if ENABLE_OVERLOADING
    MemoryIsSpanMethodInfo                  ,
#endif
    memoryIsSpan                            ,


-- ** isType #method:isType#

#if ENABLE_OVERLOADING
    MemoryIsTypeMethodInfo                  ,
#endif
    memoryIsType                            ,


-- ** makeMapped #method:makeMapped#

#if ENABLE_OVERLOADING
    MemoryMakeMappedMethodInfo              ,
#endif
    memoryMakeMapped                        ,


-- ** map #method:map#

#if ENABLE_OVERLOADING
    MemoryMapMethodInfo                     ,
#endif
    memoryMap                               ,


-- ** newWrapped #method:newWrapped#

    memoryNewWrapped                        ,


-- ** resize #method:resize#

#if ENABLE_OVERLOADING
    MemoryResizeMethodInfo                  ,
#endif
    memoryResize                            ,


-- ** share #method:share#

#if ENABLE_OVERLOADING
    MemoryShareMethodInfo                   ,
#endif
    memoryShare                             ,


-- ** unmap #method:unmap#

#if ENABLE_OVERLOADING
    MemoryUnmapMethodInfo                   ,
#endif
    memoryUnmap                             ,




 -- * Properties
-- ** align #attr:align#
{- | the alignment of the memory
-}
    getMemoryAlign                          ,
#if ENABLE_OVERLOADING
    memory_align                            ,
#endif
    setMemoryAlign                          ,


-- ** allocator #attr:allocator#
{- | pointer to the 'GI.Gst.Objects.Allocator.Allocator'
-}
    clearMemoryAllocator                    ,
    getMemoryAllocator                      ,
#if ENABLE_OVERLOADING
    memory_allocator                        ,
#endif
    setMemoryAllocator                      ,


-- ** maxsize #attr:maxsize#
{- | the maximum size allocated
-}
    getMemoryMaxsize                        ,
#if ENABLE_OVERLOADING
    memory_maxsize                          ,
#endif
    setMemoryMaxsize                        ,


-- ** miniObject #attr:miniObject#
{- | parent structure
-}
    getMemoryMiniObject                     ,
#if ENABLE_OVERLOADING
    memory_miniObject                       ,
#endif


-- ** offset #attr:offset#
{- | the offset where valid data starts
-}
    getMemoryOffset                         ,
#if ENABLE_OVERLOADING
    memory_offset                           ,
#endif
    setMemoryOffset                         ,


-- ** parent #attr:parent#
{- | parent memory block
-}
    clearMemoryParent                       ,
    getMemoryParent                         ,
#if ENABLE_OVERLOADING
    memory_parent                           ,
#endif
    setMemoryParent                         ,


-- ** size #attr:size#
{- | the size of valid data
-}
    getMemorySize                           ,
#if ENABLE_OVERLOADING
    memory_size                             ,
#endif
    setMemorySize                           ,




    ) 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.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Allocator as Gst.Allocator
import {-# SOURCE #-} qualified GI.Gst.Structs.MapInfo as Gst.MapInfo
import {-# SOURCE #-} qualified GI.Gst.Structs.MiniObject as Gst.MiniObject

-- | Memory-managed wrapper type.
newtype Memory = Memory (ManagedPtr Memory)
foreign import ccall "gst_memory_get_type" c_gst_memory_get_type :: 
    IO GType

instance BoxedObject Memory where
    boxedType _ = c_gst_memory_get_type

-- | Construct a `Memory` struct initialized to zero.
newZeroMemory :: MonadIO m => m Memory
newZeroMemory = liftIO $ callocBoxedBytes 112 >>= wrapBoxed Memory

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


-- | A convenience alias for `Nothing` :: `Maybe` `Memory`.
noMemory :: Maybe Memory
noMemory = Nothing

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

@
'Data.GI.Base.Attributes.get' memory #miniObject
@
-}
getMemoryMiniObject :: MonadIO m => Memory -> m Gst.MiniObject.MiniObject
getMemoryMiniObject s = liftIO $ withManagedPtr s $ \ptr -> do
    let val = ptr `plusPtr` 0 :: (Ptr Gst.MiniObject.MiniObject)
    val' <- (newPtr Gst.MiniObject.MiniObject) val
    return val'

#if ENABLE_OVERLOADING
data MemoryMiniObjectFieldInfo
instance AttrInfo MemoryMiniObjectFieldInfo where
    type AttrAllowedOps MemoryMiniObjectFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint MemoryMiniObjectFieldInfo = (~) (Ptr Gst.MiniObject.MiniObject)
    type AttrBaseTypeConstraint MemoryMiniObjectFieldInfo = (~) Memory
    type AttrGetType MemoryMiniObjectFieldInfo = Gst.MiniObject.MiniObject
    type AttrLabel MemoryMiniObjectFieldInfo = "mini_object"
    type AttrOrigin MemoryMiniObjectFieldInfo = Memory
    attrGet _ = getMemoryMiniObject
    attrSet _ = undefined
    attrConstruct = undefined
    attrClear _ = undefined

memory_miniObject :: AttrLabelProxy "miniObject"
memory_miniObject = AttrLabelProxy

#endif


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

@
'Data.GI.Base.Attributes.get' memory #allocator
@
-}
getMemoryAllocator :: MonadIO m => Memory -> m (Maybe Gst.Allocator.Allocator)
getMemoryAllocator s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 64) :: IO (Ptr Gst.Allocator.Allocator)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Gst.Allocator.Allocator) val'
        return val''
    return result

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

@
'Data.GI.Base.Attributes.set' memory [ #allocator 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMemoryAllocator :: MonadIO m => Memory -> Ptr Gst.Allocator.Allocator -> m ()
setMemoryAllocator s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 64) (val :: Ptr Gst.Allocator.Allocator)

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

#if ENABLE_OVERLOADING
data MemoryAllocatorFieldInfo
instance AttrInfo MemoryAllocatorFieldInfo where
    type AttrAllowedOps MemoryAllocatorFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint MemoryAllocatorFieldInfo = (~) (Ptr Gst.Allocator.Allocator)
    type AttrBaseTypeConstraint MemoryAllocatorFieldInfo = (~) Memory
    type AttrGetType MemoryAllocatorFieldInfo = Maybe Gst.Allocator.Allocator
    type AttrLabel MemoryAllocatorFieldInfo = "allocator"
    type AttrOrigin MemoryAllocatorFieldInfo = Memory
    attrGet _ = getMemoryAllocator
    attrSet _ = setMemoryAllocator
    attrConstruct = undefined
    attrClear _ = clearMemoryAllocator

memory_allocator :: AttrLabelProxy "allocator"
memory_allocator = AttrLabelProxy

#endif


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

@
'Data.GI.Base.Attributes.get' memory #parent
@
-}
getMemoryParent :: MonadIO m => Memory -> m (Maybe Memory)
getMemoryParent s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 72) :: IO (Ptr Memory)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed Memory) val'
        return val''
    return result

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

@
'Data.GI.Base.Attributes.set' memory [ #parent 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMemoryParent :: MonadIO m => Memory -> Ptr Memory -> m ()
setMemoryParent s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 72) (val :: Ptr Memory)

{- |
Set the value of the “@parent@” 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' #parent
@
-}
clearMemoryParent :: MonadIO m => Memory -> m ()
clearMemoryParent s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 72) (FP.nullPtr :: Ptr Memory)

#if ENABLE_OVERLOADING
data MemoryParentFieldInfo
instance AttrInfo MemoryParentFieldInfo where
    type AttrAllowedOps MemoryParentFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint MemoryParentFieldInfo = (~) (Ptr Memory)
    type AttrBaseTypeConstraint MemoryParentFieldInfo = (~) Memory
    type AttrGetType MemoryParentFieldInfo = Maybe Memory
    type AttrLabel MemoryParentFieldInfo = "parent"
    type AttrOrigin MemoryParentFieldInfo = Memory
    attrGet _ = getMemoryParent
    attrSet _ = setMemoryParent
    attrConstruct = undefined
    attrClear _ = clearMemoryParent

memory_parent :: AttrLabelProxy "parent"
memory_parent = AttrLabelProxy

#endif


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

@
'Data.GI.Base.Attributes.get' memory #maxsize
@
-}
getMemoryMaxsize :: MonadIO m => Memory -> m Word64
getMemoryMaxsize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 80) :: IO Word64
    return val

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

@
'Data.GI.Base.Attributes.set' memory [ #maxsize 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMemoryMaxsize :: MonadIO m => Memory -> Word64 -> m ()
setMemoryMaxsize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 80) (val :: Word64)

#if ENABLE_OVERLOADING
data MemoryMaxsizeFieldInfo
instance AttrInfo MemoryMaxsizeFieldInfo where
    type AttrAllowedOps MemoryMaxsizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint MemoryMaxsizeFieldInfo = (~) Word64
    type AttrBaseTypeConstraint MemoryMaxsizeFieldInfo = (~) Memory
    type AttrGetType MemoryMaxsizeFieldInfo = Word64
    type AttrLabel MemoryMaxsizeFieldInfo = "maxsize"
    type AttrOrigin MemoryMaxsizeFieldInfo = Memory
    attrGet _ = getMemoryMaxsize
    attrSet _ = setMemoryMaxsize
    attrConstruct = undefined
    attrClear _ = undefined

memory_maxsize :: AttrLabelProxy "maxsize"
memory_maxsize = AttrLabelProxy

#endif


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

@
'Data.GI.Base.Attributes.get' memory #align
@
-}
getMemoryAlign :: MonadIO m => Memory -> m Word64
getMemoryAlign s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 88) :: IO Word64
    return val

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

@
'Data.GI.Base.Attributes.set' memory [ #align 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMemoryAlign :: MonadIO m => Memory -> Word64 -> m ()
setMemoryAlign s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 88) (val :: Word64)

#if ENABLE_OVERLOADING
data MemoryAlignFieldInfo
instance AttrInfo MemoryAlignFieldInfo where
    type AttrAllowedOps MemoryAlignFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint MemoryAlignFieldInfo = (~) Word64
    type AttrBaseTypeConstraint MemoryAlignFieldInfo = (~) Memory
    type AttrGetType MemoryAlignFieldInfo = Word64
    type AttrLabel MemoryAlignFieldInfo = "align"
    type AttrOrigin MemoryAlignFieldInfo = Memory
    attrGet _ = getMemoryAlign
    attrSet _ = setMemoryAlign
    attrConstruct = undefined
    attrClear _ = undefined

memory_align :: AttrLabelProxy "align"
memory_align = 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' memory #offset
@
-}
getMemoryOffset :: MonadIO m => Memory -> m Word64
getMemoryOffset s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 96) :: 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' memory [ #offset 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMemoryOffset :: MonadIO m => Memory -> Word64 -> m ()
setMemoryOffset s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 96) (val :: Word64)

#if ENABLE_OVERLOADING
data MemoryOffsetFieldInfo
instance AttrInfo MemoryOffsetFieldInfo where
    type AttrAllowedOps MemoryOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint MemoryOffsetFieldInfo = (~) Word64
    type AttrBaseTypeConstraint MemoryOffsetFieldInfo = (~) Memory
    type AttrGetType MemoryOffsetFieldInfo = Word64
    type AttrLabel MemoryOffsetFieldInfo = "offset"
    type AttrOrigin MemoryOffsetFieldInfo = Memory
    attrGet _ = getMemoryOffset
    attrSet _ = setMemoryOffset
    attrConstruct = undefined
    attrClear _ = undefined

memory_offset :: AttrLabelProxy "offset"
memory_offset = AttrLabelProxy

#endif


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

@
'Data.GI.Base.Attributes.get' memory #size
@
-}
getMemorySize :: MonadIO m => Memory -> m Word64
getMemorySize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 104) :: IO Word64
    return val

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

@
'Data.GI.Base.Attributes.set' memory [ #size 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMemorySize :: MonadIO m => Memory -> Word64 -> m ()
setMemorySize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 104) (val :: Word64)

#if ENABLE_OVERLOADING
data MemorySizeFieldInfo
instance AttrInfo MemorySizeFieldInfo where
    type AttrAllowedOps MemorySizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint MemorySizeFieldInfo = (~) Word64
    type AttrBaseTypeConstraint MemorySizeFieldInfo = (~) Memory
    type AttrGetType MemorySizeFieldInfo = Word64
    type AttrLabel MemorySizeFieldInfo = "size"
    type AttrOrigin MemorySizeFieldInfo = Memory
    attrGet _ = getMemorySize
    attrSet _ = setMemorySize
    attrConstruct = undefined
    attrClear _ = undefined

memory_size :: AttrLabelProxy "size"
memory_size = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList Memory
type instance O.AttributeList Memory = MemoryAttributeList
type MemoryAttributeList = ('[ '("miniObject", MemoryMiniObjectFieldInfo), '("allocator", MemoryAllocatorFieldInfo), '("parent", MemoryParentFieldInfo), '("maxsize", MemoryMaxsizeFieldInfo), '("align", MemoryAlignFieldInfo), '("offset", MemoryOffsetFieldInfo), '("size", MemorySizeFieldInfo)] :: [(Symbol, *)])
#endif

-- method Memory::new_wrapped
-- method type : Constructor
-- Args : [Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MemoryFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstMemoryFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 4 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "data to\n  wrap", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "allocated size of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "offset in @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of valid data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "called with @user_data when the memory is freed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of valid data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Memory"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_new_wrapped" gst_memory_new_wrapped :: 
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gst", name = "MemoryFlags"})
    Ptr Word8 ->                            -- data : TCArray False (-1) 4 (TBasicType TUInt8)
    Word64 ->                               -- maxsize : TBasicType TUInt64
    Word64 ->                               -- offset : TBasicType TUInt64
    Word64 ->                               -- size : TBasicType TUInt64
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO (Ptr Memory)

{- |
Allocate a new memory block that wraps the given /@data@/.

The prefix\/padding must be filled with 0 if /@flags@/ contains
@/GST_MEMORY_FLAG_ZERO_PREFIXED/@ and @/GST_MEMORY_FLAG_ZERO_PADDED/@ respectively.
-}
memoryNewWrapped ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    [Gst.Flags.MemoryFlags]
    {- ^ /@flags@/: 'GI.Gst.Flags.MemoryFlags' -}
    -> ByteString
    {- ^ /@data@/: data to
  wrap -}
    -> Word64
    {- ^ /@maxsize@/: allocated size of /@data@/ -}
    -> Word64
    {- ^ /@offset@/: offset in /@data@/ -}
    -> Maybe (GLib.Callbacks.DestroyNotify)
    {- ^ /@notify@/: called with /@userData@/ when the memory is freed -}
    -> m (Maybe Memory)
    {- ^ __Returns:__ a new 'GI.Gst.Structs.Memory.Memory'. -}
memoryNewWrapped flags data_ maxsize offset notify = liftIO $ do
    let size = fromIntegral $ B.length data_
    let flags' = gflagsToWord flags
    data_' <- packByteString data_
    maybeNotify <- case notify of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jNotify -> do
            ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
            jNotify' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrnotify) jNotify)
            poke ptrnotify jNotify'
            return jNotify'
    let userData = nullPtr
    result <- gst_memory_new_wrapped flags' data_' maxsize offset size userData maybeNotify
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Memory) result'
        return result''
    freeMem data_'
    return maybeResult

#if ENABLE_OVERLOADING
#endif

-- method Memory::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "offset to copy from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size to copy, or -1 to copy to the end of the memory region", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Memory"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_copy" gst_memory_copy :: 
    Ptr Memory ->                           -- mem : TInterface (Name {namespace = "Gst", name = "Memory"})
    Int64 ->                                -- offset : TBasicType TInt64
    Int64 ->                                -- size : TBasicType TInt64
    IO (Ptr Memory)

{- |
Return a copy of /@size@/ bytes from /@mem@/ starting from /@offset@/. This copy is
guaranteed to be writable. /@size@/ can be set to -1 to return a copy
from /@offset@/ to the end of the memory region.
-}
memoryCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> Int64
    {- ^ /@offset@/: offset to copy from -}
    -> Int64
    {- ^ /@size@/: size to copy, or -1 to copy to the end of the memory region -}
    -> m Memory
    {- ^ __Returns:__ a new 'GI.Gst.Structs.Memory.Memory'. -}
memoryCopy mem offset size = liftIO $ do
    mem' <- unsafeManagedPtrGetPtr mem
    result <- gst_memory_copy mem' offset size
    checkUnexpectedReturnNULL "memoryCopy" result
    result' <- (wrapBoxed Memory) result
    touchManagedPtr mem
    return result'

#if ENABLE_OVERLOADING
data MemoryCopyMethodInfo
instance (signature ~ (Int64 -> Int64 -> m Memory), MonadIO m) => O.MethodInfo MemoryCopyMethodInfo Memory signature where
    overloadedMethod _ = memoryCopy

#endif

-- method Memory::get_sizes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to maxsize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_get_sizes" gst_memory_get_sizes :: 
    Ptr Memory ->                           -- mem : TInterface (Name {namespace = "Gst", name = "Memory"})
    Ptr Word64 ->                           -- offset : TBasicType TUInt64
    Ptr Word64 ->                           -- maxsize : TBasicType TUInt64
    IO Word64

{- |
Get the current /@size@/, /@offset@/ and /@maxsize@/ of /@mem@/.
-}
memoryGetSizes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> m ((Word64, Word64, Word64))
    {- ^ __Returns:__ the current sizes of /@mem@/ -}
memoryGetSizes mem = liftIO $ do
    mem' <- unsafeManagedPtrGetPtr mem
    offset <- allocMem :: IO (Ptr Word64)
    maxsize <- allocMem :: IO (Ptr Word64)
    result <- gst_memory_get_sizes mem' offset maxsize
    offset' <- peek offset
    maxsize' <- peek maxsize
    touchManagedPtr mem
    freeMem offset
    freeMem maxsize
    return (result, offset', maxsize')

#if ENABLE_OVERLOADING
data MemoryGetSizesMethodInfo
instance (signature ~ (m ((Word64, Word64, Word64))), MonadIO m) => O.MethodInfo MemoryGetSizesMethodInfo Memory signature where
    overloadedMethod _ = memoryGetSizes

#endif

-- method Memory::is_span
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem1", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem2", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a result offset", 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_memory_is_span" gst_memory_is_span :: 
    Ptr Memory ->                           -- mem1 : TInterface (Name {namespace = "Gst", name = "Memory"})
    Ptr Memory ->                           -- mem2 : TInterface (Name {namespace = "Gst", name = "Memory"})
    Ptr Word64 ->                           -- offset : TBasicType TUInt64
    IO CInt

{- |
Check if /@mem1@/ and mem2 share the memory with a common parent memory object
and that the memory is contiguous.

If this is the case, the memory of /@mem1@/ and /@mem2@/ can be merged
efficiently by performing 'GI.Gst.Structs.Memory.memoryShare' on the parent object from
the returned /@offset@/.
-}
memoryIsSpan ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem1@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> Memory
    {- ^ /@mem2@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> m ((Bool, Word64))
    {- ^ __Returns:__ 'True' if the memory is contiguous and of a common parent. -}
memoryIsSpan mem1 mem2 = liftIO $ do
    mem1' <- unsafeManagedPtrGetPtr mem1
    mem2' <- unsafeManagedPtrGetPtr mem2
    offset <- allocMem :: IO (Ptr Word64)
    result <- gst_memory_is_span mem1' mem2' offset
    let result' = (/= 0) result
    offset' <- peek offset
    touchManagedPtr mem1
    touchManagedPtr mem2
    freeMem offset
    return (result', offset')

#if ENABLE_OVERLOADING
data MemoryIsSpanMethodInfo
instance (signature ~ (Memory -> m ((Bool, Word64))), MonadIO m) => O.MethodInfo MemoryIsSpanMethodInfo Memory signature where
    overloadedMethod _ = memoryIsSpan

#endif

-- method Memory::is_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a memory type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_is_type" gst_memory_is_type :: 
    Ptr Memory ->                           -- mem : TInterface (Name {namespace = "Gst", name = "Memory"})
    CString ->                              -- mem_type : TBasicType TUTF8
    IO CInt

{- |
Check if /@mem@/ if allocated with an allocator for /@memType@/.

/Since: 1.2/
-}
memoryIsType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> T.Text
    {- ^ /@memType@/: a memory type -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@mem@/ was allocated from an allocator for /@memType@/. -}
memoryIsType mem memType = liftIO $ do
    mem' <- unsafeManagedPtrGetPtr mem
    memType' <- textToCString memType
    result <- gst_memory_is_type mem' memType'
    let result' = (/= 0) result
    touchManagedPtr mem
    freeMem memType'
    return result'

#if ENABLE_OVERLOADING
data MemoryIsTypeMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo MemoryIsTypeMethodInfo Memory signature where
    overloadedMethod _ = memoryIsType

#endif

-- method Memory::make_mapped
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer for info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "mapping flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Memory"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_make_mapped" gst_memory_make_mapped :: 
    Ptr Memory ->                           -- mem : TInterface (Name {namespace = "Gst", name = "Memory"})
    Ptr Gst.MapInfo.MapInfo ->              -- info : TInterface (Name {namespace = "Gst", name = "MapInfo"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gst", name = "MapFlags"})
    IO (Ptr Memory)

{- |
Create a 'GI.Gst.Structs.Memory.Memory' object that is mapped with /@flags@/. If /@mem@/ is mappable
with /@flags@/, this function returns the mapped /@mem@/ directly. Otherwise a
mapped copy of /@mem@/ is returned.

This function takes ownership of old /@mem@/ and returns a reference to a new
'GI.Gst.Structs.Memory.Memory'.
-}
memoryMakeMapped ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> [Gst.Flags.MapFlags]
    {- ^ /@flags@/: mapping flags -}
    -> m ((Maybe Memory, Gst.MapInfo.MapInfo))
    {- ^ __Returns:__ a 'GI.Gst.Structs.Memory.Memory' object mapped
with /@flags@/ or 'Nothing' when a mapping is not possible. -}
memoryMakeMapped mem flags = liftIO $ do
    mem' <- B.ManagedPtr.disownBoxed mem
    info <- callocBytes 104 :: IO (Ptr Gst.MapInfo.MapInfo)
    let flags' = gflagsToWord flags
    result <- gst_memory_make_mapped mem' info flags'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Memory) result'
        return result''
    info' <- (wrapPtr Gst.MapInfo.MapInfo) info
    touchManagedPtr mem
    return (maybeResult, info')

#if ENABLE_OVERLOADING
data MemoryMakeMappedMethodInfo
instance (signature ~ ([Gst.Flags.MapFlags] -> m ((Maybe Memory, Gst.MapInfo.MapInfo))), MonadIO m) => O.MethodInfo MemoryMakeMappedMethodInfo Memory signature where
    overloadedMethod _ = memoryMakeMapped

#endif

-- method Memory::map
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer for info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "mapping flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_map" gst_memory_map :: 
    Ptr Memory ->                           -- mem : TInterface (Name {namespace = "Gst", name = "Memory"})
    Ptr Gst.MapInfo.MapInfo ->              -- info : TInterface (Name {namespace = "Gst", name = "MapInfo"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gst", name = "MapFlags"})
    IO CInt

{- |
Fill /@info@/ with the pointer and sizes of the memory in /@mem@/ that can be
accessed according to /@flags@/.

This function can return 'False' for various reasons:

* the memory backed by /@mem@/ is not accessible with the given /@flags@/.
* the memory was already mapped with a different mapping.


/@info@/ and its contents remain valid for as long as /@mem@/ is valid and
until 'GI.Gst.Structs.Memory.memoryUnmap' is called.

For each 'GI.Gst.Structs.Memory.memoryMap' call, a corresponding 'GI.Gst.Structs.Memory.memoryUnmap' call
should be done.
-}
memoryMap ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> [Gst.Flags.MapFlags]
    {- ^ /@flags@/: mapping flags -}
    -> m ((Bool, Gst.MapInfo.MapInfo))
    {- ^ __Returns:__ 'True' if the map operation was successful. -}
memoryMap mem flags = liftIO $ do
    mem' <- unsafeManagedPtrGetPtr mem
    info <- callocBytes 104 :: IO (Ptr Gst.MapInfo.MapInfo)
    let flags' = gflagsToWord flags
    result <- gst_memory_map mem' info flags'
    let result' = (/= 0) result
    info' <- (wrapPtr Gst.MapInfo.MapInfo) info
    touchManagedPtr mem
    return (result', info')

#if ENABLE_OVERLOADING
data MemoryMapMethodInfo
instance (signature ~ ([Gst.Flags.MapFlags] -> m ((Bool, Gst.MapInfo.MapInfo))), MonadIO m) => O.MethodInfo MemoryMapMethodInfo Memory signature where
    overloadedMethod _ = memoryMap

#endif

-- method Memory::resize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a new offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a new size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_resize" gst_memory_resize :: 
    Ptr Memory ->                           -- mem : TInterface (Name {namespace = "Gst", name = "Memory"})
    Int64 ->                                -- offset : TBasicType TInt64
    Word64 ->                               -- size : TBasicType TUInt64
    IO ()

{- |
Resize the memory region. /@mem@/ should be writable and offset + size should be
less than the maxsize of /@mem@/.

@/GST_MEMORY_FLAG_ZERO_PREFIXED/@ and @/GST_MEMORY_FLAG_ZERO_PADDED/@ will be
cleared when offset or padding is increased respectively.
-}
memoryResize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> Int64
    {- ^ /@offset@/: a new offset -}
    -> Word64
    {- ^ /@size@/: a new size -}
    -> m ()
memoryResize mem offset size = liftIO $ do
    mem' <- unsafeManagedPtrGetPtr mem
    gst_memory_resize mem' offset size
    touchManagedPtr mem
    return ()

#if ENABLE_OVERLOADING
data MemoryResizeMethodInfo
instance (signature ~ (Int64 -> Word64 -> m ()), MonadIO m) => O.MethodInfo MemoryResizeMethodInfo Memory signature where
    overloadedMethod _ = memoryResize

#endif

-- method Memory::share
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "offset to share from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size to share, or -1 to share to the end of the memory region", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Memory"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_share" gst_memory_share :: 
    Ptr Memory ->                           -- mem : TInterface (Name {namespace = "Gst", name = "Memory"})
    Int64 ->                                -- offset : TBasicType TInt64
    Int64 ->                                -- size : TBasicType TInt64
    IO (Ptr Memory)

{- |
Return a shared copy of /@size@/ bytes from /@mem@/ starting from /@offset@/. No
memory copy is performed and the memory region is simply shared. The result
is guaranteed to be non-writable. /@size@/ can be set to -1 to return a shared
copy from /@offset@/ to the end of the memory region.
-}
memoryShare ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> Int64
    {- ^ /@offset@/: offset to share from -}
    -> Int64
    {- ^ /@size@/: size to share, or -1 to share to the end of the memory region -}
    -> m Memory
    {- ^ __Returns:__ a new 'GI.Gst.Structs.Memory.Memory'. -}
memoryShare mem offset size = liftIO $ do
    mem' <- unsafeManagedPtrGetPtr mem
    result <- gst_memory_share mem' offset size
    checkUnexpectedReturnNULL "memoryShare" result
    result' <- (wrapBoxed Memory) result
    touchManagedPtr mem
    return result'

#if ENABLE_OVERLOADING
data MemoryShareMethodInfo
instance (signature ~ (Int64 -> Int64 -> m Memory), MonadIO m) => O.MethodInfo MemoryShareMethodInfo Memory signature where
    overloadedMethod _ = memoryShare

#endif

-- method Memory::unmap
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "mem", argType = TInterface (Name {namespace = "Gst", name = "Memory"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMemory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMapInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_memory_unmap" gst_memory_unmap :: 
    Ptr Memory ->                           -- mem : TInterface (Name {namespace = "Gst", name = "Memory"})
    Ptr Gst.MapInfo.MapInfo ->              -- info : TInterface (Name {namespace = "Gst", name = "MapInfo"})
    IO ()

{- |
Release the memory obtained with 'GI.Gst.Structs.Memory.memoryMap'
-}
memoryUnmap ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Memory
    {- ^ /@mem@/: a 'GI.Gst.Structs.Memory.Memory' -}
    -> Gst.MapInfo.MapInfo
    {- ^ /@info@/: a 'GI.Gst.Structs.MapInfo.MapInfo' -}
    -> m ()
memoryUnmap mem info = liftIO $ do
    mem' <- unsafeManagedPtrGetPtr mem
    info' <- unsafeManagedPtrGetPtr info
    gst_memory_unmap mem' info'
    touchManagedPtr mem
    touchManagedPtr info
    return ()

#if ENABLE_OVERLOADING
data MemoryUnmapMethodInfo
instance (signature ~ (Gst.MapInfo.MapInfo -> m ()), MonadIO m) => O.MethodInfo MemoryUnmapMethodInfo Memory signature where
    overloadedMethod _ = memoryUnmap

#endif

#if ENABLE_OVERLOADING
type family ResolveMemoryMethod (t :: Symbol) (o :: *) :: * where
    ResolveMemoryMethod "copy" o = MemoryCopyMethodInfo
    ResolveMemoryMethod "isSpan" o = MemoryIsSpanMethodInfo
    ResolveMemoryMethod "isType" o = MemoryIsTypeMethodInfo
    ResolveMemoryMethod "makeMapped" o = MemoryMakeMappedMethodInfo
    ResolveMemoryMethod "map" o = MemoryMapMethodInfo
    ResolveMemoryMethod "resize" o = MemoryResizeMethodInfo
    ResolveMemoryMethod "share" o = MemoryShareMethodInfo
    ResolveMemoryMethod "unmap" o = MemoryUnmapMethodInfo
    ResolveMemoryMethod "getSizes" o = MemoryGetSizesMethodInfo
    ResolveMemoryMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveMemoryMethod t Memory, O.MethodInfo info Memory p) => OL.IsLabel t (Memory -> 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