{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A video frame obtained from 'GI.GstVideo.Structs.VideoFrame.videoFrameMap' -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.GstVideo.Structs.VideoFrame ( -- * Exported types VideoFrame(..) , newZeroVideoFrame , noVideoFrame , -- * Methods -- ** copy #method:copy# #if ENABLE_OVERLOADING VideoFrameCopyMethodInfo , #endif videoFrameCopy , -- ** copyPlane #method:copyPlane# #if ENABLE_OVERLOADING VideoFrameCopyPlaneMethodInfo , #endif videoFrameCopyPlane , -- ** map #method:map# #if ENABLE_OVERLOADING VideoFrameMapMethodInfo , #endif videoFrameMap , -- ** mapId #method:mapId# #if ENABLE_OVERLOADING VideoFrameMapIdMethodInfo , #endif videoFrameMapId , -- ** unmap #method:unmap# #if ENABLE_OVERLOADING VideoFrameUnmapMethodInfo , #endif videoFrameUnmap , -- * Properties -- ** buffer #attr:buffer# {- | the mapped buffer -} clearVideoFrameBuffer , getVideoFrameBuffer , setVideoFrameBuffer , #if ENABLE_OVERLOADING videoFrame_buffer , #endif -- ** flags #attr:flags# {- | 'GI.GstVideo.Flags.VideoFrameFlags' for the frame -} getVideoFrameFlags , setVideoFrameFlags , #if ENABLE_OVERLOADING videoFrame_flags , #endif -- ** id #attr:id# {- | id of the mapped frame. the id can for example be used to indentify the frame in case of multiview video. -} getVideoFrameId , setVideoFrameId , #if ENABLE_OVERLOADING videoFrame_id , #endif -- ** info #attr:info# {- | the 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} getVideoFrameInfo , #if ENABLE_OVERLOADING videoFrame_info , #endif -- ** meta #attr:meta# {- | pointer to metadata if any -} clearVideoFrameMeta , getVideoFrameMeta , setVideoFrameMeta , #if ENABLE_OVERLOADING videoFrame_meta , #endif ) 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.Flags as Gst.Flags import qualified GI.Gst.Structs.Buffer as Gst.Buffer import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo -- | Memory-managed wrapper type. newtype VideoFrame = VideoFrame (ManagedPtr VideoFrame) instance WrappedPtr VideoFrame where wrappedPtrCalloc = callocBytes 632 wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 632 >=> wrapPtr VideoFrame) wrappedPtrFree = Just ptr_to_g_free -- | Construct a `VideoFrame` struct initialized to zero. newZeroVideoFrame :: MonadIO m => m VideoFrame newZeroVideoFrame = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoFrame instance tag ~ 'AttrSet => Constructible VideoFrame tag where new _ attrs = do o <- newZeroVideoFrame GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `VideoFrame`. noVideoFrame :: Maybe VideoFrame noVideoFrame = Nothing {- | Get the value of the “@info@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' videoFrame #info @ -} getVideoFrameInfo :: MonadIO m => VideoFrame -> m GstVideo.VideoInfo.VideoInfo getVideoFrameInfo s = liftIO $ withManagedPtr s $ \ptr -> do let val = ptr `plusPtr` 0 :: (Ptr GstVideo.VideoInfo.VideoInfo) val' <- (newBoxed GstVideo.VideoInfo.VideoInfo) val return val' #if ENABLE_OVERLOADING data VideoFrameInfoFieldInfo instance AttrInfo VideoFrameInfoFieldInfo where type AttrAllowedOps VideoFrameInfoFieldInfo = '[ 'AttrGet] type AttrSetTypeConstraint VideoFrameInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo) type AttrBaseTypeConstraint VideoFrameInfoFieldInfo = (~) VideoFrame type AttrGetType VideoFrameInfoFieldInfo = GstVideo.VideoInfo.VideoInfo type AttrLabel VideoFrameInfoFieldInfo = "info" type AttrOrigin VideoFrameInfoFieldInfo = VideoFrame attrGet _ = getVideoFrameInfo attrSet _ = undefined attrConstruct = undefined attrClear _ = undefined videoFrame_info :: AttrLabelProxy "info" videoFrame_info = 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' videoFrame #flags @ -} getVideoFrameFlags :: MonadIO m => VideoFrame -> m [GstVideo.Flags.VideoFrameFlags] getVideoFrameFlags s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 120) :: IO CUInt let val' = wordToGFlags val 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' videoFrame [ #flags 'Data.GI.Base.Attributes.:=' value ] @ -} setVideoFrameFlags :: MonadIO m => VideoFrame -> [GstVideo.Flags.VideoFrameFlags] -> m () setVideoFrameFlags s val = liftIO $ withManagedPtr s $ \ptr -> do let val' = gflagsToWord val poke (ptr `plusPtr` 120) (val' :: CUInt) #if ENABLE_OVERLOADING data VideoFrameFlagsFieldInfo instance AttrInfo VideoFrameFlagsFieldInfo where type AttrAllowedOps VideoFrameFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint VideoFrameFlagsFieldInfo = (~) [GstVideo.Flags.VideoFrameFlags] type AttrBaseTypeConstraint VideoFrameFlagsFieldInfo = (~) VideoFrame type AttrGetType VideoFrameFlagsFieldInfo = [GstVideo.Flags.VideoFrameFlags] type AttrLabel VideoFrameFlagsFieldInfo = "flags" type AttrOrigin VideoFrameFlagsFieldInfo = VideoFrame attrGet _ = getVideoFrameFlags attrSet _ = setVideoFrameFlags attrConstruct = undefined attrClear _ = undefined videoFrame_flags :: AttrLabelProxy "flags" videoFrame_flags = AttrLabelProxy #endif {- | 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' videoFrame #buffer @ -} getVideoFrameBuffer :: MonadIO m => VideoFrame -> m (Maybe Gst.Buffer.Buffer) getVideoFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 128) :: 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' videoFrame [ #buffer 'Data.GI.Base.Attributes.:=' value ] @ -} setVideoFrameBuffer :: MonadIO m => VideoFrame -> Ptr Gst.Buffer.Buffer -> m () setVideoFrameBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 128) (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 @ -} clearVideoFrameBuffer :: MonadIO m => VideoFrame -> m () clearVideoFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 128) (FP.nullPtr :: Ptr Gst.Buffer.Buffer) #if ENABLE_OVERLOADING data VideoFrameBufferFieldInfo instance AttrInfo VideoFrameBufferFieldInfo where type AttrAllowedOps VideoFrameBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint VideoFrameBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer) type AttrBaseTypeConstraint VideoFrameBufferFieldInfo = (~) VideoFrame type AttrGetType VideoFrameBufferFieldInfo = Maybe Gst.Buffer.Buffer type AttrLabel VideoFrameBufferFieldInfo = "buffer" type AttrOrigin VideoFrameBufferFieldInfo = VideoFrame attrGet _ = getVideoFrameBuffer attrSet _ = setVideoFrameBuffer attrConstruct = undefined attrClear _ = clearVideoFrameBuffer videoFrame_buffer :: AttrLabelProxy "buffer" videoFrame_buffer = AttrLabelProxy #endif {- | Get the value of the “@meta@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' videoFrame #meta @ -} getVideoFrameMeta :: MonadIO m => VideoFrame -> m (Ptr ()) getVideoFrameMeta s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 136) :: IO (Ptr ()) return val {- | Set the value of the “@meta@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' videoFrame [ #meta 'Data.GI.Base.Attributes.:=' value ] @ -} setVideoFrameMeta :: MonadIO m => VideoFrame -> Ptr () -> m () setVideoFrameMeta s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 136) (val :: Ptr ()) {- | Set the value of the “@meta@” 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' #meta @ -} clearVideoFrameMeta :: MonadIO m => VideoFrame -> m () clearVideoFrameMeta s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 136) (FP.nullPtr :: Ptr ()) #if ENABLE_OVERLOADING data VideoFrameMetaFieldInfo instance AttrInfo VideoFrameMetaFieldInfo where type AttrAllowedOps VideoFrameMetaFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint VideoFrameMetaFieldInfo = (~) (Ptr ()) type AttrBaseTypeConstraint VideoFrameMetaFieldInfo = (~) VideoFrame type AttrGetType VideoFrameMetaFieldInfo = Ptr () type AttrLabel VideoFrameMetaFieldInfo = "meta" type AttrOrigin VideoFrameMetaFieldInfo = VideoFrame attrGet _ = getVideoFrameMeta attrSet _ = setVideoFrameMeta attrConstruct = undefined attrClear _ = clearVideoFrameMeta videoFrame_meta :: AttrLabelProxy "meta" videoFrame_meta = AttrLabelProxy #endif {- | Get the value of the “@id@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' videoFrame #id @ -} getVideoFrameId :: MonadIO m => VideoFrame -> m Int32 getVideoFrameId s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 144) :: IO Int32 return val {- | Set the value of the “@id@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' videoFrame [ #id 'Data.GI.Base.Attributes.:=' value ] @ -} setVideoFrameId :: MonadIO m => VideoFrame -> Int32 -> m () setVideoFrameId s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 144) (val :: Int32) #if ENABLE_OVERLOADING data VideoFrameIdFieldInfo instance AttrInfo VideoFrameIdFieldInfo where type AttrAllowedOps VideoFrameIdFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint VideoFrameIdFieldInfo = (~) Int32 type AttrBaseTypeConstraint VideoFrameIdFieldInfo = (~) VideoFrame type AttrGetType VideoFrameIdFieldInfo = Int32 type AttrLabel VideoFrameIdFieldInfo = "id" type AttrOrigin VideoFrameIdFieldInfo = VideoFrame attrGet _ = getVideoFrameId attrSet _ = setVideoFrameId attrConstruct = undefined attrClear _ = undefined videoFrame_id :: AttrLabelProxy "id" videoFrame_id = AttrLabelProxy #endif -- XXX Skipped attribute for "VideoFrame:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TPtr)" -- XXX Skipped attribute for "VideoFrame:map" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TInterface (Name {namespace = \"Gst\", name = \"MapInfo\"}))" #if ENABLE_OVERLOADING instance O.HasAttributeList VideoFrame type instance O.AttributeList VideoFrame = VideoFrameAttributeList type VideoFrameAttributeList = ('[ '("info", VideoFrameInfoFieldInfo), '("flags", VideoFrameFlagsFieldInfo), '("buffer", VideoFrameBufferFieldInfo), '("meta", VideoFrameMetaFieldInfo), '("id", VideoFrameIdFieldInfo)] :: [(Symbol, *)]) #endif -- method VideoFrame::copy -- method type : OrdinaryMethod -- Args : [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},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}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_video_frame_copy" gst_video_frame_copy :: Ptr VideoFrame -> -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) Ptr VideoFrame -> -- src : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) IO CInt {- | Copy the contents from /@src@/ to /@dest@/. -} videoFrameCopy :: (B.CallStack.HasCallStack, MonadIO m) => VideoFrame {- ^ /@dest@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} -> VideoFrame {- ^ /@src@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} -> m Bool {- ^ __Returns:__ TRUE if the contents could be copied. -} videoFrameCopy dest src = liftIO $ do dest' <- unsafeManagedPtrGetPtr dest src' <- unsafeManagedPtrGetPtr src result <- gst_video_frame_copy dest' src' let result' = (/= 0) result touchManagedPtr dest touchManagedPtr src return result' #if ENABLE_OVERLOADING data VideoFrameCopyMethodInfo instance (signature ~ (VideoFrame -> m Bool), MonadIO m) => O.MethodInfo VideoFrameCopyMethodInfo VideoFrame signature where overloadedMethod _ = videoFrameCopy #endif -- method VideoFrame::copy_plane -- method type : OrdinaryMethod -- Args : [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},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 = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a plane", 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_video_frame_copy_plane" gst_video_frame_copy_plane :: Ptr VideoFrame -> -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) Ptr VideoFrame -> -- src : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) Word32 -> -- plane : TBasicType TUInt IO CInt {- | Copy the plane with index /@plane@/ from /@src@/ to /@dest@/. -} videoFrameCopyPlane :: (B.CallStack.HasCallStack, MonadIO m) => VideoFrame {- ^ /@dest@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} -> VideoFrame {- ^ /@src@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} -> Word32 {- ^ /@plane@/: a plane -} -> m Bool {- ^ __Returns:__ TRUE if the contents could be copied. -} videoFrameCopyPlane dest src plane = liftIO $ do dest' <- unsafeManagedPtrGetPtr dest src' <- unsafeManagedPtrGetPtr src result <- gst_video_frame_copy_plane dest' src' plane let result' = (/= 0) result touchManagedPtr dest touchManagedPtr src return result' #if ENABLE_OVERLOADING data VideoFrameCopyPlaneMethodInfo instance (signature ~ (VideoFrame -> Word32 -> m Bool), MonadIO m) => O.MethodInfo VideoFrameCopyPlaneMethodInfo VideoFrame signature where overloadedMethod _ = videoFrameCopyPlane #endif -- method VideoFrame::map -- method type : OrdinaryMethod -- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer to map", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstMapFlags", 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_video_frame_map" gst_video_frame_map :: Ptr VideoFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) Ptr GstVideo.VideoInfo.VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "MapFlags"}) IO CInt {- | Use /@info@/ and /@buffer@/ to fill in the values of /@frame@/. /@frame@/ is usually allocated on the stack, and you will pass the address to the 'GI.GstVideo.Structs.VideoFrame.VideoFrame' structure allocated on the stack; 'GI.GstVideo.Structs.VideoFrame.videoFrameMap' will then fill in the structures with the various video-specific information you need to access the pixels of the video buffer. You can then use accessor macros such as @/GST_VIDEO_FRAME_COMP_DATA()/@, @/GST_VIDEO_FRAME_PLANE_DATA()/@, @/GST_VIDEO_FRAME_COMP_STRIDE()/@, @/GST_VIDEO_FRAME_PLANE_STRIDE()/@ etc. to get to the pixels. === /C code/ > > GstVideoFrame vframe; > ... > // set RGB pixels to black one at a time > if (gst_video_frame_map (&vframe, video_info, video_buffer, GST_MAP_WRITE)) { > guint8 *pixels = GST_VIDEO_FRAME_PLANE_DATA (vframe, 0); > guint stride = GST_VIDEO_FRAME_PLANE_STRIDE (vframe, 0); > guint pixel_stride = GST_VIDEO_FRAME_COMP_PSTRIDE (vframe, 0); > > for (h = 0; h < height; ++h) { > for (w = 0; w < width; ++w) { > guint8 *pixel = pixels + h * stride + w * pixel_stride; > > memset (pixel, 0, pixel_stride); > } > } > > gst_video_frame_unmap (&vframe); > } > ... All video planes of /@buffer@/ will be mapped and the pointers will be set in /@frame@/->data. The purpose of this function is to make it easy for you to get to the video pixels in a generic way, without you having to worry too much about details such as whether the video data is allocated in one contiguous memory chunk or multiple memory chunks (e.g. one for each plane); or if custom strides and custom plane offsets are used or not (as signalled by GstVideoMeta on each buffer). This function will just fill the 'GI.GstVideo.Structs.VideoFrame.VideoFrame' structure with the right values and if you use the accessor macros everything will just work and you can access the data easily. It also maps the underlying memory chunks for you. -} videoFrameMap :: (B.CallStack.HasCallStack, MonadIO m) => VideoFrame {- ^ /@frame@/: pointer to 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} -> GstVideo.VideoInfo.VideoInfo {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} -> Gst.Buffer.Buffer {- ^ /@buffer@/: the buffer to map -} -> [Gst.Flags.MapFlags] {- ^ /@flags@/: 'GI.Gst.Flags.MapFlags' -} -> m Bool {- ^ __Returns:__ 'True' on success. -} videoFrameMap frame info buffer flags = liftIO $ do frame' <- unsafeManagedPtrGetPtr frame info' <- unsafeManagedPtrGetPtr info buffer' <- unsafeManagedPtrGetPtr buffer let flags' = gflagsToWord flags result <- gst_video_frame_map frame' info' buffer' flags' let result' = (/= 0) result touchManagedPtr frame touchManagedPtr info touchManagedPtr buffer return result' #if ENABLE_OVERLOADING data VideoFrameMapMethodInfo instance (signature ~ (GstVideo.VideoInfo.VideoInfo -> Gst.Buffer.Buffer -> [Gst.Flags.MapFlags] -> m Bool), MonadIO m) => O.MethodInfo VideoFrameMapMethodInfo VideoFrame signature where overloadedMethod _ = videoFrameMap #endif -- method VideoFrame::map_id -- method type : OrdinaryMethod -- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer to map", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frame id to map", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstMapFlags", 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_video_frame_map_id" gst_video_frame_map_id :: Ptr VideoFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) Ptr GstVideo.VideoInfo.VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) Int32 -> -- id : TBasicType TInt CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "MapFlags"}) IO CInt {- | Use /@info@/ and /@buffer@/ to fill in the values of /@frame@/ with the video frame information of frame /@id@/. When /@id@/ is -1, the default frame is mapped. When /@id@/ != -1, this function will return 'False' when there is no GstVideoMeta with that id. All video planes of /@buffer@/ will be mapped and the pointers will be set in /@frame@/->data. -} videoFrameMapId :: (B.CallStack.HasCallStack, MonadIO m) => VideoFrame {- ^ /@frame@/: pointer to 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} -> GstVideo.VideoInfo.VideoInfo {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} -> Gst.Buffer.Buffer {- ^ /@buffer@/: the buffer to map -} -> Int32 {- ^ /@id@/: the frame id to map -} -> [Gst.Flags.MapFlags] {- ^ /@flags@/: 'GI.Gst.Flags.MapFlags' -} -> m Bool {- ^ __Returns:__ 'True' on success. -} videoFrameMapId frame info buffer id flags = liftIO $ do frame' <- unsafeManagedPtrGetPtr frame info' <- unsafeManagedPtrGetPtr info buffer' <- unsafeManagedPtrGetPtr buffer let flags' = gflagsToWord flags result <- gst_video_frame_map_id frame' info' buffer' id flags' let result' = (/= 0) result touchManagedPtr frame touchManagedPtr info touchManagedPtr buffer return result' #if ENABLE_OVERLOADING data VideoFrameMapIdMethodInfo instance (signature ~ (GstVideo.VideoInfo.VideoInfo -> Gst.Buffer.Buffer -> Int32 -> [Gst.Flags.MapFlags] -> m Bool), MonadIO m) => O.MethodInfo VideoFrameMapIdMethodInfo VideoFrame signature where overloadedMethod _ = videoFrameMapId #endif -- method VideoFrame::unmap -- method type : OrdinaryMethod -- Args : [Arg {argCName = "frame", 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_frame_unmap" gst_video_frame_unmap :: Ptr VideoFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) IO () {- | Unmap the memory previously mapped with gst_video_frame_map. -} videoFrameUnmap :: (B.CallStack.HasCallStack, MonadIO m) => VideoFrame {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} -> m () videoFrameUnmap frame = liftIO $ do frame' <- unsafeManagedPtrGetPtr frame gst_video_frame_unmap frame' touchManagedPtr frame return () #if ENABLE_OVERLOADING data VideoFrameUnmapMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoFrameUnmapMethodInfo VideoFrame signature where overloadedMethod _ = videoFrameUnmap #endif #if ENABLE_OVERLOADING type family ResolveVideoFrameMethod (t :: Symbol) (o :: *) :: * where ResolveVideoFrameMethod "copy" o = VideoFrameCopyMethodInfo ResolveVideoFrameMethod "copyPlane" o = VideoFrameCopyPlaneMethodInfo ResolveVideoFrameMethod "map" o = VideoFrameMapMethodInfo ResolveVideoFrameMethod "mapId" o = VideoFrameMapIdMethodInfo ResolveVideoFrameMethod "unmap" o = VideoFrameUnmapMethodInfo ResolveVideoFrameMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveVideoFrameMethod t VideoFrame, O.MethodInfo info VideoFrame p) => OL.IsLabel t (VideoFrame -> 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