mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-11-15 22:11:01 +00:00
Code Issues Projects Releases Wiki Activity
gstreamer-rs/gstreamer-gl/sys/src/lib.rs

2830 lines
106 KiB
Rust
Raw Blame History

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
clippy::approx_constant,
clippy::type_complexity,
clippy::unreadable_literal,
clippy::upper_case_acronyms
)]
#![cfg_attr(feature = "dox", feature(doc_cfg))]
mod manual;
pub use manual::*;
#[allow(unused_imports)]
use libc::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
intptr_t, size_t, ssize_t, uintptr_t, FILE,
};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
// Enums
pub type GstGLBaseMemoryError = c_int;
pub const GST_GL_BASE_MEMORY_ERROR_FAILED: GstGLBaseMemoryError = 0;
pub const GST_GL_BASE_MEMORY_ERROR_OLD_LIBS: GstGLBaseMemoryError = 1;
pub const GST_GL_BASE_MEMORY_ERROR_RESOURCE_UNAVAILABLE: GstGLBaseMemoryError = 2;
pub type GstGLConfigCaveat = c_int;
pub const GST_GL_CONFIG_CAVEAT_NONE: GstGLConfigCaveat = 0;
pub const GST_GL_CONFIG_CAVEAT_SLOW: GstGLConfigCaveat = 1;
pub const GST_GL_CONFIG_CAVEAT_NON_CONFORMANT: GstGLConfigCaveat = 2;
pub type GstGLContextError = c_int;
pub const GST_GL_CONTEXT_ERROR_FAILED: GstGLContextError = 0;
pub const GST_GL_CONTEXT_ERROR_WRONG_CONFIG: GstGLContextError = 1;
pub const GST_GL_CONTEXT_ERROR_WRONG_API: GstGLContextError = 2;
pub const GST_GL_CONTEXT_ERROR_OLD_LIBS: GstGLContextError = 3;
pub const GST_GL_CONTEXT_ERROR_CREATE_CONTEXT: GstGLContextError = 4;
pub const GST_GL_CONTEXT_ERROR_RESOURCE_UNAVAILABLE: GstGLContextError = 5;
pub type GstGLFormat = c_int;
pub const GST_GL_LUMINANCE: GstGLFormat = 6409;
pub const GST_GL_ALPHA: GstGLFormat = 6406;
pub const GST_GL_LUMINANCE_ALPHA: GstGLFormat = 6410;
pub const GST_GL_RED: GstGLFormat = 6403;
pub const GST_GL_R8: GstGLFormat = 33321;
pub const GST_GL_RG: GstGLFormat = 33319;
pub const GST_GL_RG8: GstGLFormat = 33323;
pub const GST_GL_RGB: GstGLFormat = 6407;
pub const GST_GL_RGB8: GstGLFormat = 32849;
pub const GST_GL_RGB565: GstGLFormat = 36194;
pub const GST_GL_RGB16: GstGLFormat = 32852;
pub const GST_GL_RGBA: GstGLFormat = 6408;
pub const GST_GL_RGBA8: GstGLFormat = 32856;
pub const GST_GL_RGBA16: GstGLFormat = 32859;
pub const GST_GL_DEPTH_COMPONENT16: GstGLFormat = 33189;
pub const GST_GL_DEPTH24_STENCIL8: GstGLFormat = 35056;
pub const GST_GL_RGB10_A2: GstGLFormat = 32857;
pub const GST_GL_R16: GstGLFormat = 33322;
pub const GST_GL_RG16: GstGLFormat = 33324;
pub type GstGLQueryType = c_int;
pub const GST_GL_QUERY_NONE: GstGLQueryType = 0;
pub const GST_GL_QUERY_TIME_ELAPSED: GstGLQueryType = 1;
pub const GST_GL_QUERY_TIMESTAMP: GstGLQueryType = 2;
pub type GstGLSLError = c_int;
pub const GST_GLSL_ERROR_COMPILE: GstGLSLError = 0;
pub const GST_GLSL_ERROR_LINK: GstGLSLError = 1;
pub const GST_GLSL_ERROR_PROGRAM: GstGLSLError = 2;
pub type GstGLSLVersion = c_int;
pub const GST_GLSL_VERSION_NONE: GstGLSLVersion = 0;
pub const GST_GLSL_VERSION_100: GstGLSLVersion = 100;
pub const GST_GLSL_VERSION_110: GstGLSLVersion = 110;
pub const GST_GLSL_VERSION_120: GstGLSLVersion = 120;
pub const GST_GLSL_VERSION_130: GstGLSLVersion = 130;
pub const GST_GLSL_VERSION_140: GstGLSLVersion = 140;
pub const GST_GLSL_VERSION_150: GstGLSLVersion = 150;
pub const GST_GLSL_VERSION_300: GstGLSLVersion = 300;
pub const GST_GLSL_VERSION_310: GstGLSLVersion = 310;
pub const GST_GLSL_VERSION_320: GstGLSLVersion = 320;
pub const GST_GLSL_VERSION_330: GstGLSLVersion = 330;
pub const GST_GLSL_VERSION_400: GstGLSLVersion = 400;
pub const GST_GLSL_VERSION_410: GstGLSLVersion = 410;
pub const GST_GLSL_VERSION_420: GstGLSLVersion = 420;
pub const GST_GLSL_VERSION_430: GstGLSLVersion = 430;
pub const GST_GLSL_VERSION_440: GstGLSLVersion = 440;
pub const GST_GLSL_VERSION_450: GstGLSLVersion = 450;
pub type GstGLStereoDownmix = c_int;
pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS: GstGLStereoDownmix = 0;
pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_RED_CYAN_DUBOIS: GstGLStereoDownmix = 1;
pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_AMBER_BLUE_DUBOIS: GstGLStereoDownmix = 2;
pub type GstGLTextureTarget = c_int;
pub const GST_GL_TEXTURE_TARGET_NONE: GstGLTextureTarget = 0;
pub const GST_GL_TEXTURE_TARGET_2D: GstGLTextureTarget = 1;
pub const GST_GL_TEXTURE_TARGET_RECTANGLE: GstGLTextureTarget = 2;
pub const GST_GL_TEXTURE_TARGET_EXTERNAL_OES: GstGLTextureTarget = 3;
pub type GstGLUploadReturn = c_int;
pub const GST_GL_UPLOAD_DONE: GstGLUploadReturn = 1;
pub const GST_GL_UPLOAD_ERROR: GstGLUploadReturn = -1;
pub const GST_GL_UPLOAD_UNSUPPORTED: GstGLUploadReturn = -2;
pub const GST_GL_UPLOAD_RECONFIGURE: GstGLUploadReturn = -3;
pub const GST_GL_UPLOAD_UNSHARED_GL_CONTEXT: GstGLUploadReturn = -100;
pub type GstGLWindowError = c_int;
pub const GST_GL_WINDOW_ERROR_FAILED: GstGLWindowError = 0;
pub const GST_GL_WINDOW_ERROR_OLD_LIBS: GstGLWindowError = 1;
pub const GST_GL_WINDOW_ERROR_RESOURCE_UNAVAILABLE: GstGLWindowError = 2;
// Constants
pub const GST_BUFFER_POOL_OPTION_GL_SYNC_META: &[u8] = b"GstBufferPoolOptionGLSyncMeta\0";
pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_2D: &[u8] =
b"GstBufferPoolOptionGLTextureTarget2D\0";
pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_EXTERNAL_OES: &[u8] =
b"GstBufferPoolOptionGLTextureTargetExternalOES\0";
pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_RECTANGLE: &[u8] =
b"GstBufferPoolOptionGLTextureTargetRectangle\0";
pub const GST_CAPS_FEATURE_MEMORY_GL_BUFFER: &[u8] = b"memory:GLBuffer\0";
pub const GST_CAPS_FEATURE_MEMORY_GL_MEMORY: &[u8] = b"memory:GLMemory\0";
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_ALLOC: c_int = 1;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_BUFFER: c_int = 16;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_USER: c_int = 65536;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_VIDEO: c_int = 8;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_WRAP_GPU_HANDLE: c_int = 4;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_WRAP_SYSMEM: c_int = 2;
pub const GST_GL_API_GLES1_NAME: &[u8] = b"gles1\0";
pub const GST_GL_API_GLES2_NAME: &[u8] = b"gles2\0";
pub const GST_GL_API_OPENGL3_NAME: &[u8] = b"opengl3\0";
pub const GST_GL_API_OPENGL_NAME: &[u8] = b"opengl\0";
pub const GST_GL_BASE_MEMORY_ALLOCATOR_NAME: &[u8] = b"GLBaseMemory\0";
pub const GST_GL_BUFFER_ALLOCATOR_NAME: &[u8] = b"GLBuffer\0";
pub const GST_GL_COLOR_CONVERT_EXT_FORMATS: &[u8] =
b", BGR10A2_LE, RGB10A2_LE, P010_10LE, P012_LE, P016_LE, Y212_LE, Y412_LE\0";
pub const GST_GL_CONFIG_STRUCTURE_NAME: &[u8] = b"gst-gl-context-config\0";
pub const GST_GL_CONTEXT_TYPE_CGL: &[u8] = b"gst.gl.context.CGL\0";
pub const GST_GL_CONTEXT_TYPE_EAGL: &[u8] = b"gst.gl.context.EAGL\0";
pub const GST_GL_CONTEXT_TYPE_EGL: &[u8] = b"gst.gl.context.EGL\0";
pub const GST_GL_CONTEXT_TYPE_GLX: &[u8] = b"gst.gl.context.GLX\0";
pub const GST_GL_CONTEXT_TYPE_WGL: &[u8] = b"gst.gl.context.WGL\0";
pub const GST_GL_DISPLAY_CONTEXT_TYPE: &[u8] = b"gst.gl.GLDisplay\0";
pub const GST_GL_MEMORY_ALLOCATOR_NAME: &[u8] = b"GLMemory\0";
pub const GST_GL_MEMORY_PBO_ALLOCATOR_NAME: &[u8] = b"GLMemoryPBO\0";
pub const GST_GL_MEMORY_VIDEO_EXT_FORMATS: &[u8] =
b", BGR10A2_LE, RGB10A2_LE, P010_10LE, P012_LE, P016_LE, Y212_LE, Y412_LE\0";
pub const GST_GL_RENDERBUFFER_ALLOCATOR_NAME: &[u8] = b"GLRenderbuffer\0";
pub const GST_GL_TEXTURE_TARGET_2D_STR: &[u8] = b"2D\0";
pub const GST_GL_TEXTURE_TARGET_EXTERNAL_OES_STR: &[u8] = b"external-oes\0";
pub const GST_GL_TEXTURE_TARGET_RECTANGLE_STR: &[u8] = b"rectangle\0";
pub const GST_MAP_GL: c_int = 131072;
// Flags
pub type GstGLAPI = c_uint;
pub const GST_GL_API_NONE: GstGLAPI = 0;
pub const GST_GL_API_OPENGL: GstGLAPI = 1;
pub const GST_GL_API_OPENGL3: GstGLAPI = 2;
pub const GST_GL_API_GLES1: GstGLAPI = 32768;
pub const GST_GL_API_GLES2: GstGLAPI = 65536;
pub const GST_GL_API_ANY: GstGLAPI = 4294967295;
pub type GstGLBaseMemoryTransfer = c_uint;
pub const GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD: GstGLBaseMemoryTransfer = 1048576;
pub const GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD: GstGLBaseMemoryTransfer = 2097152;
pub type GstGLConfigSurfaceType = c_uint;
pub const GST_GL_CONFIG_SURFACE_TYPE_NONE: GstGLConfigSurfaceType = 0;
pub const GST_GL_CONFIG_SURFACE_TYPE_WINDOW: GstGLConfigSurfaceType = 1;
pub const GST_GL_CONFIG_SURFACE_TYPE_PBUFFER: GstGLConfigSurfaceType = 2;
pub const GST_GL_CONFIG_SURFACE_TYPE_PIXMAP: GstGLConfigSurfaceType = 4;
pub type GstGLDisplayType = c_uint;
pub const GST_GL_DISPLAY_TYPE_NONE: GstGLDisplayType = 0;
pub const GST_GL_DISPLAY_TYPE_X11: GstGLDisplayType = 1;
pub const GST_GL_DISPLAY_TYPE_WAYLAND: GstGLDisplayType = 2;
pub const GST_GL_DISPLAY_TYPE_COCOA: GstGLDisplayType = 4;
pub const GST_GL_DISPLAY_TYPE_WIN32: GstGLDisplayType = 8;
pub const GST_GL_DISPLAY_TYPE_DISPMANX: GstGLDisplayType = 16;
pub const GST_GL_DISPLAY_TYPE_EGL: GstGLDisplayType = 32;
pub const GST_GL_DISPLAY_TYPE_VIV_FB: GstGLDisplayType = 64;
pub const GST_GL_DISPLAY_TYPE_GBM: GstGLDisplayType = 128;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub const GST_GL_DISPLAY_TYPE_EGL_DEVICE: GstGLDisplayType = 256;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub const GST_GL_DISPLAY_TYPE_EAGL: GstGLDisplayType = 512;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub const GST_GL_DISPLAY_TYPE_WINRT: GstGLDisplayType = 1024;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub const GST_GL_DISPLAY_TYPE_ANDROID: GstGLDisplayType = 2048;
pub const GST_GL_DISPLAY_TYPE_ANY: GstGLDisplayType = 4294967295;
pub type GstGLPlatform = c_uint;
pub const GST_GL_PLATFORM_NONE: GstGLPlatform = 0;
pub const GST_GL_PLATFORM_EGL: GstGLPlatform = 1;
pub const GST_GL_PLATFORM_GLX: GstGLPlatform = 2;
pub const GST_GL_PLATFORM_WGL: GstGLPlatform = 4;
pub const GST_GL_PLATFORM_CGL: GstGLPlatform = 8;
pub const GST_GL_PLATFORM_EAGL: GstGLPlatform = 16;
pub const GST_GL_PLATFORM_ANY: GstGLPlatform = 4294967295;
pub type GstGLSLProfile = c_uint;
pub const GST_GLSL_PROFILE_NONE: GstGLSLProfile = 0;
pub const GST_GLSL_PROFILE_ES: GstGLSLProfile = 1;
pub const GST_GLSL_PROFILE_CORE: GstGLSLProfile = 2;
pub const GST_GLSL_PROFILE_COMPATIBILITY: GstGLSLProfile = 4;
pub const GST_GLSL_PROFILE_ANY: GstGLSLProfile = 4294967295;
// Callbacks
pub type GstGLAllocationParamsCopyFunc =
Option<unsafe extern "C" fn(*mut GstGLAllocationParams, *mut GstGLAllocationParams)>;
pub type GstGLAllocationParamsFreeFunc = Option<unsafe extern "C" fn(gpointer)>;
pub type GstGLAsyncDebugLogGetMessage = Option<unsafe extern "C" fn(gpointer) -> *mut c_char>;
pub type GstGLBaseMemoryAllocatorAllocFunction = Option<
unsafe extern "C" fn(
*mut GstGLBaseMemoryAllocator,
*mut GstGLAllocationParams,
) -> *mut GstGLBaseMemory,
>;
pub type GstGLBaseMemoryAllocatorCopyFunction =
Option<unsafe extern "C" fn(*mut GstGLBaseMemory, ssize_t, ssize_t) -> *mut GstGLBaseMemory>;
pub type GstGLBaseMemoryAllocatorCreateFunction =
Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut *mut glib::GError) -> gboolean>;
pub type GstGLBaseMemoryAllocatorDestroyFunction =
Option<unsafe extern "C" fn(*mut GstGLBaseMemory)>;
pub type GstGLBaseMemoryAllocatorMapFunction =
Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut gst::GstMapInfo, size_t) -> gpointer>;
pub type GstGLBaseMemoryAllocatorUnmapFunction =
Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut gst::GstMapInfo)>;
pub type GstGLContextThreadFunc = Option<unsafe extern "C" fn(*mut GstGLContext, gpointer)>;
pub type GstGLFilterRenderFunc =
Option<unsafe extern "C" fn(*mut GstGLFilter, *mut GstGLMemory, gpointer) -> gboolean>;
pub type GstGLFramebufferFunc = Option<unsafe extern "C" fn(gpointer) -> gboolean>;
pub type GstGLWindowCB = Option<unsafe extern "C" fn(gpointer)>;
pub type GstGLWindowResizeCB = Option<unsafe extern "C" fn(gpointer, c_uint, c_uint)>;
// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLAllocationParams {
pub struct_size: size_t,
pub copy: GstGLAllocationParamsCopyFunc,
pub free: GstGLAllocationParamsFreeFunc,
pub alloc_flags: c_uint,
pub alloc_size: size_t,
pub alloc_params: *mut gst::GstAllocationParams,
pub context: *mut GstGLContext,
pub notify: glib::GDestroyNotify,
pub user_data: gpointer,
pub wrapped_data: gpointer,
pub gl_handle: gpointer,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLAllocationParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLAllocationParams @ {self:p}"))
.field("struct_size", &self.struct_size)
.field("copy", &self.copy)
.field("free", &self.free)
.field("alloc_flags", &self.alloc_flags)
.field("alloc_size", &self.alloc_size)
.field("alloc_params", &self.alloc_params)
.field("context", &self.context)
.field("notify", &self.notify)
.field("user_data", &self.user_data)
.field("wrapped_data", &self.wrapped_data)
.field("gl_handle", &self.gl_handle)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLAsyncDebug {
pub state_flags: c_uint,
pub cat: *mut gst::GstDebugCategory,
pub level: gst::GstDebugLevel,
pub file: *const c_char,
pub function: *const c_char,
pub line: c_int,
pub object: *mut gobject::GObject,
pub debug_msg: *mut c_char,
pub callback: GstGLAsyncDebugLogGetMessage,
pub user_data: gpointer,
pub notify: glib::GDestroyNotify,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLAsyncDebug {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLAsyncDebug @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBaseFilterClass {
pub parent_class: gst_base::GstBaseTransformClass,
pub supported_gl_api: GstGLAPI,
pub gl_start: Option<unsafe extern "C" fn(*mut GstGLBaseFilter) -> gboolean>,
pub gl_stop: Option<unsafe extern "C" fn(*mut GstGLBaseFilter)>,
pub gl_set_caps: Option<
unsafe extern "C" fn(
*mut GstGLBaseFilter,
*mut gst::GstCaps,
*mut gst::GstCaps,
) -> gboolean,
>,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBaseFilterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBaseFilterClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("supported_gl_api", &self.supported_gl_api)
.field("gl_start", &self.gl_start)
.field("gl_stop", &self.gl_stop)
.field("gl_set_caps", &self.gl_set_caps)
.finish()
}
}
#[repr(C)]
pub struct _GstGLBaseFilterPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLBaseFilterPrivate = *mut _GstGLBaseFilterPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBaseMemory {
pub mem: gst::GstMemory,
pub context: *mut GstGLContext,
pub lock: glib::GMutex,
pub map_flags: gst::GstMapFlags,
pub map_count: c_int,
pub gl_map_count: c_int,
pub data: gpointer,
pub query: *mut GstGLQuery,
pub alloc_size: size_t,
pub alloc_data: gpointer,
pub notify: glib::GDestroyNotify,
pub user_data: gpointer,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBaseMemory {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBaseMemory @ {self:p}"))
.field("mem", &self.mem)
.field("context", &self.context)
.field("lock", &self.lock)
.field("map_flags", &self.map_flags)
.field("map_count", &self.map_count)
.field("gl_map_count", &self.gl_map_count)
.field("data", &self.data)
.field("query", &self.query)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBaseMemoryAllocatorClass {
pub parent_class: gst::GstAllocatorClass,
pub alloc: GstGLBaseMemoryAllocatorAllocFunction,
pub create: GstGLBaseMemoryAllocatorCreateFunction,
pub map: GstGLBaseMemoryAllocatorMapFunction,
pub unmap: GstGLBaseMemoryAllocatorUnmapFunction,
pub copy: GstGLBaseMemoryAllocatorCopyFunction,
pub destroy: GstGLBaseMemoryAllocatorDestroyFunction,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBaseMemoryAllocatorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBaseMemoryAllocatorClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("alloc", &self.alloc)
.field("create", &self.create)
.field("map", &self.map)
.field("unmap", &self.unmap)
.field("copy", &self.copy)
.field("destroy", &self.destroy)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBaseSrcClass {
pub parent_class: gst_base::GstPushSrcClass,
pub supported_gl_api: GstGLAPI,
pub gl_start: Option<unsafe extern "C" fn(*mut GstGLBaseSrc) -> gboolean>,
pub gl_stop: Option<unsafe extern "C" fn(*mut GstGLBaseSrc)>,
pub fill_gl_memory:
Option<unsafe extern "C" fn(*mut GstGLBaseSrc, *mut GstGLMemory) -> gboolean>,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBaseSrcClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBaseSrcClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("supported_gl_api", &self.supported_gl_api)
.field("gl_start", &self.gl_start)
.field("gl_stop", &self.gl_stop)
.field("fill_gl_memory", &self.fill_gl_memory)
.finish()
}
}
#[repr(C)]
pub struct _GstGLBaseSrcPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLBaseSrcPrivate = *mut _GstGLBaseSrcPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBuffer {
pub mem: GstGLBaseMemory,
pub id: c_uint,
pub target: c_uint,
pub usage_hints: c_uint,
}
impl ::std::fmt::Debug for GstGLBuffer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBuffer @ {self:p}"))
.field("mem", &self.mem)
.field("id", &self.id)
.field("target", &self.target)
.field("usage_hints", &self.usage_hints)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBufferAllocationParams {
pub parent: GstGLAllocationParams,
pub gl_target: c_uint,
pub gl_usage: c_uint,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBufferAllocationParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBufferAllocationParams @ {self:p}"))
.field("parent", &self.parent)
.field("gl_target", &self.gl_target)
.field("gl_usage", &self.gl_usage)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBufferAllocatorClass {
pub parent_class: GstGLBaseMemoryAllocatorClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBufferAllocatorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBufferAllocatorClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBufferPoolClass {
pub parent_class: gst::GstBufferPoolClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBufferPoolClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBufferPoolClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _GstGLBufferPoolPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLBufferPoolPrivate = *mut _GstGLBufferPoolPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLColorConvertClass {
pub object_class: gst::GstObjectClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLColorConvertClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLColorConvertClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _GstGLColorConvertPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLColorConvertPrivate = *mut _GstGLColorConvertPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLContextClass {
pub parent_class: gst::GstObjectClass,
pub get_current_context: Option<unsafe extern "C" fn() -> uintptr_t>,
pub get_gl_context: Option<unsafe extern "C" fn(*mut GstGLContext) -> uintptr_t>,
pub get_gl_api: Option<unsafe extern "C" fn(*mut GstGLContext) -> GstGLAPI>,
pub get_gl_platform: Option<unsafe extern "C" fn(*mut GstGLContext) -> GstGLPlatform>,
pub get_proc_address: Option<unsafe extern "C" fn(GstGLAPI, *const c_char) -> gpointer>,
pub activate: Option<unsafe extern "C" fn(*mut GstGLContext, gboolean) -> gboolean>,
pub choose_format:
Option<unsafe extern "C" fn(*mut GstGLContext, *mut *mut glib::GError) -> gboolean>,
pub create_context: Option<
unsafe extern "C" fn(
*mut GstGLContext,
GstGLAPI,
*mut GstGLContext,
*mut *mut glib::GError,
) -> gboolean,
>,
pub destroy_context: Option<unsafe extern "C" fn(*mut GstGLContext)>,
pub swap_buffers: Option<unsafe extern "C" fn(*mut GstGLContext)>,
pub check_feature: Option<unsafe extern "C" fn(*mut GstGLContext, *const c_char) -> gboolean>,
pub get_gl_platform_version:
Option<unsafe extern "C" fn(*mut GstGLContext, *mut c_int, *mut c_int)>,
pub get_config: Option<unsafe extern "C" fn(*mut GstGLContext) -> *mut gst::GstStructure>,
pub request_config:
Option<unsafe extern "C" fn(*mut GstGLContext, *mut gst::GstStructure) -> gboolean>,
pub _reserved: [gpointer; 2],
}
impl ::std::fmt::Debug for GstGLContextClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLContextClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("get_current_context", &self.get_current_context)
.field("get_gl_context", &self.get_gl_context)
.field("get_gl_api", &self.get_gl_api)
.field("get_gl_platform", &self.get_gl_platform)
.field("get_proc_address", &self.get_proc_address)
.field("activate", &self.activate)
.field("choose_format", &self.choose_format)
.field("create_context", &self.create_context)
.field("destroy_context", &self.destroy_context)
.field("swap_buffers", &self.swap_buffers)
.field("check_feature", &self.check_feature)
.field("get_gl_platform_version", &self.get_gl_platform_version)
.field("get_config", &self.get_config)
.field("request_config", &self.request_config)
.finish()
}
}
#[repr(C)]
pub struct _GstGLContextPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLContextPrivate = *mut _GstGLContextPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLDisplayClass {
pub object_class: gst::GstObjectClass,
pub get_handle: Option<unsafe extern "C" fn(*mut GstGLDisplay) -> uintptr_t>,
pub create_window: Option<unsafe extern "C" fn(*mut GstGLDisplay) -> *mut GstGLWindow>,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLDisplayClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLDisplayClass @ {self:p}"))
.field("object_class", &self.object_class)
.field("get_handle", &self.get_handle)
.field("create_window", &self.create_window)
.finish()
}
}
#[repr(C)]
pub struct _GstGLDisplayPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLDisplayPrivate = *mut _GstGLDisplayPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLFilterClass {
pub parent_class: GstGLBaseFilterClass,
pub set_caps: Option<
unsafe extern "C" fn(*mut GstGLFilter, *mut gst::GstCaps, *mut gst::GstCaps) -> gboolean,
>,
pub filter: Option<
unsafe extern "C" fn(
*mut GstGLFilter,
*mut gst::GstBuffer,
*mut gst::GstBuffer,
) -> gboolean,
>,
pub filter_texture: Option<
unsafe extern "C" fn(*mut GstGLFilter, *mut GstGLMemory, *mut GstGLMemory) -> gboolean,
>,
pub init_fbo: Option<unsafe extern "C" fn(*mut GstGLFilter) -> gboolean>,
pub transform_internal_caps: Option<
unsafe extern "C" fn(
*mut GstGLFilter,
gst::GstPadDirection,
*mut gst::GstCaps,
*mut gst::GstCaps,
) -> *mut gst::GstCaps,
>,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLFilterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLFilterClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("set_caps", &self.set_caps)
.field("filter", &self.filter)
.field("filter_texture", &self.filter_texture)
.field("init_fbo", &self.init_fbo)
.field("transform_internal_caps", &self.transform_internal_caps)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLFramebufferClass {
pub object_class: gst::GstObjectClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLFramebufferClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLFramebufferClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _GstGLFramebufferPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLFramebufferPrivate = *mut _GstGLFramebufferPrivate;
#[repr(C)]
pub struct _GstGLFuncs {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLFuncs = *mut _GstGLFuncs;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLMemory {
pub mem: GstGLBaseMemory,
pub tex_id: c_uint,
pub tex_target: GstGLTextureTarget,
pub tex_format: GstGLFormat,
pub info: gst_video::GstVideoInfo,
pub valign: gst_video::GstVideoAlignment,
pub plane: c_uint,
pub tex_scaling: [c_float; 2],
pub texture_wrapped: gboolean,
pub unpack_length: c_uint,
pub tex_width: c_uint,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLMemory {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLMemory @ {self:p}"))
.field("mem", &self.mem)
.field("tex_id", &self.tex_id)
.field("tex_target", &self.tex_target)
.field("tex_format", &self.tex_format)
.field("info", &self.info)
.field("valign", &self.valign)
.field("plane", &self.plane)
.field("tex_scaling", &self.tex_scaling)
.field("texture_wrapped", &self.texture_wrapped)
.field("unpack_length", &self.unpack_length)
.field("tex_width", &self.tex_width)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLMemoryAllocatorClass {
pub parent_class: GstGLBaseMemoryAllocatorClass,
pub map: GstGLBaseMemoryAllocatorMapFunction,
pub copy: GstGLBaseMemoryAllocatorCopyFunction,
pub unmap: GstGLBaseMemoryAllocatorUnmapFunction,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLMemoryAllocatorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLMemoryAllocatorClass @ {self:p}"))
.field("map", &self.map)
.field("copy", &self.copy)
.field("unmap", &self.unmap)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLMemoryPBO {
pub mem: GstGLMemory,
pub pbo: *mut GstGLBuffer,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLMemoryPBO {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLMemoryPBO @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLMemoryPBOAllocatorClass {
pub parent_class: GstGLMemoryAllocatorClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLMemoryPBOAllocatorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLMemoryPBOAllocatorClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLOverlayCompositorClass {
pub object_class: gst::GstObjectClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLOverlayCompositorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLOverlayCompositorClass @ {self:p}"))
.field("object_class", &self.object_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLQuery {
pub context: *mut GstGLContext,
pub query_type: c_uint,
pub query_id: c_uint,
pub supported: gboolean,
pub start_called: gboolean,
pub debug: GstGLAsyncDebug,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLQuery {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLQuery @ {self:p}")).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLRenderbuffer {
pub mem: GstGLBaseMemory,
pub renderbuffer_id: c_uint,
pub renderbuffer_format: GstGLFormat,
pub width: c_uint,
pub height: c_uint,
pub renderbuffer_wrapped: gboolean,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLRenderbuffer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLRenderbuffer @ {self:p}"))
.field("renderbuffer_id", &self.renderbuffer_id)
.field("renderbuffer_format", &self.renderbuffer_format)
.field("width", &self.width)
.field("height", &self.height)
.field("renderbuffer_wrapped", &self.renderbuffer_wrapped)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLRenderbufferAllocationParams {
pub parent: GstGLAllocationParams,
pub renderbuffer_format: GstGLFormat,
pub width: c_uint,
pub height: c_uint,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLRenderbufferAllocationParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLRenderbufferAllocationParams @ {self:p}"))
.field("renderbuffer_format", &self.renderbuffer_format)
.field("width", &self.width)
.field("height", &self.height)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLRenderbufferAllocatorClass {
pub parent_class: GstGLBaseMemoryAllocatorClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLRenderbufferAllocatorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLRenderbufferAllocatorClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLSLStageClass {
pub parent: gst::GstObjectClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLSLStageClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLSLStageClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _GstGLSLStagePrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLSLStagePrivate = *mut _GstGLSLStagePrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLShaderClass {
pub parent_class: gst::GstObjectClass,
}
impl ::std::fmt::Debug for GstGLShaderClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLShaderClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _GstGLShaderPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLShaderPrivate = *mut _GstGLShaderPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLSyncMeta {
pub parent: gst::GstMeta,
pub context: *mut GstGLContext,
pub data: gpointer,
pub set_sync: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
pub set_sync_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
pub wait: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
pub wait_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
pub wait_cpu: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
pub wait_cpu_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
pub copy: Option<
unsafe extern "C" fn(
*mut GstGLSyncMeta,
*mut gst::GstBuffer,
*mut GstGLSyncMeta,
*mut gst::GstBuffer,
),
>,
pub free: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
pub free_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
}
impl ::std::fmt::Debug for GstGLSyncMeta {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLSyncMeta @ {self:p}"))
.field("parent", &self.parent)
.field("context", &self.context)
.field("data", &self.data)
.field("set_sync", &self.set_sync)
.field("set_sync_gl", &self.set_sync_gl)
.field("wait", &self.wait)
.field("wait_gl", &self.wait_gl)
.field("wait_cpu", &self.wait_cpu)
.field("wait_cpu_gl", &self.wait_cpu_gl)
.field("copy", &self.copy)
.field("free", &self.free)
.field("free_gl", &self.free_gl)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLUploadClass {
pub object_class: gst::GstObjectClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLUploadClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLUploadClass @ {self:p}"))
.field("object_class", &self.object_class)
.finish()
}
}
#[repr(C)]
pub struct _GstGLUploadPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLUploadPrivate = *mut _GstGLUploadPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLVideoAllocationParams {
pub parent: GstGLAllocationParams,
pub v_info: *mut gst_video::GstVideoInfo,
pub plane: c_uint,
pub valign: *mut gst_video::GstVideoAlignment,
pub target: GstGLTextureTarget,
pub tex_format: GstGLFormat,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLVideoAllocationParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLVideoAllocationParams @ {self:p}"))
.field("parent", &self.parent)
.field("v_info", &self.v_info)
.field("plane", &self.plane)
.field("valign", &self.valign)
.field("target", &self.target)
.field("tex_format", &self.tex_format)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLViewConvertClass {
pub object_class: gst::GstObjectClass,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLViewConvertClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLViewConvertClass @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _GstGLViewConvertPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLViewConvertPrivate = *mut _GstGLViewConvertPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLWindowClass {
pub parent_class: gst::GstObjectClass,
pub get_display: Option<unsafe extern "C" fn(*mut GstGLWindow) -> uintptr_t>,
pub set_window_handle: Option<unsafe extern "C" fn(*mut GstGLWindow, uintptr_t)>,
pub get_window_handle: Option<unsafe extern "C" fn(*mut GstGLWindow) -> uintptr_t>,
pub draw: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
pub run: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
pub quit: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
pub send_message: Option<unsafe extern "C" fn(*mut GstGLWindow, GstGLWindowCB, gpointer)>,
pub send_message_async: Option<
unsafe extern "C" fn(*mut GstGLWindow, GstGLWindowCB, gpointer, glib::GDestroyNotify),
>,
pub open: Option<unsafe extern "C" fn(*mut GstGLWindow, *mut *mut glib::GError) -> gboolean>,
pub close: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
pub handle_events: Option<unsafe extern "C" fn(*mut GstGLWindow, gboolean)>,
pub set_preferred_size: Option<unsafe extern "C" fn(*mut GstGLWindow, c_int, c_int)>,
pub show: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
pub set_render_rectangle:
Option<unsafe extern "C" fn(*mut GstGLWindow, c_int, c_int, c_int, c_int) -> gboolean>,
pub queue_resize: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
pub controls_viewport: Option<unsafe extern "C" fn(*mut GstGLWindow) -> gboolean>,
pub has_output_surface: Option<unsafe extern "C" fn(*mut GstGLWindow) -> gboolean>,
pub _reserved: [gpointer; 2],
}
impl ::std::fmt::Debug for GstGLWindowClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLWindowClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("get_display", &self.get_display)
.field("set_window_handle", &self.set_window_handle)
.field("get_window_handle", &self.get_window_handle)
.field("draw", &self.draw)
.field("run", &self.run)
.field("quit", &self.quit)
.field("send_message", &self.send_message)
.field("send_message_async", &self.send_message_async)
.field("open", &self.open)
.field("close", &self.close)
.field("handle_events", &self.handle_events)
.field("set_preferred_size", &self.set_preferred_size)
.field("show", &self.show)
.field("set_render_rectangle", &self.set_render_rectangle)
.field("queue_resize", &self.queue_resize)
.field("controls_viewport", &self.controls_viewport)
.field("has_output_surface", &self.has_output_surface)
.finish()
}
}
#[repr(C)]
pub struct _GstGLWindowPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GstGLWindowPrivate = *mut _GstGLWindowPrivate;
// Classes
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBaseFilter {
pub parent: gst_base::GstBaseTransform,
pub display: *mut GstGLDisplay,
pub context: *mut GstGLContext,
pub in_caps: *mut gst::GstCaps,
pub out_caps: *mut gst::GstCaps,
pub _padding: [gpointer; 4],
pub priv_: *mut GstGLBaseFilterPrivate,
}
impl ::std::fmt::Debug for GstGLBaseFilter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBaseFilter @ {self:p}"))
.field("parent", &self.parent)
.field("display", &self.display)
.field("context", &self.context)
.field("in_caps", &self.in_caps)
.field("out_caps", &self.out_caps)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBaseMemoryAllocator {
pub parent: gst::GstAllocator,
pub fallback_mem_copy: gst::GstMemoryCopyFunction,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBaseMemoryAllocator {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBaseMemoryAllocator @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBaseSrc {
pub parent: gst_base::GstPushSrc,
pub display: *mut GstGLDisplay,
pub context: *mut GstGLContext,
pub out_info: gst_video::GstVideoInfo,
pub out_caps: *mut gst::GstCaps,
pub running_time: gst::GstClockTime,
pub _padding: [gpointer; 4],
pub priv_: *mut GstGLBaseSrcPrivate,
}
impl ::std::fmt::Debug for GstGLBaseSrc {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBaseSrc @ {self:p}"))
.field("parent", &self.parent)
.field("display", &self.display)
.field("context", &self.context)
.field("out_info", &self.out_info)
.field("out_caps", &self.out_caps)
.field("running_time", &self.running_time)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBufferAllocator {
pub parent: GstGLBaseMemoryAllocator,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBufferAllocator {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBufferAllocator @ {self:p}"))
.field("parent", &self.parent)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLBufferPool {
pub bufferpool: gst::GstBufferPool,
pub context: *mut GstGLContext,
pub priv_: *mut GstGLBufferPoolPrivate,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLBufferPool {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLBufferPool @ {self:p}"))
.field("bufferpool", &self.bufferpool)
.field("context", &self.context)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLColorConvert {
pub parent: gst::GstObject,
pub context: *mut GstGLContext,
pub in_info: gst_video::GstVideoInfo,
pub out_info: gst_video::GstVideoInfo,
pub initted: gboolean,
pub passthrough: gboolean,
pub inbuf: *mut gst::GstBuffer,
pub outbuf: *mut gst::GstBuffer,
pub fbo: *mut GstGLFramebuffer,
pub shader: *mut GstGLShader,
pub priv_: *mut GstGLColorConvertPrivate,
pub _reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLColorConvert {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLColorConvert @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLContext {
pub parent: gst::GstObject,
pub display: *mut GstGLDisplay,
pub window: *mut GstGLWindow,
pub gl_vtable: *mut GstGLFuncs,
pub priv_: *mut GstGLContextPrivate,
pub _reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLContext {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLContext @ {self:p}"))
.field("gl_vtable", &self.gl_vtable)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLDisplay {
pub object: gst::GstObject,
pub type_: GstGLDisplayType,
pub windows: *mut glib::GList,
pub main_context: *mut glib::GMainContext,
pub main_loop: *mut glib::GMainLoop,
pub event_source: *mut glib::GSource,
pub priv_: *mut GstGLDisplayPrivate,
}
impl ::std::fmt::Debug for GstGLDisplay {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLDisplay @ {self:p}")).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLFilter {
pub parent: GstGLBaseFilter,
pub in_info: gst_video::GstVideoInfo,
pub out_info: gst_video::GstVideoInfo,
pub in_texture_target: GstGLTextureTarget,
pub out_texture_target: GstGLTextureTarget,
pub out_caps: *mut gst::GstCaps,
pub fbo: *mut GstGLFramebuffer,
pub gl_result: gboolean,
pub inbuf: *mut gst::GstBuffer,
pub outbuf: *mut gst::GstBuffer,
pub default_shader: *mut GstGLShader,
pub valid_attributes: gboolean,
pub vao: c_uint,
pub vbo_indices: c_uint,
pub vertex_buffer: c_uint,
pub draw_attr_position_loc: c_int,
pub draw_attr_texture_loc: c_int,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLFilter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLFilter @ {self:p}"))
.field("parent", &self.parent)
.field("in_info", &self.in_info)
.field("out_info", &self.out_info)
.field("in_texture_target", &self.in_texture_target)
.field("out_texture_target", &self.out_texture_target)
.field("out_caps", &self.out_caps)
.field("fbo", &self.fbo)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLFramebuffer {
pub object: gst::GstObject,
pub context: *mut GstGLContext,
pub fbo_id: c_uint,
pub attachments: *mut glib::GArray,
pub _padding: [gpointer; 4],
pub priv_: *mut GstGLFramebufferPrivate,
}
impl ::std::fmt::Debug for GstGLFramebuffer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLFramebuffer @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLMemoryAllocator {
pub parent: GstGLBaseMemoryAllocator,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLMemoryAllocator {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLMemoryAllocator @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLMemoryPBOAllocator {
pub parent: GstGLMemoryAllocator,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLMemoryPBOAllocator {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLMemoryPBOAllocator @ {self:p}"))
.field("parent", &self.parent)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLOverlayCompositor {
pub parent: gst::GstObject,
pub context: *mut GstGLContext,
pub last_window_width: c_uint,
pub last_window_height: c_uint,
pub overlays: *mut glib::GList,
pub shader: *mut GstGLShader,
pub position_attrib: c_int,
pub texcoord_attrib: c_int,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLOverlayCompositor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLOverlayCompositor @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLRenderbufferAllocator {
pub parent: GstGLBaseMemoryAllocator,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLRenderbufferAllocator {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLRenderbufferAllocator @ {self:p}"))
.field("parent", &self.parent)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLSLStage {
pub parent: gst::GstObject,
pub context: *mut GstGLContext,
pub priv_: *mut GstGLSLStagePrivate,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLSLStage {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLSLStage @ {self:p}")).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLShader {
pub parent: gst::GstObject,
pub context: *mut GstGLContext,
pub priv_: *mut GstGLShaderPrivate,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLShader {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLShader @ {self:p}"))
.field("parent", &self.parent)
.field("context", &self.context)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLUpload {
pub parent: gst::GstObject,
pub context: *mut GstGLContext,
pub priv_: *mut GstGLUploadPrivate,
pub _reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLUpload {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLUpload @ {self:p}"))
.field("parent", &self.parent)
.field("context", &self.context)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLViewConvert {
pub object: gst::GstObject,
pub context: *mut GstGLContext,
pub shader: *mut GstGLShader,
pub input_mode_override: gst_video::GstVideoMultiviewMode,
pub input_flags_override: gst_video::GstVideoMultiviewFlags,
pub output_mode_override: gst_video::GstVideoMultiviewMode,
pub output_flags_override: gst_video::GstVideoMultiviewFlags,
pub downmix_mode: GstGLStereoDownmix,
pub in_info: gst_video::GstVideoInfo,
pub out_info: gst_video::GstVideoInfo,
pub from_texture_target: GstGLTextureTarget,
pub to_texture_target: GstGLTextureTarget,
pub caps_passthrough: gboolean,
pub initted: gboolean,
pub reconfigure: gboolean,
pub fbo: *mut GstGLFramebuffer,
pub priv_: *mut GstGLViewConvertPrivate,
pub _padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLViewConvert {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLViewConvert @ {self:p}"))
.field("object", &self.object)
.field("context", &self.context)
.field("shader", &self.shader)
.field("input_mode_override", &self.input_mode_override)
.field("input_flags_override", &self.input_flags_override)
.field("output_mode_override", &self.output_mode_override)
.field("output_flags_override", &self.output_flags_override)
.field("downmix_mode", &self.downmix_mode)
.field("in_info", &self.in_info)
.field("out_info", &self.out_info)
.field("from_texture_target", &self.from_texture_target)
.field("to_texture_target", &self.to_texture_target)
.field("caps_passthrough", &self.caps_passthrough)
.field("initted", &self.initted)
.field("reconfigure", &self.reconfigure)
.field("fbo", &self.fbo)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GstGLWindow {
pub parent: gst::GstObject,
pub lock: glib::GMutex,
pub display: *mut GstGLDisplay,
pub context_ref: gobject::GWeakRef,
pub is_drawing: gboolean,
pub draw: GstGLWindowCB,
pub draw_data: gpointer,
pub draw_notify: glib::GDestroyNotify,
pub close: GstGLWindowCB,
pub close_data: gpointer,
pub close_notify: glib::GDestroyNotify,
pub resize: GstGLWindowResizeCB,
pub resize_data: gpointer,
pub resize_notify: glib::GDestroyNotify,
pub queue_resize: gboolean,
pub main_context: *mut glib::GMainContext,
pub priv_: *mut GstGLWindowPrivate,
pub _reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GstGLWindow {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GstGLWindow @ {self:p}")).finish()
}
}
#[link(name = "gstgl-1.0")]
extern "C" {
//=========================================================================
// GstGLBaseMemoryError
//=========================================================================
pub fn gst_gl_base_memory_error_get_type() -> GType;
pub fn gst_gl_base_memory_error_quark() -> glib::GQuark;
//=========================================================================
// GstGLConfigCaveat
//=========================================================================
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_config_caveat_get_type() -> GType;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_config_caveat_to_string(caveat: GstGLConfigCaveat) -> *const c_char;
//=========================================================================
// GstGLContextError
//=========================================================================
pub fn gst_gl_context_error_get_type() -> GType;
pub fn gst_gl_context_error_quark() -> glib::GQuark;
//=========================================================================
// GstGLFormat
//=========================================================================
pub fn gst_gl_format_get_type() -> GType;
pub fn gst_gl_format_from_video_info(
context: *mut GstGLContext,
vinfo: *const gst_video::GstVideoInfo,
plane: c_uint,
) -> GstGLFormat;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_format_is_supported(context: *mut GstGLContext, format: GstGLFormat) -> gboolean;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_format_type_from_sized_gl_format(
format: GstGLFormat,
unsized_format: *mut GstGLFormat,
gl_type: *mut c_uint,
);
pub fn gst_gl_format_type_n_bytes(format: c_uint, type_: c_uint) -> c_uint;
//=========================================================================
// GstGLQueryType
//=========================================================================
pub fn gst_gl_query_type_get_type() -> GType;
//=========================================================================
// GstGLSLError
//=========================================================================
pub fn gst_glsl_error_get_type() -> GType;
pub fn gst_glsl_error_quark() -> glib::GQuark;
//=========================================================================
// GstGLSLVersion
//=========================================================================
pub fn gst_glsl_version_get_type() -> GType;
pub fn gst_glsl_version_from_string(string: *const c_char) -> GstGLSLVersion;
pub fn gst_glsl_version_profile_from_string(
string: *const c_char,
version_ret: *mut GstGLSLVersion,
profile_ret: *mut GstGLSLProfile,
) -> gboolean;
pub fn gst_glsl_version_profile_to_string(
version: GstGLSLVersion,
profile: GstGLSLProfile,
) -> *mut c_char;
pub fn gst_glsl_version_to_string(version: GstGLSLVersion) -> *const c_char;
//=========================================================================
// GstGLStereoDownmix
//=========================================================================
pub fn gst_gl_stereo_downmix_get_type() -> GType;
//=========================================================================
// GstGLTextureTarget
//=========================================================================
pub fn gst_gl_texture_target_get_type() -> GType;
pub fn gst_gl_texture_target_from_gl(target: c_uint) -> GstGLTextureTarget;
pub fn gst_gl_texture_target_from_string(str: *const c_char) -> GstGLTextureTarget;
pub fn gst_gl_texture_target_to_buffer_pool_option(target: GstGLTextureTarget)
-> *const c_char;
pub fn gst_gl_texture_target_to_gl(target: GstGLTextureTarget) -> c_uint;
pub fn gst_gl_texture_target_to_string(target: GstGLTextureTarget) -> *const c_char;
//=========================================================================
// GstGLUploadReturn
//=========================================================================
pub fn gst_gl_upload_return_get_type() -> GType;
//=========================================================================
// GstGLWindowError
//=========================================================================
pub fn gst_gl_window_error_get_type() -> GType;
pub fn gst_gl_window_error_quark() -> glib::GQuark;
//=========================================================================
// GstGLAPI
//=========================================================================
pub fn gst_gl_api_get_type() -> GType;
pub fn gst_gl_api_from_string(api_s: *const c_char) -> GstGLAPI;
pub fn gst_gl_api_to_string(api: GstGLAPI) -> *mut c_char;
//=========================================================================
// GstGLBaseMemoryTransfer
//=========================================================================
pub fn gst_gl_base_memory_transfer_get_type() -> GType;
//=========================================================================
// GstGLConfigSurfaceType
//=========================================================================
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_config_surface_type_get_type() -> GType;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_config_surface_type_to_string(
surface_type: GstGLConfigSurfaceType,
) -> *const c_char;
//=========================================================================
// GstGLDisplayType
//=========================================================================
pub fn gst_gl_display_type_get_type() -> GType;
//=========================================================================
// GstGLPlatform
//=========================================================================
pub fn gst_gl_platform_get_type() -> GType;
pub fn gst_gl_platform_from_string(platform_s: *const c_char) -> GstGLPlatform;
pub fn gst_gl_platform_to_string(platform: GstGLPlatform) -> *mut c_char;
//=========================================================================
// GstGLSLProfile
//=========================================================================
pub fn gst_glsl_profile_get_type() -> GType;
pub fn gst_glsl_profile_from_string(string: *const c_char) -> GstGLSLProfile;
pub fn gst_glsl_profile_to_string(profile: GstGLSLProfile) -> *const c_char;
//=========================================================================
// GstGLAllocationParams
//=========================================================================
pub fn gst_gl_allocation_params_get_type() -> GType;
pub fn gst_gl_allocation_params_copy(
src: *mut GstGLAllocationParams,
) -> *mut GstGLAllocationParams;
pub fn gst_gl_allocation_params_copy_data(
src: *mut GstGLAllocationParams,
dest: *mut GstGLAllocationParams,
);
pub fn gst_gl_allocation_params_free(params: *mut GstGLAllocationParams);
pub fn gst_gl_allocation_params_free_data(params: *mut GstGLAllocationParams);
pub fn gst_gl_allocation_params_init(
params: *mut GstGLAllocationParams,
struct_size: size_t,
alloc_flags: c_uint,
copy: GstGLAllocationParamsCopyFunc,
free: GstGLAllocationParamsFreeFunc,
context: *mut GstGLContext,
alloc_size: size_t,
alloc_params: *const gst::GstAllocationParams,
wrapped_data: gpointer,
gl_handle: gpointer,
user_data: gpointer,
notify: glib::GDestroyNotify,
) -> gboolean;
//=========================================================================
// GstGLAsyncDebug
//=========================================================================
pub fn gst_gl_async_debug_free(ad: *mut GstGLAsyncDebug);
pub fn gst_gl_async_debug_freeze(ad: *mut GstGLAsyncDebug);
pub fn gst_gl_async_debug_init(ad: *mut GstGLAsyncDebug);
pub fn gst_gl_async_debug_output_log_msg(ad: *mut GstGLAsyncDebug);
pub fn gst_gl_async_debug_store_log_msg(
ad: *mut GstGLAsyncDebug,
cat: *mut gst::GstDebugCategory,
level: gst::GstDebugLevel,
file: *const c_char,
function: *const c_char,
line: c_int,
object: *mut gobject::GObject,
format: *const c_char,
...
);
//pub fn gst_gl_async_debug_store_log_msg_valist(ad: *mut GstGLAsyncDebug, cat: *mut gst::GstDebugCategory, level: gst::GstDebugLevel, file: *const c_char, function: *const c_char, line: c_int, object: *mut gobject::GObject, format: *const c_char, varargs: /*Unimplemented*/va_list);
pub fn gst_gl_async_debug_thaw(ad: *mut GstGLAsyncDebug);
pub fn gst_gl_async_debug_unset(ad: *mut GstGLAsyncDebug);
pub fn gst_gl_async_debug_new() -> *mut GstGLAsyncDebug;
//=========================================================================
// GstGLBaseMemory
//=========================================================================
pub fn gst_gl_base_memory_get_type() -> GType;
pub fn gst_gl_base_memory_alloc_data(gl_mem: *mut GstGLBaseMemory) -> gboolean;
pub fn gst_gl_base_memory_init(
mem: *mut GstGLBaseMemory,
allocator: *mut gst::GstAllocator,
parent: *mut gst::GstMemory,
context: *mut GstGLContext,
params: *const gst::GstAllocationParams,
size: size_t,
user_data: gpointer,
notify: glib::GDestroyNotify,
);
pub fn gst_gl_base_memory_memcpy(
src: *mut GstGLBaseMemory,
dest: *mut GstGLBaseMemory,
offset: ssize_t,
size: ssize_t,
) -> gboolean;
pub fn gst_gl_base_memory_alloc(
allocator: *mut GstGLBaseMemoryAllocator,
params: *mut GstGLAllocationParams,
) -> *mut GstGLBaseMemory;
pub fn gst_gl_base_memory_init_once();
//=========================================================================
// GstGLBuffer
//=========================================================================
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_buffer_get_type() -> GType;
pub fn gst_gl_buffer_init_once();
//=========================================================================
// GstGLBufferAllocationParams
//=========================================================================
pub fn gst_gl_buffer_allocation_params_get_type() -> GType;
pub fn gst_gl_buffer_allocation_params_new(
context: *mut GstGLContext,
alloc_size: size_t,
alloc_params: *const gst::GstAllocationParams,
gl_target: c_uint,
gl_usage: c_uint,
) -> *mut GstGLBufferAllocationParams;
//=========================================================================
// GstGLMemory
//=========================================================================
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_memory_get_type() -> GType;
pub fn gst_gl_memory_copy_into(
gl_mem: *mut GstGLMemory,
tex_id: c_uint,
target: GstGLTextureTarget,
tex_format: GstGLFormat,
width: c_int,
height: c_int,
) -> gboolean;
pub fn gst_gl_memory_copy_teximage(
src: *mut GstGLMemory,
tex_id: c_uint,
out_target: GstGLTextureTarget,
out_tex_format: GstGLFormat,
out_width: c_int,
out_height: c_int,
) -> gboolean;
pub fn gst_gl_memory_get_texture_format(gl_mem: *mut GstGLMemory) -> GstGLFormat;
pub fn gst_gl_memory_get_texture_height(gl_mem: *mut GstGLMemory) -> c_int;
pub fn gst_gl_memory_get_texture_id(gl_mem: *mut GstGLMemory) -> c_uint;
pub fn gst_gl_memory_get_texture_target(gl_mem: *mut GstGLMemory) -> GstGLTextureTarget;
pub fn gst_gl_memory_get_texture_width(gl_mem: *mut GstGLMemory) -> c_int;
pub fn gst_gl_memory_init(
mem: *mut GstGLMemory,
allocator: *mut gst::GstAllocator,
parent: *mut gst::GstMemory,
context: *mut GstGLContext,
target: GstGLTextureTarget,
tex_format: GstGLFormat,
params: *const gst::GstAllocationParams,
info: *const gst_video::GstVideoInfo,
plane: c_uint,
valign: *const gst_video::GstVideoAlignment,
user_data: gpointer,
notify: glib::GDestroyNotify,
);
pub fn gst_gl_memory_read_pixels(gl_mem: *mut GstGLMemory, write_pointer: gpointer)
-> gboolean;
pub fn gst_gl_memory_texsubimage(gl_mem: *mut GstGLMemory, read_pointer: gpointer);
pub fn gst_gl_memory_init_once();
pub fn gst_gl_memory_setup_buffer(
allocator: *mut GstGLMemoryAllocator,
buffer: *mut gst::GstBuffer,
params: *mut GstGLVideoAllocationParams,
tex_formats: *mut GstGLFormat,
wrapped_data: *mut gpointer,
n_wrapped_pointers: size_t,
) -> gboolean;
//=========================================================================
// GstGLMemoryPBO
//=========================================================================
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_memory_pbo_get_type() -> GType;
pub fn gst_gl_memory_pbo_copy_into_texture(
gl_mem: *mut GstGLMemoryPBO,
tex_id: c_uint,
target: GstGLTextureTarget,
tex_format: GstGLFormat,
width: c_int,
height: c_int,
stride: c_int,
respecify: gboolean,
) -> gboolean;
pub fn gst_gl_memory_pbo_download_transfer(gl_mem: *mut GstGLMemoryPBO);
pub fn gst_gl_memory_pbo_upload_transfer(gl_mem: *mut GstGLMemoryPBO);
pub fn gst_gl_memory_pbo_init_once();
//=========================================================================
// GstGLQuery
//=========================================================================
pub fn gst_gl_query_counter(query: *mut GstGLQuery);
pub fn gst_gl_query_end(query: *mut GstGLQuery);
pub fn gst_gl_query_free(query: *mut GstGLQuery);
pub fn gst_gl_query_init(
query: *mut GstGLQuery,
context: *mut GstGLContext,
query_type: GstGLQueryType,
);
pub fn gst_gl_query_result(query: *mut GstGLQuery) -> u64;
pub fn gst_gl_query_start(query: *mut GstGLQuery);
pub fn gst_gl_query_unset(query: *mut GstGLQuery);
pub fn gst_gl_query_local_gl_context(
element: *mut gst::GstElement,
direction: gst::GstPadDirection,
context_ptr: *mut *mut GstGLContext,
) -> gboolean;
pub fn gst_gl_query_new(
context: *mut GstGLContext,
query_type: GstGLQueryType,
) -> *mut GstGLQuery;
//=========================================================================
// GstGLRenderbuffer
//=========================================================================
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_renderbuffer_get_type() -> GType;
pub fn gst_gl_renderbuffer_get_format(gl_mem: *mut GstGLRenderbuffer) -> GstGLFormat;
pub fn gst_gl_renderbuffer_get_height(gl_mem: *mut GstGLRenderbuffer) -> c_int;
pub fn gst_gl_renderbuffer_get_id(gl_mem: *mut GstGLRenderbuffer) -> c_uint;
pub fn gst_gl_renderbuffer_get_width(gl_mem: *mut GstGLRenderbuffer) -> c_int;
pub fn gst_gl_renderbuffer_init_once();
//=========================================================================
// GstGLRenderbufferAllocationParams
//=========================================================================
pub fn gst_gl_renderbuffer_allocation_params_get_type() -> GType;
pub fn gst_gl_renderbuffer_allocation_params_new(
context: *mut GstGLContext,
alloc_params: *const gst::GstAllocationParams,
renderbuffer_format: GstGLFormat,
width: c_uint,
height: c_uint,
) -> *mut GstGLRenderbufferAllocationParams;
pub fn gst_gl_renderbuffer_allocation_params_new_wrapped(
context: *mut GstGLContext,
alloc_params: *const gst::GstAllocationParams,
renderbuffer_format: GstGLFormat,
width: c_uint,
height: c_uint,
gl_handle: gpointer,
user_data: gpointer,
notify: glib::GDestroyNotify,
) -> *mut GstGLRenderbufferAllocationParams;
//=========================================================================
// GstGLSyncMeta
//=========================================================================
pub fn gst_gl_sync_meta_set_sync_point(
sync_meta: *mut GstGLSyncMeta,
context: *mut GstGLContext,
);
pub fn gst_gl_sync_meta_wait(sync_meta: *mut GstGLSyncMeta, context: *mut GstGLContext);
pub fn gst_gl_sync_meta_wait_cpu(sync_meta: *mut GstGLSyncMeta, context: *mut GstGLContext);
pub fn gst_gl_sync_meta_get_info() -> *const gst::GstMetaInfo;
//=========================================================================
// GstGLVideoAllocationParams
//=========================================================================
pub fn gst_gl_video_allocation_params_get_type() -> GType;
pub fn gst_gl_video_allocation_params_new(
context: *mut GstGLContext,
alloc_params: *const gst::GstAllocationParams,
v_info: *const gst_video::GstVideoInfo,
plane: c_uint,
valign: *const gst_video::GstVideoAlignment,
target: GstGLTextureTarget,
tex_format: GstGLFormat,
) -> *mut GstGLVideoAllocationParams;
pub fn gst_gl_video_allocation_params_new_wrapped_data(
context: *mut GstGLContext,
alloc_params: *const gst::GstAllocationParams,
v_info: *const gst_video::GstVideoInfo,
plane: c_uint,
valign: *const gst_video::GstVideoAlignment,
target: GstGLTextureTarget,
tex_format: GstGLFormat,
wrapped_data: gpointer,
user_data: gpointer,
notify: glib::GDestroyNotify,
) -> *mut GstGLVideoAllocationParams;
pub fn gst_gl_video_allocation_params_new_wrapped_gl_handle(
context: *mut GstGLContext,
alloc_params: *const gst::GstAllocationParams,
v_info: *const gst_video::GstVideoInfo,
plane: c_uint,
valign: *const gst_video::GstVideoAlignment,
target: GstGLTextureTarget,
tex_format: GstGLFormat,
gl_handle: gpointer,
user_data: gpointer,
notify: glib::GDestroyNotify,
) -> *mut GstGLVideoAllocationParams;
pub fn gst_gl_video_allocation_params_new_wrapped_texture(
context: *mut GstGLContext,
alloc_params: *const gst::GstAllocationParams,
v_info: *const gst_video::GstVideoInfo,
plane: c_uint,
valign: *const gst_video::GstVideoAlignment,
target: GstGLTextureTarget,
tex_format: GstGLFormat,
tex_id: c_uint,
user_data: gpointer,
notify: glib::GDestroyNotify,
) -> *mut GstGLVideoAllocationParams;
pub fn gst_gl_video_allocation_params_copy_data(
src_vid: *mut GstGLVideoAllocationParams,
dest_vid: *mut GstGLVideoAllocationParams,
);
pub fn gst_gl_video_allocation_params_free_data(params: *mut GstGLVideoAllocationParams);
pub fn gst_gl_video_allocation_params_init_full(
params: *mut GstGLVideoAllocationParams,
struct_size: size_t,
alloc_flags: c_uint,
copy: GstGLAllocationParamsCopyFunc,
free: GstGLAllocationParamsFreeFunc,
context: *mut GstGLContext,
alloc_params: *const gst::GstAllocationParams,
v_info: *const gst_video::GstVideoInfo,
plane: c_uint,
valign: *const gst_video::GstVideoAlignment,
target: GstGLTextureTarget,
tex_format: GstGLFormat,
wrapped_data: gpointer,
gl_handle: gpointer,
user_data: gpointer,
notify: glib::GDestroyNotify,
) -> gboolean;
//=========================================================================
// GstGLBaseFilter
//=========================================================================
pub fn gst_gl_base_filter_get_type() -> GType;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_base_filter_find_gl_context(filter: *mut GstGLBaseFilter) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn gst_gl_base_filter_get_gl_context(filter: *mut GstGLBaseFilter) -> *mut GstGLContext;
//=========================================================================
// GstGLBaseMemoryAllocator
//=========================================================================
pub fn gst_gl_base_memory_allocator_get_type() -> GType;
//=========================================================================
// GstGLBaseSrc
//=========================================================================
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn gst_gl_base_src_get_type() -> GType;
//=========================================================================
// GstGLBufferAllocator
//=========================================================================
pub fn gst_gl_buffer_allocator_get_type() -> GType;
//=========================================================================
// GstGLBufferPool
//=========================================================================
pub fn gst_gl_buffer_pool_get_type() -> GType;
pub fn gst_gl_buffer_pool_new(context: *mut GstGLContext) -> *mut gst::GstBufferPool;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_buffer_pool_get_gl_allocation_params(
pool: *mut GstGLBufferPool,
) -> *mut GstGLAllocationParams;
//=========================================================================
// GstGLColorConvert
//=========================================================================
pub fn gst_gl_color_convert_get_type() -> GType;
pub fn gst_gl_color_convert_new(context: *mut GstGLContext) -> *mut GstGLColorConvert;
pub fn gst_gl_color_convert_fixate_caps(
context: *mut GstGLContext,
direction: gst::GstPadDirection,
caps: *mut gst::GstCaps,
other: *mut gst::GstCaps,
) -> *mut gst::GstCaps;
pub fn gst_gl_color_convert_transform_caps(
context: *mut GstGLContext,
direction: gst::GstPadDirection,
caps: *mut gst::GstCaps,
filter: *mut gst::GstCaps,
) -> *mut gst::GstCaps;
pub fn gst_gl_color_convert_decide_allocation(
convert: *mut GstGLColorConvert,
query: *mut gst::GstQuery,
) -> gboolean;
pub fn gst_gl_color_convert_perform(
convert: *mut GstGLColorConvert,
inbuf: *mut gst::GstBuffer,
) -> *mut gst::GstBuffer;
pub fn gst_gl_color_convert_set_caps(
convert: *mut GstGLColorConvert,
in_caps: *mut gst::GstCaps,
out_caps: *mut gst::GstCaps,
) -> gboolean;
//=========================================================================
// GstGLContext
//=========================================================================
pub fn gst_gl_context_get_type() -> GType;
pub fn gst_gl_context_new(display: *mut GstGLDisplay) -> *mut GstGLContext;
pub fn gst_gl_context_new_wrapped(
display: *mut GstGLDisplay,
handle: uintptr_t,
context_type: GstGLPlatform,
available_apis: GstGLAPI,
) -> *mut GstGLContext;
pub fn gst_gl_context_default_get_proc_address(
gl_api: GstGLAPI,
name: *const c_char,
) -> gpointer;
pub fn gst_gl_context_get_current() -> *mut GstGLContext;
pub fn gst_gl_context_get_current_gl_api(
platform: GstGLPlatform,
major: *mut c_uint,
minor: *mut c_uint,
) -> GstGLAPI;
pub fn gst_gl_context_get_current_gl_context(context_type: GstGLPlatform) -> uintptr_t;
pub fn gst_gl_context_get_proc_address_with_platform(
context_type: GstGLPlatform,
gl_api: GstGLAPI,
name: *const c_char,
) -> gpointer;
pub fn gst_gl_context_activate(context: *mut GstGLContext, activate: gboolean) -> gboolean;
pub fn gst_gl_context_can_share(
context: *mut GstGLContext,
other_context: *mut GstGLContext,
) -> gboolean;
pub fn gst_gl_context_check_feature(
context: *mut GstGLContext,
feature: *const c_char,
) -> gboolean;
pub fn gst_gl_context_check_framebuffer_status(
context: *mut GstGLContext,
fbo_target: c_uint,
) -> gboolean;
pub fn gst_gl_context_check_gl_version(
context: *mut GstGLContext,
api: GstGLAPI,
maj: c_int,
min: c_int,
) -> gboolean;
pub fn gst_gl_context_clear_framebuffer(context: *mut GstGLContext);
pub fn gst_gl_context_clear_shader(context: *mut GstGLContext);
pub fn gst_gl_context_create(
context: *mut GstGLContext,
other_context: *mut GstGLContext,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn gst_gl_context_destroy(context: *mut GstGLContext);
pub fn gst_gl_context_fill_info(
context: *mut GstGLContext,
error: *mut *mut glib::GError,
) -> gboolean;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_context_get_config(context: *mut GstGLContext) -> *mut gst::GstStructure;
pub fn gst_gl_context_get_display(context: *mut GstGLContext) -> *mut GstGLDisplay;
pub fn gst_gl_context_get_gl_api(context: *mut GstGLContext) -> GstGLAPI;
pub fn gst_gl_context_get_gl_context(context: *mut GstGLContext) -> uintptr_t;
pub fn gst_gl_context_get_gl_platform(context: *mut GstGLContext) -> GstGLPlatform;
pub fn gst_gl_context_get_gl_platform_version(
context: *mut GstGLContext,
major: *mut c_int,
minor: *mut c_int,
);
pub fn gst_gl_context_get_gl_version(
context: *mut GstGLContext,
maj: *mut c_int,
min: *mut c_int,
);
pub fn gst_gl_context_get_proc_address(
context: *mut GstGLContext,
name: *const c_char,
) -> gpointer;
pub fn gst_gl_context_get_thread(context: *mut GstGLContext) -> *mut glib::GThread;
pub fn gst_gl_context_get_window(context: *mut GstGLContext) -> *mut GstGLWindow;
pub fn gst_gl_context_is_shared(context: *mut GstGLContext) -> gboolean;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_context_request_config(
context: *mut GstGLContext,
gl_config: *mut gst::GstStructure,
) -> gboolean;
pub fn gst_gl_context_set_shared_with(context: *mut GstGLContext, share: *mut GstGLContext);
pub fn gst_gl_context_set_window(
context: *mut GstGLContext,
window: *mut GstGLWindow,
) -> gboolean;
pub fn gst_gl_context_supports_glsl_profile_version(
context: *mut GstGLContext,
version: GstGLSLVersion,
profile: GstGLSLProfile,
) -> gboolean;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_context_supports_precision(
context: *mut GstGLContext,
version: GstGLSLVersion,
profile: GstGLSLProfile,
) -> gboolean;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_context_supports_precision_highp(
context: *mut GstGLContext,
version: GstGLSLVersion,
profile: GstGLSLProfile,
) -> gboolean;
pub fn gst_gl_context_swap_buffers(context: *mut GstGLContext);
pub fn gst_gl_context_thread_add(
context: *mut GstGLContext,
func: GstGLContextThreadFunc,
data: gpointer,
);
//=========================================================================
// GstGLDisplay
//=========================================================================
pub fn gst_gl_display_get_type() -> GType;
pub fn gst_gl_display_new() -> *mut GstGLDisplay;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_display_new_with_type(type_: GstGLDisplayType) -> *mut GstGLDisplay;
pub fn gst_gl_display_add_context(
display: *mut GstGLDisplay,
context: *mut GstGLContext,
) -> gboolean;
pub fn gst_gl_display_create_context(
display: *mut GstGLDisplay,
other_context: *mut GstGLContext,
p_context: *mut *mut GstGLContext,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn gst_gl_display_create_window(display: *mut GstGLDisplay) -> *mut GstGLWindow;
#[cfg(any(feature = "v1_24", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_24")))]
pub fn gst_gl_display_ensure_context(
display: *mut GstGLDisplay,
other_context: *mut GstGLContext,
context: *mut *mut GstGLContext,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn gst_gl_display_filter_gl_api(display: *mut GstGLDisplay, gl_api: GstGLAPI);
pub fn gst_gl_display_find_window(
display: *mut GstGLDisplay,
data: gpointer,
compare_func: glib::GCompareFunc,
) -> *mut GstGLWindow;
pub fn gst_gl_display_get_gl_api(display: *mut GstGLDisplay) -> GstGLAPI;
pub fn gst_gl_display_get_gl_api_unlocked(display: *mut GstGLDisplay) -> GstGLAPI;
pub fn gst_gl_display_get_gl_context_for_thread(
display: *mut GstGLDisplay,
thread: *mut glib::GThread,
) -> *mut GstGLContext;
pub fn gst_gl_display_get_handle(display: *mut GstGLDisplay) -> uintptr_t;
pub fn gst_gl_display_get_handle_type(display: *mut GstGLDisplay) -> GstGLDisplayType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn gst_gl_display_remove_context(display: *mut GstGLDisplay, context: *mut GstGLContext);
pub fn gst_gl_display_remove_window(
display: *mut GstGLDisplay,
window: *mut GstGLWindow,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn gst_gl_display_retrieve_window(
display: *mut GstGLDisplay,
data: gpointer,
compare_func: glib::GCompareFunc,
) -> *mut GstGLWindow;
//=========================================================================
// GstGLFilter
//=========================================================================
pub fn gst_gl_filter_get_type() -> GType;
pub fn gst_gl_filter_add_rgba_pad_templates(klass: *mut GstGLFilterClass);
pub fn gst_gl_filter_draw_fullscreen_quad(filter: *mut GstGLFilter);
pub fn gst_gl_filter_filter_texture(
filter: *mut GstGLFilter,
input: *mut gst::GstBuffer,
output: *mut gst::GstBuffer,
) -> gboolean;
pub fn gst_gl_filter_render_to_target(
filter: *mut GstGLFilter,
input: *mut GstGLMemory,
output: *mut GstGLMemory,
func: GstGLFilterRenderFunc,
data: gpointer,
) -> gboolean;
pub fn gst_gl_filter_render_to_target_with_shader(
filter: *mut GstGLFilter,
input: *mut GstGLMemory,
output: *mut GstGLMemory,
shader: *mut GstGLShader,
);
//=========================================================================
// GstGLFramebuffer
//=========================================================================
pub fn gst_gl_framebuffer_get_type() -> GType;
pub fn gst_gl_framebuffer_new(context: *mut GstGLContext) -> *mut GstGLFramebuffer;
pub fn gst_gl_framebuffer_new_with_default_depth(
context: *mut GstGLContext,
width: c_uint,
height: c_uint,
) -> *mut GstGLFramebuffer;
pub fn gst_gl_framebuffer_attach(
fb: *mut GstGLFramebuffer,
attachment_point: c_uint,
mem: *mut GstGLBaseMemory,
);
pub fn gst_gl_framebuffer_bind(fb: *mut GstGLFramebuffer);
pub fn gst_gl_framebuffer_draw_to_texture(
fb: *mut GstGLFramebuffer,
mem: *mut GstGLMemory,
func: GstGLFramebufferFunc,
user_data: gpointer,
) -> gboolean;
pub fn gst_gl_framebuffer_get_effective_dimensions(
fb: *mut GstGLFramebuffer,
width: *mut c_uint,
height: *mut c_uint,
);
pub fn gst_gl_framebuffer_get_id(fb: *mut GstGLFramebuffer) -> c_uint;
//=========================================================================
// GstGLMemoryAllocator
//=========================================================================
pub fn gst_gl_memory_allocator_get_type() -> GType;
pub fn gst_gl_memory_allocator_get_default(
context: *mut GstGLContext,
) -> *mut GstGLMemoryAllocator;
//=========================================================================
// GstGLMemoryPBOAllocator
//=========================================================================
pub fn gst_gl_memory_pbo_allocator_get_type() -> GType;
//=========================================================================
// GstGLOverlayCompositor
//=========================================================================
pub fn gst_gl_overlay_compositor_get_type() -> GType;
pub fn gst_gl_overlay_compositor_new(context: *mut GstGLContext)
-> *mut GstGLOverlayCompositor;
pub fn gst_gl_overlay_compositor_add_caps(caps: *mut gst::GstCaps) -> *mut gst::GstCaps;
pub fn gst_gl_overlay_compositor_draw_overlays(compositor: *mut GstGLOverlayCompositor);
pub fn gst_gl_overlay_compositor_free_overlays(compositor: *mut GstGLOverlayCompositor);
pub fn gst_gl_overlay_compositor_upload_overlays(
compositor: *mut GstGLOverlayCompositor,
buf: *mut gst::GstBuffer,
);
//=========================================================================
// GstGLRenderbufferAllocator
//=========================================================================
pub fn gst_gl_renderbuffer_allocator_get_type() -> GType;
//=========================================================================
// GstGLSLStage
//=========================================================================
pub fn gst_glsl_stage_get_type() -> GType;
pub fn gst_glsl_stage_new(context: *mut GstGLContext, type_: c_uint) -> *mut GstGLSLStage;
pub fn gst_glsl_stage_new_default_fragment(context: *mut GstGLContext) -> *mut GstGLSLStage;
pub fn gst_glsl_stage_new_default_vertex(context: *mut GstGLContext) -> *mut GstGLSLStage;
pub fn gst_glsl_stage_new_with_string(
context: *mut GstGLContext,
type_: c_uint,
version: GstGLSLVersion,
profile: GstGLSLProfile,
str: *const c_char,
) -> *mut GstGLSLStage;
pub fn gst_glsl_stage_new_with_strings(
context: *mut GstGLContext,
type_: c_uint,
version: GstGLSLVersion,
profile: GstGLSLProfile,
n_strings: c_int,
str: *mut *const c_char,
) -> *mut GstGLSLStage;
pub fn gst_glsl_stage_compile(
stage: *mut GstGLSLStage,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn gst_glsl_stage_get_handle(stage: *mut GstGLSLStage) -> c_uint;
pub fn gst_glsl_stage_get_profile(stage: *mut GstGLSLStage) -> GstGLSLProfile;
pub fn gst_glsl_stage_get_shader_type(stage: *mut GstGLSLStage) -> c_uint;
pub fn gst_glsl_stage_get_version(stage: *mut GstGLSLStage) -> GstGLSLVersion;
pub fn gst_glsl_stage_set_strings(
stage: *mut GstGLSLStage,
version: GstGLSLVersion,
profile: GstGLSLProfile,
n_strings: c_int,
str: *mut *const c_char,
) -> gboolean;
//=========================================================================
// GstGLShader
//=========================================================================
pub fn gst_gl_shader_get_type() -> GType;
pub fn gst_gl_shader_new(context: *mut GstGLContext) -> *mut GstGLShader;
pub fn gst_gl_shader_new_default(
context: *mut GstGLContext,
error: *mut *mut glib::GError,
) -> *mut GstGLShader;
pub fn gst_gl_shader_new_link_with_stages(
context: *mut GstGLContext,
error: *mut *mut glib::GError,
...
) -> *mut GstGLShader;
pub fn gst_gl_shader_new_with_stages(
context: *mut GstGLContext,
error: *mut *mut glib::GError,
...
) -> *mut GstGLShader;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_shader_string_fragment_external_oes_get_default(
context: *mut GstGLContext,
version: GstGLSLVersion,
profile: GstGLSLProfile,
) -> *mut c_char;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_shader_string_fragment_get_default(
context: *mut GstGLContext,
version: GstGLSLVersion,
profile: GstGLSLProfile,
) -> *mut c_char;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_shader_string_get_highest_precision(
context: *mut GstGLContext,
version: GstGLSLVersion,
profile: GstGLSLProfile,
) -> *const c_char;
pub fn gst_gl_shader_attach(shader: *mut GstGLShader, stage: *mut GstGLSLStage) -> gboolean;
pub fn gst_gl_shader_attach_unlocked(
shader: *mut GstGLShader,
stage: *mut GstGLSLStage,
) -> gboolean;
pub fn gst_gl_shader_bind_attribute_location(
shader: *mut GstGLShader,
index: c_uint,
name: *const c_char,
);
pub fn gst_gl_shader_bind_frag_data_location(
shader: *mut GstGLShader,
index: c_uint,
name: *const c_char,
);
pub fn gst_gl_shader_compile_attach_stage(
shader: *mut GstGLShader,
stage: *mut GstGLSLStage,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn gst_gl_shader_detach(shader: *mut GstGLShader, stage: *mut GstGLSLStage);
pub fn gst_gl_shader_detach_unlocked(shader: *mut GstGLShader, stage: *mut GstGLSLStage);
pub fn gst_gl_shader_get_attribute_location(
shader: *mut GstGLShader,
name: *const c_char,
) -> c_int;
pub fn gst_gl_shader_get_program_handle(shader: *mut GstGLShader) -> c_int;
pub fn gst_gl_shader_is_linked(shader: *mut GstGLShader) -> gboolean;
pub fn gst_gl_shader_link(shader: *mut GstGLShader, error: *mut *mut glib::GError) -> gboolean;
pub fn gst_gl_shader_release(shader: *mut GstGLShader);
pub fn gst_gl_shader_release_unlocked(shader: *mut GstGLShader);
pub fn gst_gl_shader_set_uniform_1f(
shader: *mut GstGLShader,
name: *const c_char,
value: c_float,
);
pub fn gst_gl_shader_set_uniform_1fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_uint,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_1i(
shader: *mut GstGLShader,
name: *const c_char,
value: c_int,
);
pub fn gst_gl_shader_set_uniform_1iv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_uint,
value: *const c_int,
);
pub fn gst_gl_shader_set_uniform_2f(
shader: *mut GstGLShader,
name: *const c_char,
v0: c_float,
v1: c_float,
);
pub fn gst_gl_shader_set_uniform_2fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_uint,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_2i(
shader: *mut GstGLShader,
name: *const c_char,
v0: c_int,
v1: c_int,
);
pub fn gst_gl_shader_set_uniform_2iv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_uint,
value: *const c_int,
);
pub fn gst_gl_shader_set_uniform_3f(
shader: *mut GstGLShader,
name: *const c_char,
v0: c_float,
v1: c_float,
v2: c_float,
);
pub fn gst_gl_shader_set_uniform_3fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_uint,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_3i(
shader: *mut GstGLShader,
name: *const c_char,
v0: c_int,
v1: c_int,
v2: c_int,
);
pub fn gst_gl_shader_set_uniform_3iv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_uint,
value: *const c_int,
);
pub fn gst_gl_shader_set_uniform_4f(
shader: *mut GstGLShader,
name: *const c_char,
v0: c_float,
v1: c_float,
v2: c_float,
v3: c_float,
);
pub fn gst_gl_shader_set_uniform_4fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_uint,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_4i(
shader: *mut GstGLShader,
name: *const c_char,
v0: c_int,
v1: c_int,
v2: c_int,
v3: c_int,
);
pub fn gst_gl_shader_set_uniform_4iv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_uint,
value: *const c_int,
);
pub fn gst_gl_shader_set_uniform_matrix_2fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_matrix_2x3fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_matrix_2x4fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_matrix_3fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_matrix_3x2fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_matrix_3x4fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_matrix_4fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_matrix_4x2fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_set_uniform_matrix_4x3fv(
shader: *mut GstGLShader,
name: *const c_char,
count: c_int,
transpose: gboolean,
value: *const c_float,
);
pub fn gst_gl_shader_use(shader: *mut GstGLShader);
//=========================================================================
// GstGLUpload
//=========================================================================
pub fn gst_gl_upload_get_type() -> GType;
pub fn gst_gl_upload_new(context: *mut GstGLContext) -> *mut GstGLUpload;
pub fn gst_gl_upload_get_input_template_caps() -> *mut gst::GstCaps;
pub fn gst_gl_upload_get_caps(
upload: *mut GstGLUpload,
in_caps: *mut *mut gst::GstCaps,
out_caps: *mut *mut gst::GstCaps,
);
pub fn gst_gl_upload_perform_with_buffer(
upload: *mut GstGLUpload,
buffer: *mut gst::GstBuffer,
outbuf_ptr: *mut *mut gst::GstBuffer,
) -> GstGLUploadReturn;
pub fn gst_gl_upload_propose_allocation(
upload: *mut GstGLUpload,
decide_query: *mut gst::GstQuery,
query: *mut gst::GstQuery,
);
pub fn gst_gl_upload_set_caps(
upload: *mut GstGLUpload,
in_caps: *mut gst::GstCaps,
out_caps: *mut gst::GstCaps,
) -> gboolean;
pub fn gst_gl_upload_set_context(upload: *mut GstGLUpload, context: *mut GstGLContext);
pub fn gst_gl_upload_transform_caps(
upload: *mut GstGLUpload,
context: *mut GstGLContext,
direction: gst::GstPadDirection,
caps: *mut gst::GstCaps,
filter: *mut gst::GstCaps,
) -> *mut gst::GstCaps;
//=========================================================================
// GstGLViewConvert
//=========================================================================
pub fn gst_gl_view_convert_get_type() -> GType;
pub fn gst_gl_view_convert_new() -> *mut GstGLViewConvert;
pub fn gst_gl_view_convert_fixate_caps(
viewconvert: *mut GstGLViewConvert,
direction: gst::GstPadDirection,
caps: *mut gst::GstCaps,
othercaps: *mut gst::GstCaps,
) -> *mut gst::GstCaps;
pub fn gst_gl_view_convert_get_output(
viewconvert: *mut GstGLViewConvert,
outbuf_ptr: *mut *mut gst::GstBuffer,
) -> gst::GstFlowReturn;
pub fn gst_gl_view_convert_perform(
viewconvert: *mut GstGLViewConvert,
inbuf: *mut gst::GstBuffer,
) -> *mut gst::GstBuffer;
pub fn gst_gl_view_convert_reset(viewconvert: *mut GstGLViewConvert);
pub fn gst_gl_view_convert_set_caps(
viewconvert: *mut GstGLViewConvert,
in_caps: *mut gst::GstCaps,
out_caps: *mut gst::GstCaps,
) -> gboolean;
pub fn gst_gl_view_convert_set_context(
viewconvert: *mut GstGLViewConvert,
context: *mut GstGLContext,
);
pub fn gst_gl_view_convert_submit_input_buffer(
viewconvert: *mut GstGLViewConvert,
is_discont: gboolean,
input: *mut gst::GstBuffer,
) -> gst::GstFlowReturn;
pub fn gst_gl_view_convert_transform_caps(
viewconvert: *mut GstGLViewConvert,
direction: gst::GstPadDirection,
caps: *mut gst::GstCaps,
filter: *mut gst::GstCaps,
) -> *mut gst::GstCaps;
//=========================================================================
// GstGLWindow
//=========================================================================
pub fn gst_gl_window_get_type() -> GType;
pub fn gst_gl_window_new(display: *mut GstGLDisplay) -> *mut GstGLWindow;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn gst_gl_window_controls_viewport(window: *mut GstGLWindow) -> gboolean;
pub fn gst_gl_window_draw(window: *mut GstGLWindow);
pub fn gst_gl_window_get_context(window: *mut GstGLWindow) -> *mut GstGLContext;
pub fn gst_gl_window_get_display(window: *mut GstGLWindow) -> uintptr_t;
pub fn gst_gl_window_get_surface_dimensions(
window: *mut GstGLWindow,
width: *mut c_uint,
height: *mut c_uint,
);
pub fn gst_gl_window_get_window_handle(window: *mut GstGLWindow) -> uintptr_t;
pub fn gst_gl_window_handle_events(window: *mut GstGLWindow, handle_events: gboolean);
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn gst_gl_window_has_output_surface(window: *mut GstGLWindow) -> gboolean;
pub fn gst_gl_window_queue_resize(window: *mut GstGLWindow);
pub fn gst_gl_window_quit(window: *mut GstGLWindow);
pub fn gst_gl_window_resize(window: *mut GstGLWindow, width: c_uint, height: c_uint);
pub fn gst_gl_window_run(window: *mut GstGLWindow);
pub fn gst_gl_window_send_key_event(
window: *mut GstGLWindow,
event_type: *const c_char,
key_str: *const c_char,
);
pub fn gst_gl_window_send_message(
window: *mut GstGLWindow,
callback: GstGLWindowCB,
data: gpointer,
);
pub fn gst_gl_window_send_message_async(
window: *mut GstGLWindow,
callback: GstGLWindowCB,
data: gpointer,
destroy: glib::GDestroyNotify,
);
pub fn gst_gl_window_send_mouse_event(
window: *mut GstGLWindow,
event_type: *const c_char,
button: c_int,
posx: c_double,
posy: c_double,
);
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn gst_gl_window_send_scroll_event(
window: *mut GstGLWindow,
posx: c_double,
posy: c_double,
delta_x: c_double,
delta_y: c_double,
);
pub fn gst_gl_window_set_close_callback(
window: *mut GstGLWindow,
callback: GstGLWindowCB,
data: gpointer,
destroy_notify: glib::GDestroyNotify,
);
pub fn gst_gl_window_set_draw_callback(
window: *mut GstGLWindow,
callback: GstGLWindowCB,
data: gpointer,
destroy_notify: glib::GDestroyNotify,
);
pub fn gst_gl_window_set_preferred_size(window: *mut GstGLWindow, width: c_int, height: c_int);
pub fn gst_gl_window_set_render_rectangle(
window: *mut GstGLWindow,
x: c_int,
y: c_int,
width: c_int,
height: c_int,
) -> gboolean;
pub fn gst_gl_window_set_resize_callback(
window: *mut GstGLWindow,
callback: GstGLWindowResizeCB,
data: gpointer,
destroy_notify: glib::GDestroyNotify,
);
pub fn gst_gl_window_set_window_handle(window: *mut GstGLWindow, handle: uintptr_t);
pub fn gst_gl_window_show(window: *mut GstGLWindow);
//=========================================================================
// Other functions
//=========================================================================
pub fn gst_buffer_add_gl_sync_meta(
context: *mut GstGLContext,
buffer: *mut gst::GstBuffer,
) -> *mut GstGLSyncMeta;
pub fn gst_buffer_add_gl_sync_meta_full(
context: *mut GstGLContext,
buffer: *mut gst::GstBuffer,
data: gpointer,
) -> *mut GstGLSyncMeta;
pub fn gst_buffer_pool_config_get_gl_allocation_params(
config: *mut gst::GstStructure,
) -> *mut GstGLAllocationParams;
pub fn gst_buffer_pool_config_set_gl_allocation_params(
config: *mut gst::GstStructure,
params: *const GstGLAllocationParams,
);
pub fn gst_context_get_gl_display(
context: *mut gst::GstContext,
display: *mut *mut GstGLDisplay,
) -> gboolean;
pub fn gst_context_set_gl_display(context: *mut gst::GstContext, display: *mut GstGLDisplay);
pub fn gst_gl_check_extension(name: *const c_char, ext: *const c_char) -> gboolean;
pub fn gst_gl_element_propagate_display_context(
element: *mut gst::GstElement,
display: *mut GstGLDisplay,
);
pub fn gst_gl_ensure_element_data(
element: *mut gst::GstElement,
display_ptr: *mut *mut GstGLDisplay,
other_context_ptr: *mut *mut GstGLContext,
) -> gboolean;
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_get_affine_transformation_meta_as_ndc(
meta: *mut gst_video::GstVideoAffineTransformationMeta,
matrix: *mut [c_float; 16],
);
pub fn gst_gl_get_plane_data_size(
info: *const gst_video::GstVideoInfo,
align: *const gst_video::GstVideoAlignment,
plane: c_uint,
) -> size_t;
pub fn gst_gl_get_plane_start(
info: *const gst_video::GstVideoInfo,
valign: *const gst_video::GstVideoAlignment,
plane: c_uint,
) -> size_t;
pub fn gst_gl_handle_context_query(
element: *mut gst::GstElement,
query: *mut gst::GstQuery,
display: *mut GstGLDisplay,
context: *mut GstGLContext,
other_context: *mut GstGLContext,
) -> gboolean;
pub fn gst_gl_handle_set_context(
element: *mut gst::GstElement,
context: *mut gst::GstContext,
display: *mut *mut GstGLDisplay,
other_context: *mut *mut GstGLContext,
) -> gboolean;
pub fn gst_gl_insert_debug_marker(context: *mut GstGLContext, format: *const c_char, ...);
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_multiply_matrix4(
a: *const [c_float; 16],
b: *const [c_float; 16],
result: *mut [c_float; 16],
);
#[cfg(any(feature = "v1_20", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_20")))]
pub fn gst_gl_set_affine_transformation_meta_from_ndc(
meta: *mut gst_video::GstVideoAffineTransformationMeta,
matrix: *const [c_float; 16],
);
pub fn gst_gl_sized_gl_format_from_gl_format_type(
context: *mut GstGLContext,
format: c_uint,
type_: c_uint,
) -> c_uint;
pub fn gst_gl_stereo_downmix_mode_get_type() -> GType;
pub fn gst_gl_sync_meta_api_get_type() -> GType;
pub fn gst_gl_value_get_texture_target_mask(
value: *const gobject::GValue,
) -> GstGLTextureTarget;
pub fn gst_gl_value_set_texture_target(
value: *mut gobject::GValue,
target: GstGLTextureTarget,
) -> gboolean;
pub fn gst_gl_value_set_texture_target_from_mask(
value: *mut gobject::GValue,
target_mask: GstGLTextureTarget,
) -> gboolean;
pub fn gst_gl_version_to_glsl_version(
gl_api: GstGLAPI,
maj: c_int,
min: c_int,
) -> GstGLSLVersion;
pub fn gst_glsl_string_get_version_profile(
s: *const c_char,
version: *mut GstGLSLVersion,
profile: *mut GstGLSLProfile,
) -> gboolean;
pub fn gst_is_gl_base_memory(mem: *mut gst::GstMemory) -> gboolean;
pub fn gst_is_gl_buffer(mem: *mut gst::GstMemory) -> gboolean;
pub fn gst_is_gl_memory(mem: *mut gst::GstMemory) -> gboolean;
pub fn gst_is_gl_memory_pbo(mem: *mut gst::GstMemory) -> gboolean;
pub fn gst_is_gl_renderbuffer(mem: *mut gst::GstMemory) -> gboolean;
}
Reference in a new issue View git blame Copy permalink