video frame

src –

Returns –

TRUE if the contents could be copied.

GstVideo.VideoFrame.prototype.copy

function GstVideo.VideoFrame.prototype.copy(src: GstVideo.VideoFrame): {
    // javascript wrapper for 'gst_video_frame_copy'
}

Copy the contents from src to dest.

Note: Since: 1.18, dest dimensions are allowed to be smaller than src dimensions.

Parameters:

dest (GstVideo.VideoFrame) –

src (GstVideo.VideoFrame) –

Returns (Number) –

TRUE if the contents could be copied.

GstVideo.VideoFrame.copy

def GstVideo.VideoFrame.copy (self, src):
    #python wrapper for 'gst_video_frame_copy'

Copy the contents from src to dest.

Note: Since: 1.18, dest dimensions are allowed to be smaller than src dimensions.

Parameters:

dest (GstVideo.VideoFrame) –

src (GstVideo.VideoFrame) –

Returns (bool) –

TRUE if the contents could be copied.

gst_video_frame_copy_plane

gboolean
gst_video_frame_copy_plane (GstVideoFrame * dest,
                            const GstVideoFrame * src,
                            guint plane)

Copy the plane with index plane from src to dest.

Note: Since: 1.18, dest dimensions are allowed to be smaller than src dimensions.

Parameters:

dest –

src –

plane –

a plane

Returns –

TRUE if the contents could be copied.

GstVideo.VideoFrame.prototype.copy_plane

function GstVideo.VideoFrame.prototype.copy_plane(src: GstVideo.VideoFrame, plane: Number): {
    // javascript wrapper for 'gst_video_frame_copy_plane'
}

Copy the plane with index plane from src to dest.

Note: Since: 1.18, dest dimensions are allowed to be smaller than src dimensions.

Parameters:

dest (GstVideo.VideoFrame) –

src (GstVideo.VideoFrame) –

plane (Number) –

a plane

Returns (Number) –

TRUE if the contents could be copied.

GstVideo.VideoFrame.copy_plane

def GstVideo.VideoFrame.copy_plane (self, src, plane):
    #python wrapper for 'gst_video_frame_copy_plane'

Copy the plane with index plane from src to dest.

Note: Since: 1.18, dest dimensions are allowed to be smaller than src dimensions.

Parameters:

dest (GstVideo.VideoFrame) –

src (GstVideo.VideoFrame) –

plane (int) –

a plane

Returns (bool) –

TRUE if the contents could be copied.

gst_video_frame_unmap

gst_video_frame_unmap (GstVideoFrame * frame)

Unmap the memory previously mapped with gst_video_frame_map.

Parameters:

frame –

GstVideo.VideoFrame.prototype.unmap

function GstVideo.VideoFrame.prototype.unmap(): {
    // javascript wrapper for 'gst_video_frame_unmap'
}

Unmap the memory previously mapped with gst_video_frame_map.

Parameters:

frame (GstVideo.VideoFrame) –

GstVideo.VideoFrame.unmap

def GstVideo.VideoFrame.unmap (self):
    #python wrapper for 'gst_video_frame_unmap'

Unmap the memory previously mapped with gst_video_frame_map.

Parameters:

frame (GstVideo.VideoFrame) –

Functions

gst_video_frame_map

gboolean
gst_video_frame_map (GstVideoFrame * frame,
                     const GstVideoInfo * info,
                     GstBuffer * buffer,
                     GstMapFlags flags)

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 GstVideoFrame structure allocated on the stack; gst_video_frame_map 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.

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

Parameters:

frame ( [out]) –

pointer to GstVideoFrame

info –

a GstVideoInfo

buffer –

the buffer to map

flags –

GstMapFlags

Returns –

TRUE on success.

GstVideo.prototype.video_frame_map

function GstVideo.prototype.video_frame_map(info: GstVideo.VideoInfo, buffer: Gst.Buffer, flags: Gst.MapFlags): {
    // javascript wrapper for 'gst_video_frame_map'
}

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 GstVideo.VideoFrame structure allocated on the stack; GstVideo.prototype.video_frame_map 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 (not introspectable), GST_VIDEO_FRAME_PLANE_DATA (not introspectable), GST_VIDEO_FRAME_COMP_STRIDE (not introspectable), GST_VIDEO_FRAME_PLANE_STRIDE (not introspectable) etc. to get to the pixels.

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

Parameters:

info (GstVideo.VideoInfo) –

buffer (Gst.Buffer) –

the buffer to map

flags (Gst.MapFlags) –

Returns a tuple made of:

(Number ) –

true on success.

frame (GstVideo.VideoFrame ) –

true on success.

GstVideo.video_frame_map

def GstVideo.video_frame_map (info, buffer, flags):
    #python wrapper for 'gst_video_frame_map'

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 GstVideo.VideoFrame structure allocated on the stack; GstVideo.video_frame_map 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 (not introspectable), GST_VIDEO_FRAME_PLANE_DATA (not introspectable), GST_VIDEO_FRAME_COMP_STRIDE (not introspectable), GST_VIDEO_FRAME_PLANE_STRIDE (not introspectable) etc. to get to the pixels.

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

Parameters:

info (GstVideo.VideoInfo) –

buffer (Gst.Buffer) –

the buffer to map

flags (Gst.MapFlags) –

Returns a tuple made of:

(bool ) –

True on success.

frame (GstVideo.VideoFrame ) –

True on success.

gst_video_frame_map_id

gboolean
gst_video_frame_map_id (GstVideoFrame * frame,
                        const GstVideoInfo * info,
                        GstBuffer * buffer,
                        gint id,
                        GstMapFlags flags)

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.

Parameters:

frame ( [out]) –

pointer to GstVideoFrame

info –

a GstVideoInfo

buffer –

the buffer to map

id –

the frame id to map

flags –

GstMapFlags

Returns –

TRUE on success.

GstVideo.prototype.video_frame_map_id

function GstVideo.prototype.video_frame_map_id(info: GstVideo.VideoInfo, buffer: Gst.Buffer, id: Number, flags: Gst.MapFlags): {
    // javascript wrapper for 'gst_video_frame_map_id'
}

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.

Parameters:

info (GstVideo.VideoInfo) –

buffer (Gst.Buffer) –

the buffer to map

id (Number) –

the frame id to map

flags (Gst.MapFlags) –

Returns a tuple made of:

(Number ) –

true on success.

frame (GstVideo.VideoFrame ) –

true on success.

GstVideo.video_frame_map_id

def GstVideo.video_frame_map_id (info, buffer, id, flags):
    #python wrapper for 'gst_video_frame_map_id'

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.

Parameters:

info (GstVideo.VideoInfo) –

buffer (Gst.Buffer) –

the buffer to map

id (int) –

the frame id to map

flags (Gst.MapFlags) –