// Generated by gir (https://github.com/gtk-rs/gir @ 1bef39f) // from gir-files (https://github.com/gtk-rs/gir-files @ 7d95377) // from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git @ 85bd06b) // 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))] use glib_sys as glib; use gobject_sys as gobject; use gstreamer_base_sys as gst_base; use gstreamer_sys as gst; use gstreamer_video_sys as gst_video; 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, time_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: *const c_char = b"GstBufferPoolOptionGLSyncMeta\0" as *const u8 as *const c_char; pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_2D: *const c_char = b"GstBufferPoolOptionGLTextureTarget2D\0" as *const u8 as *const c_char; pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_EXTERNAL_OES: *const c_char = b"GstBufferPoolOptionGLTextureTargetExternalOES\0" as *const u8 as *const c_char; pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_RECTANGLE: *const c_char = b"GstBufferPoolOptionGLTextureTargetRectangle\0" as *const u8 as *const c_char; pub const GST_CAPS_FEATURE_MEMORY_GL_BUFFER: *const c_char = b"memory:GLBuffer\0" as *const u8 as *const c_char; pub const GST_CAPS_FEATURE_MEMORY_GL_MEMORY: *const c_char = b"memory:GLMemory\0" as *const u8 as *const c_char; 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: *const c_char = b"gles1\0" as *const u8 as *const c_char; pub const GST_GL_API_GLES2_NAME: *const c_char = b"gles2\0" as *const u8 as *const c_char; pub const GST_GL_API_OPENGL3_NAME: *const c_char = b"opengl3\0" as *const u8 as *const c_char; pub const GST_GL_API_OPENGL_NAME: *const c_char = b"opengl\0" as *const u8 as *const c_char; pub const GST_GL_BASE_MEMORY_ALLOCATOR_NAME: *const c_char = b"GLBaseMemory\0" as *const u8 as *const c_char; pub const GST_GL_BUFFER_ALLOCATOR_NAME: *const c_char = b"GLBuffer\0" as *const u8 as *const c_char; pub const GST_GL_COLOR_CONVERT_EXT_FORMATS: *const c_char = b", BGR10A2_LE, RGB10A2_LE, P010_10LE, P012_LE, P016_LE, Y212_LE, Y412_LE\0" as *const u8 as *const c_char; pub const GST_GL_CONFIG_STRUCTURE_NAME: *const c_char = b"gst-gl-context-config\0" as *const u8 as *const c_char; pub const GST_GL_CONTEXT_TYPE_CGL: *const c_char = b"gst.gl.context.CGL\0" as *const u8 as *const c_char; pub const GST_GL_CONTEXT_TYPE_EAGL: *const c_char = b"gst.gl.context.EAGL\0" as *const u8 as *const c_char; pub const GST_GL_CONTEXT_TYPE_EGL: *const c_char = b"gst.gl.context.EGL\0" as *const u8 as *const c_char; pub const GST_GL_CONTEXT_TYPE_GLX: *const c_char = b"gst.gl.context.GLX\0" as *const u8 as *const c_char; pub const GST_GL_CONTEXT_TYPE_WGL: *const c_char = b"gst.gl.context.WGL\0" as *const u8 as *const c_char; pub const GST_GL_DISPLAY_CONTEXT_TYPE: *const c_char = b"gst.gl.GLDisplay\0" as *const u8 as *const c_char; pub const GST_GL_MEMORY_ALLOCATOR_NAME: *const c_char = b"GLMemory\0" as *const u8 as *const c_char; pub const GST_GL_MEMORY_PBO_ALLOCATOR_NAME: *const c_char = b"GLMemoryPBO\0" as *const u8 as *const c_char; pub const GST_GL_MEMORY_VIDEO_EXT_FORMATS: *const c_char = b", BGR10A2_LE, RGB10A2_LE, P010_10LE, P012_LE, P016_LE, Y212_LE, Y412_LE\0" as *const u8 as *const c_char; pub const GST_GL_RENDERBUFFER_ALLOCATOR_NAME: *const c_char = b"GLRenderbuffer\0" as *const u8 as *const c_char; pub const GST_GL_TEXTURE_TARGET_2D_STR: *const c_char = b"2D\0" as *const u8 as *const c_char; pub const GST_GL_TEXTURE_TARGET_EXTERNAL_OES_STR: *const c_char = b"external-oes\0" as *const u8 as *const c_char; pub const GST_GL_TEXTURE_TARGET_RECTANGLE_STR: *const c_char = b"rectangle\0" as *const u8 as *const c_char; 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; pub type GstGLAllocationParamsFreeFunc = Option; pub type GstGLAsyncDebugLogGetMessage = Option *mut c_char>; pub type GstGLBaseMemoryAllocatorAllocFunction = Option< unsafe extern "C" fn( *mut GstGLBaseMemoryAllocator, *mut GstGLAllocationParams, ) -> *mut GstGLBaseMemory, >; pub type GstGLBaseMemoryAllocatorCopyFunction = Option *mut GstGLBaseMemory>; pub type GstGLBaseMemoryAllocatorCreateFunction = Option gboolean>; pub type GstGLBaseMemoryAllocatorDestroyFunction = Option; pub type GstGLBaseMemoryAllocatorMapFunction = Option gpointer>; pub type GstGLBaseMemoryAllocatorUnmapFunction = Option; pub type GstGLContextThreadFunc = Option; pub type GstGLFilterRenderFunc = Option gboolean>; pub type GstGLFramebufferFunc = Option gboolean>; pub type GstGLWindowCB = Option; pub type GstGLWindowResizeCB = Option; // Records #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] pub struct GstGLBaseFilterClass { pub parent_class: gst_base::GstBaseTransformClass, pub supported_gl_api: GstGLAPI, pub gl_start: Option gboolean>, pub gl_stop: Option, 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 @ {:p}", self)) .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(c_void); pub type GstGLBaseFilterPrivate = *mut _GstGLBaseFilterPrivate; #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] pub struct GstGLBaseSrcClass { pub parent_class: gst_base::GstPushSrcClass, pub supported_gl_api: GstGLAPI, pub gl_start: Option gboolean>, pub gl_stop: Option, pub fill_gl_memory: Option 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 @ {:p}", self)) .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(c_void); pub type GstGLBaseSrcPrivate = *mut _GstGLBaseSrcPrivate; #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("mem", &self.mem) .field("id", &self.id) .field("target", &self.target) .field("usage_hints", &self.usage_hints) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("gl_target", &self.gl_target) .field("gl_usage", &self.gl_usage) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .finish() } } #[repr(C)] pub struct _GstGLBufferPoolPrivate(c_void); pub type GstGLBufferPoolPrivate = *mut _GstGLBufferPoolPrivate; #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] pub struct _GstGLColorConvertPrivate(c_void); pub type GstGLColorConvertPrivate = *mut _GstGLColorConvertPrivate; #[repr(C)] #[derive(Copy, Clone)] pub struct GstGLContextClass { pub parent_class: gst::GstObjectClass, pub get_current_context: Option uintptr_t>, pub get_gl_context: Option uintptr_t>, pub get_gl_api: Option GstGLAPI>, pub get_gl_platform: Option GstGLPlatform>, pub get_proc_address: Option gpointer>, pub activate: Option gboolean>, pub choose_format: Option gboolean>, pub create_context: Option< unsafe extern "C" fn( *mut GstGLContext, GstGLAPI, *mut GstGLContext, *mut *mut glib::GError, ) -> gboolean, >, pub destroy_context: Option, pub swap_buffers: Option, pub check_feature: Option gboolean>, pub get_gl_platform_version: Option, pub get_config: Option *mut gst::GstStructure>, pub request_config: Option 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 @ {:p}", self)) .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(c_void); pub type GstGLContextPrivate = *mut _GstGLContextPrivate; #[repr(C)] #[derive(Copy, Clone)] pub struct GstGLDisplayClass { pub object_class: gst::GstObjectClass, pub get_handle: Option uintptr_t>, pub create_window: Option *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 @ {:p}", self)) .field("object_class", &self.object_class) .field("get_handle", &self.get_handle) .field("create_window", &self.create_window) .finish() } } #[repr(C)] pub struct _GstGLDisplayPrivate(c_void); pub type GstGLDisplayPrivate = *mut _GstGLDisplayPrivate; #[repr(C)] #[derive(Copy, Clone)] 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 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] pub struct _GstGLFramebufferPrivate(c_void); pub type GstGLFramebufferPrivate = *mut _GstGLFramebufferPrivate; #[repr(C)] pub struct _GstGLFuncs(c_void); pub type GstGLFuncs = *mut _GstGLFuncs; #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("map", &self.map) .field("copy", &self.copy) .field("unmap", &self.unmap) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("object_class", &self.object_class) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)).finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("renderbuffer_format", &self.renderbuffer_format) .field("width", &self.width) .field("height", &self.height) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] pub struct _GstGLSLStagePrivate(c_void); pub type GstGLSLStagePrivate = *mut _GstGLSLStagePrivate; #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] pub struct _GstGLShaderPrivate(c_void); pub type GstGLShaderPrivate = *mut _GstGLShaderPrivate; #[repr(C)] #[derive(Copy, Clone)] pub struct GstGLSyncMeta { pub parent: gst::GstMeta, pub context: *mut GstGLContext, pub data: gpointer, pub set_sync: Option, pub set_sync_gl: Option, pub wait: Option, pub wait_gl: Option, pub wait_cpu: Option, pub wait_cpu_gl: Option, pub copy: Option< unsafe extern "C" fn( *mut GstGLSyncMeta, *mut gst::GstBuffer, *mut GstGLSyncMeta, *mut gst::GstBuffer, ), >, pub free: Option, pub free_gl: Option, } impl ::std::fmt::Debug for GstGLSyncMeta { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GstGLSyncMeta @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("object_class", &self.object_class) .finish() } } #[repr(C)] pub struct _GstGLUploadPrivate(c_void); pub type GstGLUploadPrivate = *mut _GstGLUploadPrivate; #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] pub struct _GstGLViewConvertPrivate(c_void); pub type GstGLViewConvertPrivate = *mut _GstGLViewConvertPrivate; #[repr(C)] #[derive(Copy, Clone)] pub struct GstGLWindowClass { pub parent_class: gst::GstObjectClass, pub get_display: Option uintptr_t>, pub set_window_handle: Option, pub get_window_handle: Option uintptr_t>, pub draw: Option, pub run: Option, pub quit: Option, pub send_message: Option, pub send_message_async: Option< unsafe extern "C" fn(*mut GstGLWindow, GstGLWindowCB, gpointer, glib::GDestroyNotify), >, pub open: Option gboolean>, pub close: Option, pub handle_events: Option, pub set_preferred_size: Option, pub show: Option, pub set_render_rectangle: Option gboolean>, pub queue_resize: Option, pub controls_viewport: Option gboolean>, pub has_output_surface: Option 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 @ {:p}", self)) .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(c_void); pub type GstGLWindowPrivate = *mut _GstGLWindowPrivate; // Classes #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("bufferpool", &self.bufferpool) .field("context", &self.context) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("gl_vtable", &self.gl_vtable) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("context", &self.context) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("context", &self.context) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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; 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: gpointer, display_ptr: *mut *mut GstGLDisplay, other_context_ptr: *mut *mut GstGLContext, ) -> gboolean; 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, ...); 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; }