diff --git a/gstreamer-gl-sys/Cargo.toml b/gstreamer-gl-sys/Cargo.toml new file mode 100644 index 000000000..ba5ae09ed --- /dev/null +++ b/gstreamer-gl-sys/Cargo.toml @@ -0,0 +1,46 @@ +[build-dependencies] +pkg-config = "0.3.7" + +[dependencies] +libc = "0.2" + +[dependencies.glib-sys] +path = "../glib-sys" +version = "0.2.0" + +[dependencies.gobject-sys] +path = "../gobject-sys" +version = "0.2.0" + +[dependencies.gstreamer-base-sys] +path = "../gstreamer-base-sys" +version = "0.2.0" + +[dependencies.gstreamer-sys] +path = "../gstreamer-sys" +version = "0.2.0" + +[dependencies.gstreamer-video-sys] +path = "../gstreamer-video-sys" +version = "0.2.0" + +[dev-dependencies] +shell-words = "0.1.0" +tempdir = "0.3" + +[features] +dox = [] +v1_10 = ["v1_8"] +v1_12 = ["v1_10"] +v1_4 = [] +v1_6 = ["v1_4"] +v1_8 = ["v1_6"] + +[lib] +name = "gst_gl_sys" + +[package] +build = "build.rs" +links = "gst_gl" +name = "gst-gl-sys" +version = "0.2.0" diff --git a/gstreamer-gl-sys/build.rs b/gstreamer-gl-sys/build.rs new file mode 100644 index 000000000..0d2be71d9 --- /dev/null +++ b/gstreamer-gl-sys/build.rs @@ -0,0 +1,70 @@ +extern crate pkg_config; + +use pkg_config::{Config, Error}; +use std::env; +use std::io::prelude::*; +use std::io; +use std::process; + +fn main() { + if let Err(s) = find() { + let _ = writeln!(io::stderr(), "{}", s); + process::exit(1); + } +} + +fn find() -> Result<(), Error> { + let package_name = "gstreamer-gl-1.0"; + let shared_libs = ["gstgl-1.0"]; + let version = if cfg!(feature = "v1_12") { + "1.12" + } else if cfg!(feature = "v1_10") { + "1.10" + } else if cfg!(feature = "v1_8") { + "1.8" + } else if cfg!(feature = "v1_6") { + "1.6" + } else { + "1.0" + }; + + if let Ok(lib_dir) = env::var("GTK_LIB_DIR") { + for lib_ in shared_libs.iter() { + println!("cargo:rustc-link-lib=dylib={}", lib_); + } + println!("cargo:rustc-link-search=native={}", lib_dir); + return Ok(()) + } + + let target = env::var("TARGET").expect("TARGET environment variable doesn't exist"); + let hardcode_shared_libs = target.contains("windows"); + + let mut config = Config::new(); + config.atleast_version(version); + config.print_system_libs(false); + if hardcode_shared_libs { + config.cargo_metadata(false); + } + match config.probe(package_name) { + Ok(library) => { + if hardcode_shared_libs { + for lib_ in shared_libs.iter() { + println!("cargo:rustc-link-lib=dylib={}", lib_); + } + for path in library.link_paths.iter() { + println!("cargo:rustc-link-search=native={}", + path.to_str().expect("library path doesn't exist")); + } + } + Ok(()) + } + Err(Error::EnvNoPkgConfig(_)) | Err(Error::Command { .. }) => { + for lib_ in shared_libs.iter() { + println!("cargo:rustc-link-lib=dylib={}", lib_); + } + Ok(()) + } + Err(err) => Err(err), + } +} + diff --git a/gstreamer-gl-sys/src/lib.rs b/gstreamer-gl-sys/src/lib.rs new file mode 100644 index 000000000..23b3afffd --- /dev/null +++ b/gstreamer-gl-sys/src/lib.rs @@ -0,0 +1,1981 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir @ f5fca82) +// from gir-files (https://github.com/gtk-rs/gir-files @ ???) +// DO NOT EDIT + +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] +#![cfg_attr(feature = "cargo-clippy", allow(approx_constant, type_complexity, unreadable_literal))] + +extern crate libc; +extern crate glib_sys as glib; +extern crate gobject_sys as gobject; +extern crate gstreamer_sys as gst; +extern crate gstreamer_base_sys as gst_base; +extern crate gstreamer_video_sys as gst_video; + +#[allow(unused_imports)] +use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double, + c_short, c_ushort, c_long, c_ulong, + c_void, size_t, ssize_t, intptr_t, uintptr_t, time_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 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_RGBA: GstGLFormat = 6408; +pub const GST_GL_RGBA8: GstGLFormat = 32856; +pub const GST_GL_DEPTH_COMPONENT16: GstGLFormat = 33189; +pub const GST_GL_DEPTH24_STENCIL8: GstGLFormat = 35056; + +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 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_FORMATS: *const c_char = b"{ RGBA, RGB, RGBx, BGR, BGRx, BGRA, xRGB, xBGR, ARGB, ABGR, Y444, I420, YV12, Y42B, Y41B, NV12, NV21, YUY2, UYVY, AYUV, GRAY8, GRAY16_LE, GRAY16_BE, RGB16, BGR16 }\0" as *const u8 as *const c_char; +pub const GST_GL_COLOR_CONVERT_VIDEO_CAPS: *const c_char = b"video/x-raw(\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_DISPLAY_EGL_NAME: *const c_char = b"gst.gl.display.egl\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_FORMATS_STR: *const c_char = b"{ RGBA, BGRA, RGBx, BGRx, ARGB, ABGR, xRGB, xBGR, RGB, BGR, RGB16, BGR16, AYUV, I420, YV12, NV12, NV21, YUY2, UYVY, Y41B, Y42B, Y444, GRAY8, GRAY16_LE, GRAY16_BE }\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 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; +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 *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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 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 as *const _)) + .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); + +impl ::std::fmt::Debug for GstGLBaseFilterPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLBaseFilterPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 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 as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .finish() + } +} + +#[repr(C)] +pub struct GstGLBufferPoolPrivate(c_void); + +impl ::std::fmt::Debug for GstGLBufferPoolPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLBufferPoolPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[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 @ {:?}", self as *const _)) + .finish() + } +} + +#[repr(C)] +pub struct GstGLColorConvertPrivate(c_void); + +impl ::std::fmt::Debug for GstGLColorConvertPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLColorConvertPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[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 gboolean>, + pub destroy_context: Option, + pub swap_buffers: Option, + pub check_feature: Option gboolean>, + pub get_gl_platform_version: Option, + pub _reserved: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstGLContextClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLContextClass @ {:?}", self as *const _)) + .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) + .finish() + } +} + +#[repr(C)] +pub struct GstGLContextPrivate(c_void); + +impl ::std::fmt::Debug for GstGLContextPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLContextPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[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 @ {:?}", self as *const _)) + .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); + +impl ::std::fmt::Debug for GstGLDisplayPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLDisplayPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstGLFilterClass { + pub parent_class: GstGLBaseFilterClass, + pub set_caps: Option gboolean>, + pub filter: Option gboolean>, + pub filter_texture: Option gboolean>, + pub init_fbo: Option gboolean>, + pub transform_internal_caps: Option *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 as *const _)) + .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 @ {:?}", self as *const _)) + .finish() + } +} + +#[repr(C)] +pub struct GstGLFramebufferPrivate(c_void); + +impl ::std::fmt::Debug for GstGLFramebufferPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLFramebufferPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[repr(C)] +pub struct GstGLFuncs(c_void); + +impl ::std::fmt::Debug for GstGLFuncs { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLFuncs @ {:?}", self as *const _)) + .finish() + } +} + +#[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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .field("mem", &self.mem) + .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 @ {:?}", self as *const _)) + .field("parent", &self.parent) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .finish() + } +} + +#[repr(C)] +pub struct GstGLSLStagePrivate(c_void); + +impl ::std::fmt::Debug for GstGLSLStagePrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLSLStagePrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[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 @ {:?}", self as *const _)) + .finish() + } +} + +#[repr(C)] +pub struct GstGLShaderPrivate(c_void); + +impl ::std::fmt::Debug for GstGLShaderPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLShaderPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[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, + 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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .field("object_class", &self.object_class) + .finish() + } +} + +#[repr(C)] +pub struct GstGLUploadPrivate(c_void); + +impl ::std::fmt::Debug for GstGLUploadPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLUploadPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .finish() + } +} + +#[repr(C)] +pub struct GstGLViewConvertPrivate(c_void); + +impl ::std::fmt::Debug for GstGLViewConvertPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLViewConvertPrivate @ {:?}", self as *const _)) + .finish() + } +} + +#[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, + 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 _reserved: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstGLWindowClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLWindowClass @ {:?}", self as *const _)) + .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) + .finish() + } +} + +#[repr(C)] +pub struct GstGLWindowPrivate(c_void); + +impl ::std::fmt::Debug for GstGLWindowPrivate { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstGLWindowPrivate @ {:?}", self as *const _)) + .finish() + } +} + +// 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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("context", &self.context) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .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 @ {:?}", self as *const _)) + .finish() + } +} + +extern "C" { + + //========================================================================= + // GstGLStereoDownmix + //========================================================================= + pub fn gst_gl_stereo_downmix_mode_get_type() -> GType; + + //========================================================================= + // GstGLAllocationParams + //========================================================================= + pub fn gst_gl_allocation_params_get_type() -> GType; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_allocation_params_copy(src: *mut GstGLAllocationParams) -> *mut GstGLAllocationParams; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_allocation_params_copy_data(src: *mut GstGLAllocationParams, dest: *mut GstGLAllocationParams); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_allocation_params_free(params: *mut GstGLAllocationParams); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_allocation_params_free_data(params: *mut GstGLAllocationParams); + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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: *mut gst::GstAllocationParams, wrapped_data: gpointer, gl_handle: gpointer, user_data: gpointer, notify: glib::GDestroyNotify) -> gboolean; + + //========================================================================= + // GstGLAsyncDebug + //========================================================================= + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_async_debug_free(ad: *mut GstGLAsyncDebug); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_async_debug_freeze(ad: *mut GstGLAsyncDebug); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_async_debug_init(ad: *mut GstGLAsyncDebug); + pub fn gst_gl_async_debug_output_log_msg(ad: *mut GstGLAsyncDebug); + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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, ...); + //#[cfg(any(feature = "v1_8", feature = "dox"))] + //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); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_async_debug_thaw(ad: *mut GstGLAsyncDebug); + pub fn gst_gl_async_debug_unset(ad: *mut GstGLAsyncDebug); + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_base_memory_init(mem: *mut GstGLBaseMemory, allocator: *mut gst::GstAllocator, parent: *mut gst::GstMemory, context: *mut GstGLContext, params: *mut gst::GstAllocationParams, size: size_t, user_data: gpointer, notify: glib::GDestroyNotify); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_base_memory_memcpy(src: *mut GstGLBaseMemory, dest: *mut GstGLBaseMemory, offset: ssize_t, size: ssize_t) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_base_memory_alloc(allocator: *mut GstGLBaseMemoryAllocator, params: *mut GstGLAllocationParams) -> *mut GstGLBaseMemory; + pub fn gst_gl_base_memory_error_quark() -> glib::GQuark; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_base_memory_init_once(); + + //========================================================================= + // GstGLBuffer + //========================================================================= + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_buffer_init_once(); + + //========================================================================= + // GstGLBufferAllocationParams + //========================================================================= + pub fn gst_gl_buffer_allocation_params_get_type() -> GType; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_buffer_allocation_params_new(context: *mut GstGLContext, alloc_size: size_t, alloc_params: *mut gst::GstAllocationParams, gl_target: c_uint, gl_usage: c_uint) -> *mut GstGLBufferAllocationParams; + + //========================================================================= + // GstGLMemory + //========================================================================= + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_12", feature = "dox"))] + pub fn gst_gl_memory_get_texture_format(gl_mem: *mut GstGLMemory) -> GstGLFormat; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_memory_get_texture_height(gl_mem: *mut GstGLMemory) -> c_int; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_memory_get_texture_id(gl_mem: *mut GstGLMemory) -> c_uint; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_memory_get_texture_target(gl_mem: *mut GstGLMemory) -> GstGLTextureTarget; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_memory_get_texture_width(gl_mem: *mut GstGLMemory) -> c_int; + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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: *mut gst::GstAllocationParams, info: *mut gst_video::GstVideoInfo, plane: c_uint, valign: *mut gst_video::GstVideoAlignment, user_data: gpointer, notify: glib::GDestroyNotify); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_memory_read_pixels(gl_mem: *mut GstGLMemory, read_pointer: gpointer) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_memory_texsubimage(gl_mem: *mut GstGLMemory, read_pointer: gpointer); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_memory_init_once(); + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_memory_pbo_download_transfer(gl_mem: *mut GstGLMemoryPBO); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_memory_pbo_upload_transfer(gl_mem: *mut GstGLMemoryPBO); + pub fn gst_gl_memory_pbo_init_once(); + + //========================================================================= + // GstGLQuery + //========================================================================= + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_query_counter(query: *mut GstGLQuery); + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_query_end(query: *mut GstGLQuery); + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_query_free(query: *mut GstGLQuery); + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_query_init(query: *mut GstGLQuery, context: *mut GstGLContext, query_type: GstGLQueryType); + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_query_result(query: *mut GstGLQuery) -> u64; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_query_start(query: *mut GstGLQuery); + #[cfg(any(feature = "v1_10", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_query_new(context: *mut GstGLContext, query_type: GstGLQueryType) -> *mut GstGLQuery; + + //========================================================================= + // GstGLRenderbuffer + //========================================================================= + #[cfg(any(feature = "v1_12", feature = "dox"))] + pub fn gst_gl_renderbuffer_get_format(gl_mem: *mut GstGLRenderbuffer) -> GstGLFormat; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_renderbuffer_get_height(gl_mem: *mut GstGLRenderbuffer) -> c_int; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_renderbuffer_get_id(gl_mem: *mut GstGLRenderbuffer) -> c_uint; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_renderbuffer_get_width(gl_mem: *mut GstGLRenderbuffer) -> c_int; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_renderbuffer_init_once(); + + //========================================================================= + // GstGLRenderbufferAllocationParams + //========================================================================= + pub fn gst_gl_renderbuffer_allocation_params_get_type() -> GType; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_renderbuffer_allocation_params_new(context: *mut GstGLContext, alloc_params: *mut gst::GstAllocationParams, renderbuffer_format: GstGLFormat, width: c_uint, height: c_uint) -> *mut GstGLRenderbufferAllocationParams; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_renderbuffer_allocation_params_new_wrapped(context: *mut GstGLContext, alloc_params: *mut gst::GstAllocationParams, renderbuffer_format: GstGLFormat, width: c_uint, height: c_uint, gl_handle: gpointer, user_data: gpointer, notify: glib::GDestroyNotify) -> *mut GstGLRenderbufferAllocationParams; + + //========================================================================= + // GstGLSyncMeta + //========================================================================= + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_sync_meta_set_sync_point(sync_meta: *mut GstGLSyncMeta, context: *mut GstGLContext); + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_sync_meta_wait(sync_meta: *mut GstGLSyncMeta, context: *mut GstGLContext); + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_video_allocation_params_new(context: *mut GstGLContext, alloc_params: *mut gst::GstAllocationParams, v_info: *mut gst_video::GstVideoInfo, plane: c_uint, valign: *mut gst_video::GstVideoAlignment, target: GstGLTextureTarget, tex_format: GstGLFormat) -> *mut GstGLVideoAllocationParams; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_video_allocation_params_new_wrapped_data(context: *mut GstGLContext, alloc_params: *mut gst::GstAllocationParams, v_info: *mut gst_video::GstVideoInfo, plane: c_uint, valign: *mut gst_video::GstVideoAlignment, target: GstGLTextureTarget, tex_format: GstGLFormat, wrapped_data: gpointer, user_data: gpointer, notify: glib::GDestroyNotify) -> *mut GstGLVideoAllocationParams; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_video_allocation_params_new_wrapped_gl_handle(context: *mut GstGLContext, alloc_params: *mut gst::GstAllocationParams, v_info: *mut gst_video::GstVideoInfo, plane: c_uint, valign: *mut gst_video::GstVideoAlignment, target: GstGLTextureTarget, tex_format: GstGLFormat, gl_handle: gpointer, user_data: gpointer, notify: glib::GDestroyNotify) -> *mut GstGLVideoAllocationParams; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_video_allocation_params_new_wrapped_texture(context: *mut GstGLContext, alloc_params: *mut gst::GstAllocationParams, v_info: *mut gst_video::GstVideoInfo, plane: c_uint, valign: *mut gst_video::GstVideoAlignment, target: GstGLTextureTarget, tex_format: GstGLFormat, tex_id: c_uint, user_data: gpointer, notify: glib::GDestroyNotify) -> *mut GstGLVideoAllocationParams; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_video_allocation_params_copy_data(src_vid: *mut GstGLVideoAllocationParams, dest_vid: *mut GstGLVideoAllocationParams); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_video_allocation_params_free_data(params: *mut GstGLVideoAllocationParams); + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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: *mut gst::GstAllocationParams, v_info: *mut gst_video::GstVideoInfo, plane: c_uint, valign: *mut 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; + + //========================================================================= + // GstGLBaseMemoryAllocator + //========================================================================= + pub fn gst_gl_base_memory_allocator_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; + + //========================================================================= + // GstGLColorConvert + //========================================================================= + pub fn gst_gl_color_convert_get_type() -> GType; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_color_convert_new(context: *mut GstGLContext) -> *mut GstGLColorConvert; + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_6", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_color_convert_decide_allocation(convert: *mut GstGLColorConvert, query: *mut gst::GstQuery) -> gboolean; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_color_convert_perform(convert: *mut GstGLColorConvert, inbuf: *mut gst::GstBuffer) -> *mut gst::GstBuffer; + #[cfg(any(feature = "v1_6", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_new(display: *mut GstGLDisplay) -> *mut GstGLContext; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_new_wrapped(display: *mut GstGLDisplay, handle: uintptr_t, context_type: GstGLPlatform, available_apis: GstGLAPI) -> *mut GstGLContext; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_default_get_proc_address(gl_api: GstGLAPI, name: *const c_char) -> gpointer; + pub fn gst_gl_context_error_quark() -> glib::GQuark; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_context_get_current() -> *mut GstGLContext; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_context_get_current_gl_api(platform: GstGLPlatform, major: *mut c_uint, minor: *mut c_uint) -> GstGLAPI; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_context_get_current_gl_context(context_type: GstGLPlatform) -> uintptr_t; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_context_get_proc_address_with_platform(context_type: GstGLPlatform, gl_api: GstGLAPI, name: *const c_char) -> gpointer; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_activate(context: *mut GstGLContext, activate: gboolean) -> gboolean; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_context_can_share(context: *mut GstGLContext, other_context: *mut GstGLContext) -> gboolean; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_check_feature(context: *mut GstGLContext, feature: *const c_char) -> gboolean; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_context_check_framebuffer_status(context: *mut GstGLContext, fbo_target: c_uint) -> gboolean; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_check_gl_version(context: *mut GstGLContext, api: GstGLAPI, maj: c_int, min: c_int) -> gboolean; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_context_clear_framebuffer(context: *mut GstGLContext); + pub fn gst_gl_context_clear_shader(context: *mut GstGLContext); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_create(context: *mut GstGLContext, other_context: *mut GstGLContext, error: *mut *mut glib::GError) -> gboolean; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_context_destroy(context: *mut GstGLContext); + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_context_fill_info(context: *mut GstGLContext, error: *mut *mut glib::GError) -> gboolean; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_get_display(context: *mut GstGLContext) -> *mut GstGLDisplay; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_get_gl_api(context: *mut GstGLContext) -> GstGLAPI; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_get_gl_context(context: *mut GstGLContext) -> uintptr_t; + #[cfg(any(feature = "v1_4", feature = "dox"))] + 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); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_get_gl_version(context: *mut GstGLContext, maj: *mut c_int, min: *mut c_int); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_get_proc_address(context: *mut GstGLContext, name: *const c_char) -> gpointer; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_context_get_thread(context: *mut GstGLContext) -> *mut glib::GThread; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_get_window(context: *mut GstGLContext) -> *mut GstGLWindow; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_context_is_shared(context: *mut GstGLContext) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_context_set_shared_with(context: *mut GstGLContext, share: *mut GstGLContext); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_set_window(context: *mut GstGLContext, window: *mut GstGLWindow) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_context_supports_glsl_profile_version(context: *mut GstGLContext, version: GstGLSLVersion, profile: GstGLSLProfile) -> gboolean; + pub fn gst_gl_context_swap_buffers(context: *mut GstGLContext); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_context_thread_add(context: *mut GstGLContext, func: GstGLContextThreadFunc, data: gpointer); + + //========================================================================= + // GstGLDisplay + //========================================================================= + pub fn gst_gl_display_get_type() -> GType; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_display_new() -> *mut GstGLDisplay; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_display_add_context(display: *mut GstGLDisplay, context: *mut GstGLContext) -> gboolean; + #[cfg(any(feature = "v1_6", feature = "dox"))] + 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); + #[cfg(any(feature = "v1_12", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_display_get_gl_context_for_thread(display: *mut GstGLDisplay, thread: *mut glib::GThread) -> *mut GstGLContext; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_display_get_handle(display: *mut GstGLDisplay) -> uintptr_t; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_display_get_handle_type(display: *mut GstGLDisplay) -> GstGLDisplayType; + #[cfg(any(feature = "v1_12", feature = "dox"))] + pub fn gst_gl_display_remove_window(display: *mut GstGLDisplay, window: *mut GstGLWindow) -> gboolean; + + //========================================================================= + // GstGLFilter + //========================================================================= + pub fn gst_gl_filter_get_type() -> GType; + pub fn gst_gl_filter_add_rgba_pad_templates(klass: *mut GstGLFilterClass); + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_filter_draw_fullscreen_quad(filter: *mut GstGLFilter); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_filter_filter_texture(filter: *mut GstGLFilter, inbuf: *mut gst::GstBuffer, outbuf: *mut gst::GstBuffer) -> gboolean; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_filter_render_to_target(filter: *mut GstGLFilter, input: *mut GstGLMemory, output: *mut GstGLMemory, func: GstGLFilterRenderFunc, data: gpointer) -> gboolean; + #[cfg(any(feature = "v1_4", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_framebuffer_new(context: *mut GstGLContext) -> *mut GstGLFramebuffer; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_framebuffer_new_with_default_depth(context: *mut GstGLContext, width: c_uint, height: c_uint) -> *mut GstGLFramebuffer; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_framebuffer_attach(fb: *mut GstGLFramebuffer, attachment_point: c_uint, mem: *mut GstGLBaseMemory); + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_framebuffer_bind(fb: *mut GstGLFramebuffer); + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_framebuffer_draw_to_texture(fb: *mut GstGLFramebuffer, mem: *mut GstGLMemory, func: GstGLFramebufferFunc, user_data: gpointer) -> gboolean; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_framebuffer_get_effective_dimensions(fb: *mut GstGLFramebuffer, width: *mut c_uint, height: *mut c_uint); + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_gl_framebuffer_get_id(fb: *mut GstGLFramebuffer) -> c_uint; + + //========================================================================= + // GstGLMemoryAllocator + //========================================================================= + pub fn gst_gl_memory_allocator_get_type() -> GType; + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_stage_new_with_string(context: *mut GstGLContext, type_: c_uint, version: GstGLSLVersion, profile: GstGLSLProfile, str: *const c_char) -> *mut GstGLSLStage; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_stage_new_with_strings(context: *mut GstGLContext, type_: c_uint, version: GstGLSLVersion, profile: GstGLSLProfile, n_strings: c_int, str: *mut *mut c_char) -> *mut GstGLSLStage; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_stage_compile(stage: *mut GstGLSLStage, error: *mut *mut glib::GError) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_stage_get_handle(stage: *mut GstGLSLStage) -> c_uint; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_stage_get_profile(stage: *mut GstGLSLStage) -> GstGLSLProfile; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_stage_get_shader_type(stage: *mut GstGLSLStage) -> c_uint; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_stage_get_version(stage: *mut GstGLSLStage) -> GstGLSLVersion; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_stage_set_strings(stage: *mut GstGLSLStage, version: GstGLSLVersion, profile: GstGLSLProfile, n_strings: c_int, str: *mut *mut c_char) -> gboolean; + + //========================================================================= + // GstGLShader + //========================================================================= + pub fn gst_gl_shader_get_type() -> GType; + pub fn gst_gl_shader_new(context: *mut GstGLContext) -> *mut GstGLShader; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_new_default(context: *mut GstGLContext, error: *mut *mut glib::GError) -> *mut GstGLShader; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_new_link_with_stages(context: *mut GstGLContext, error: *mut *mut glib::GError, ...) -> *mut GstGLShader; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_new_with_stages(context: *mut GstGLContext, error: *mut *mut glib::GError, ...) -> *mut GstGLShader; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_attach(shader: *mut GstGLShader, stage: *mut GstGLSLStage) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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); + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_compile_attach_stage(shader: *mut GstGLShader, stage: *mut GstGLSLStage, error: *mut *mut glib::GError) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_detach(shader: *mut GstGLShader, stage: *mut GstGLSLStage); + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_get_program_handle(shader: *mut GstGLShader) -> c_int; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_is_linked(shader: *mut GstGLShader) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_link(shader: *mut GstGLShader, error: *mut *mut glib::GError) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_shader_release(shader: *mut GstGLShader); + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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: *mut 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: *mut 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: *mut 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: *mut 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: *mut 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: *mut 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: *mut 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: *mut 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; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_view_convert_new() -> *mut GstGLViewConvert; + #[cfg(any(feature = "v1_6", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_view_convert_get_output(viewconvert: *mut GstGLViewConvert, outbuf_ptr: *mut *mut gst::GstBuffer) -> gst::GstFlowReturn; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_view_convert_perform(viewconvert: *mut GstGLViewConvert, inbuf: *mut gst::GstBuffer) -> *mut gst::GstBuffer; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_view_convert_reset(viewconvert: *mut GstGLViewConvert); + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_view_convert_set_caps(viewconvert: *mut GstGLViewConvert, in_caps: *mut gst::GstCaps, out_caps: *mut gst::GstCaps) -> gboolean; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_view_convert_set_context(viewconvert: *mut GstGLViewConvert, context: *mut GstGLContext); + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_view_convert_submit_input_buffer(viewconvert: *mut GstGLViewConvert, is_discont: gboolean, input: *mut gst::GstBuffer) -> gst::GstFlowReturn; + #[cfg(any(feature = "v1_6", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_new(display: *mut GstGLDisplay) -> *mut GstGLWindow; + pub fn gst_gl_window_error_quark() -> glib::GQuark; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_draw(window: *mut GstGLWindow); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_get_context(window: *mut GstGLWindow) -> *mut GstGLContext; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_get_display(window: *mut GstGLWindow) -> uintptr_t; + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_window_get_surface_dimensions(window: *mut GstGLWindow, width: *mut c_uint, height: *mut c_uint); + #[cfg(any(feature = "v1_4", feature = "dox"))] + 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); + pub fn gst_gl_window_queue_resize(window: *mut GstGLWindow); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_quit(window: *mut GstGLWindow); + pub fn gst_gl_window_resize(window: *mut GstGLWindow, width: c_uint, height: c_uint); + #[cfg(any(feature = "v1_4", feature = "dox"))] + 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); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_send_message(window: *mut GstGLWindow, callback: GstGLWindowCB, data: gpointer); + #[cfg(any(feature = "v1_4", feature = "dox"))] + 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_4", feature = "dox"))] + pub fn gst_gl_window_set_close_callback(window: *mut GstGLWindow, callback: GstGLWindowCB, data: gpointer, destroy_notify: glib::GDestroyNotify); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_set_draw_callback(window: *mut GstGLWindow, callback: GstGLWindowCB, data: gpointer, destroy_notify: glib::GDestroyNotify); + #[cfg(any(feature = "v1_6", feature = "dox"))] + 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; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_set_resize_callback(window: *mut GstGLWindow, callback: GstGLWindowResizeCB, data: gpointer, destroy_notify: glib::GDestroyNotify); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_gl_window_set_window_handle(window: *mut GstGLWindow, handle: uintptr_t); + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_gl_window_show(window: *mut GstGLWindow); + + //========================================================================= + // Other functions + //========================================================================= + #[cfg(any(feature = "v1_6", feature = "dox"))] + pub fn gst_buffer_add_gl_sync_meta(context: *mut GstGLContext, buffer: *mut gst::GstBuffer) -> *mut GstGLSyncMeta; + #[cfg(any(feature = "v1_8", feature = "dox"))] + 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: *mut GstGLAllocationParams); + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_context_get_gl_display(context: *mut gst::GstContext, display: *mut *mut GstGLDisplay) -> gboolean; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_context_set_gl_display(context: *mut gst::GstContext, display: *mut GstGLDisplay); + 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; + 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_format_from_video_info(context: *mut GstGLContext, vinfo: *mut gst_video::GstVideoInfo, plane: c_uint) -> GstGLFormat; + pub fn gst_gl_format_type_n_bytes(format: c_uint, type_: c_uint) -> c_uint; + pub fn gst_gl_get_plane_data_size(info: *mut gst_video::GstVideoInfo, align: *mut gst_video::GstVideoAlignment, plane: c_uint) -> size_t; + pub fn gst_gl_get_plane_start(info: *mut gst_video::GstVideoInfo, valign: *mut 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; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_insert_debug_marker(context: *mut GstGLContext, format: *const c_char, ...); + 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; + 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_sync_meta_api_get_type() -> GType; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_texture_target_from_gl(target: c_uint) -> GstGLTextureTarget; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_texture_target_from_string(str: *const c_char) -> GstGLTextureTarget; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_texture_target_to_buffer_pool_option(target: GstGLTextureTarget) -> *const c_char; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_texture_target_to_gl(target: GstGLTextureTarget) -> c_uint; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_texture_target_to_string(target: GstGLTextureTarget) -> *const c_char; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_value_get_texture_target_mask(value: *const gobject::GValue) -> GstGLTextureTarget; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_value_set_texture_target(value: *mut gobject::GValue, target: GstGLTextureTarget) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_value_set_texture_target_from_mask(value: *mut gobject::GValue, target_mask: GstGLTextureTarget) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_gl_version_to_glsl_version(gl_api: GstGLAPI, maj: c_int, min: c_int) -> GstGLSLVersion; + pub fn gst_glsl_error_quark() -> glib::GQuark; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_profile_from_string(string: *const c_char) -> GstGLSLProfile; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_profile_to_string(profile: GstGLSLProfile) -> *const c_char; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_string_get_version_profile(s: *const c_char, version: *mut GstGLSLVersion, profile: *mut GstGLSLProfile) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_version_from_string(string: *const c_char) -> GstGLSLVersion; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_version_profile_from_string(string: *const c_char, version_ret: *mut GstGLSLVersion, profile_ret: *mut GstGLSLProfile) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_version_profile_to_string(version: GstGLSLVersion, profile: GstGLSLProfile) -> *mut c_char; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_glsl_version_to_string(version: GstGLSLVersion) -> *const c_char; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_is_gl_base_memory(mem: *mut gst::GstMemory) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_is_gl_buffer(mem: *mut gst::GstMemory) -> gboolean; + #[cfg(any(feature = "v1_4", feature = "dox"))] + pub fn gst_is_gl_memory(mem: *mut gst::GstMemory) -> gboolean; + #[cfg(any(feature = "v1_8", feature = "dox"))] + pub fn gst_is_gl_memory_pbo(mem: *mut gst::GstMemory) -> gboolean; + #[cfg(any(feature = "v1_10", feature = "dox"))] + pub fn gst_is_gl_renderbuffer(mem: *mut gst::GstMemory) -> gboolean; + +} diff --git a/gstreamer-gl-sys/tests/abi.rs b/gstreamer-gl-sys/tests/abi.rs new file mode 100644 index 000000000..c6206e0fd --- /dev/null +++ b/gstreamer-gl-sys/tests/abi.rs @@ -0,0 +1,427 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir @ f5fca82) +// from gir-files (https://github.com/gtk-rs/gir-files @ ???) +// DO NOT EDIT + +extern crate gst_gl_sys; +extern crate shell_words; +extern crate tempdir; +use std::env; +use std::error::Error; +use std::path::Path; +use std::mem::{align_of, size_of}; +use std::process::Command; +use std::str; +use gst_gl_sys::*; + +static PACKAGES: &[&str] = &["gstreamer-gl-1.0"]; + +#[derive(Clone, Debug)] +struct Compiler { + pub args: Vec, +} + +impl Compiler { + pub fn new() -> Result> { + let mut args = get_var("CC", "cc")?; + args.push("-Wno-deprecated-declarations".to_owned()); + // For %z support in printf when using MinGW. + args.push("-D__USE_MINGW_ANSI_STDIO".to_owned()); + args.extend(get_var("CFLAGS", "")?); + args.extend(get_var("CPPFLAGS", "")?); + args.extend(pkg_config_cflags(PACKAGES)?); + Ok(Compiler { args }) + } + + pub fn define<'a, V: Into>>(&mut self, var: &str, val: V) { + let arg = match val.into() { + None => format!("-D{}", var), + Some(val) => format!("-D{}={}", var, val), + }; + self.args.push(arg); + } + + pub fn compile(&self, src: &Path, out: &Path) -> Result<(), Box> { + let mut cmd = self.to_command(); + cmd.arg(src); + cmd.arg("-o"); + cmd.arg(out); + let status = cmd.spawn()?.wait()?; + if !status.success() { + return Err(format!("compilation command {:?} failed, {}", + &cmd, status).into()); + } + Ok(()) + } + + fn to_command(&self) -> Command { + let mut cmd = Command::new(&self.args[0]); + cmd.args(&self.args[1..]); + cmd + } +} + +fn get_var(name: &str, default: &str) -> Result, Box> { + match env::var(name) { + Ok(value) => Ok(shell_words::split(&value)?), + Err(env::VarError::NotPresent) => Ok(shell_words::split(default)?), + Err(err) => Err(format!("{} {}", name, err).into()), + } +} + +fn pkg_config_cflags(packages: &[&str]) -> Result, Box> { + if packages.is_empty() { + return Ok(Vec::new()); + } + let mut cmd = Command::new("pkg-config"); + cmd.arg("--cflags"); + cmd.args(packages); + let out = cmd.output()?; + if !out.status.success() { + return Err(format!("command {:?} returned {}", + &cmd, out.status).into()); + } + let stdout = str::from_utf8(&out.stdout)?; + Ok(shell_words::split(stdout.trim())?) +} + + +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +struct Layout { + size: usize, + alignment: usize, +} + +#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] +struct Results { + /// Number of successfully completed tests. + passed: usize, + /// Total number of failed tests (including those that failed to compile). + failed: usize, + /// Number of tests that failed to compile. + failed_to_compile: usize, +} + +impl Results { + fn record_passed(&mut self) { + self.passed += 1; + } + fn record_failed(&mut self) { + self.failed += 1; + } + fn record_failed_to_compile(&mut self) { + self.failed += 1; + self.failed_to_compile += 1; + } + fn summary(&self) -> String { + format!( + "{} passed; {} failed (compilation errors: {})", + self.passed, + self.failed, + self.failed_to_compile) + } + fn expect_total_success(&self) { + if self.failed == 0 { + println!("OK: {}", self.summary()); + } else { + panic!("FAILED: {}", self.summary()); + }; + } +} + +#[test] +fn cross_validate_constants_with_c() { + let tmpdir = tempdir::TempDir::new("abi").expect("temporary directory"); + let cc = Compiler::new().expect("configured compiler"); + + assert_eq!("1", + get_c_value(tmpdir.path(), &cc, "1").expect("C constant"), + "failed to obtain correct constant value for 1"); + + let mut results : Results = Default::default(); + for (i, &(name, rust_value)) in RUST_CONSTANTS.iter().enumerate() { + match get_c_value(tmpdir.path(), &cc, name) { + Err(e) => { + results.record_failed_to_compile(); + eprintln!("{}", e); + }, + Ok(ref c_value) => { + if rust_value == c_value { + results.record_passed(); + } else { + results.record_failed(); + eprintln!("Constant value mismatch for {}\nRust: {:?}\nC: {:?}", + name, rust_value, c_value); + } + } + }; + if (i + 1) % 25 == 0 { + println!("constants ... {}", results.summary()); + } + } + results.expect_total_success(); +} + +#[test] +fn cross_validate_layout_with_c() { + let tmpdir = tempdir::TempDir::new("abi").expect("temporary directory"); + let cc = Compiler::new().expect("configured compiler"); + + assert_eq!(Layout {size: 1, alignment: 1}, + get_c_layout(tmpdir.path(), &cc, "char").expect("C layout"), + "failed to obtain correct layout for char type"); + + let mut results : Results = Default::default(); + for (i, &(name, rust_layout)) in RUST_LAYOUTS.iter().enumerate() { + match get_c_layout(tmpdir.path(), &cc, name) { + Err(e) => { + results.record_failed_to_compile(); + eprintln!("{}", e); + }, + Ok(c_layout) => { + if rust_layout == c_layout { + results.record_passed(); + } else { + results.record_failed(); + eprintln!("Layout mismatch for {}\nRust: {:?}\nC: {:?}", + name, rust_layout, &c_layout); + } + } + }; + if (i + 1) % 25 == 0 { + println!("layout ... {}", results.summary()); + } + } + results.expect_total_success(); +} + +fn get_c_layout(dir: &Path, cc: &Compiler, name: &str) -> Result> { + let exe = dir.join("layout"); + let mut cc = cc.clone(); + cc.define("ABI_TYPE_NAME", name); + cc.compile(Path::new("tests/layout.c"), &exe)?; + + let mut abi_cmd = Command::new(exe); + let output = abi_cmd.output()?; + if !output.status.success() { + return Err(format!("command {:?} failed, {:?}", + &abi_cmd, &output).into()); + } + + let stdout = str::from_utf8(&output.stdout)?; + let mut words = stdout.trim().split_whitespace(); + let size = words.next().unwrap().parse().unwrap(); + let alignment = words.next().unwrap().parse().unwrap(); + Ok(Layout {size, alignment}) +} + +fn get_c_value(dir: &Path, cc: &Compiler, name: &str) -> Result> { + let exe = dir.join("constant"); + let mut cc = cc.clone(); + cc.define("ABI_CONSTANT_NAME", name); + cc.compile(Path::new("tests/constant.c"), &exe)?; + + let mut abi_cmd = Command::new(exe); + let output = abi_cmd.output()?; + if !output.status.success() { + return Err(format!("command {:?} failed, {:?}", + &abi_cmd, &output).into()); + } + + Ok(str::from_utf8(&output.stdout)?.trim().to_owned()) +} + +const RUST_LAYOUTS: &[(&str, Layout)] = &[ + ("GstGLAPI", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLAllocationParams", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLAsyncDebug", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBaseFilter", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBaseFilterClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBaseMemory", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBaseMemoryAllocator", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBaseMemoryAllocatorClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBaseMemoryError", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBaseMemoryTransfer", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBuffer", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBufferAllocationParams", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBufferAllocator", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBufferAllocatorClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBufferPool", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLBufferPoolClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLColorConvert", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLColorConvertClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLContext", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLContextClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLContextError", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLDisplay", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLDisplayClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLDisplayType", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLFilter", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLFilterClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLFormat", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLFramebuffer", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLFramebufferClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLMemory", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLMemoryAllocator", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLMemoryAllocatorClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLMemoryPBO", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLMemoryPBOAllocator", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLMemoryPBOAllocatorClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLOverlayCompositor", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLOverlayCompositorClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLPlatform", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLQuery", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLQueryType", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLRenderbuffer", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLRenderbufferAllocationParams", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLRenderbufferAllocator", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLRenderbufferAllocatorClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLSLError", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLSLProfile", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLSLStage", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLSLStageClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLSLVersion", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLShader", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLShaderClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLStereoDownmix", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLSyncMeta", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLTextureTarget", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLUpload", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLUploadClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLUploadReturn", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLVideoAllocationParams", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLViewConvert", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLViewConvertClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLWindow", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLWindowClass", Layout {size: size_of::(), alignment: align_of::()}), + ("GstGLWindowError", Layout {size: size_of::(), alignment: align_of::()}), +]; + +const RUST_CONSTANTS: &[(&str, &str)] = &[ + ("GST_BUFFER_POOL_OPTION_GL_SYNC_META", "GstBufferPoolOptionGLSyncMeta"), + ("GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_2D", "GstBufferPoolOptionGLTextureTarget2D"), + ("GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_EXTERNAL_OES", "GstBufferPoolOptionGLTextureTargetExternalOES"), + ("GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_RECTANGLE", "GstBufferPoolOptionGLTextureTargetRectangle"), + ("GST_CAPS_FEATURE_MEMORY_GL_BUFFER", "memory:GLBuffer"), + ("GST_CAPS_FEATURE_MEMORY_GL_MEMORY", "memory:GLMemory"), + ("GST_GLSL_ERROR_COMPILE", "0"), + ("GST_GLSL_ERROR_LINK", "1"), + ("GST_GLSL_ERROR_PROGRAM", "2"), + ("GST_GLSL_PROFILE_ANY", "-1"), + ("GST_GLSL_PROFILE_COMPATIBILITY", "4"), + ("GST_GLSL_PROFILE_CORE", "2"), + ("GST_GLSL_PROFILE_ES", "1"), + ("GST_GLSL_PROFILE_NONE", "0"), + ("GST_GLSL_VERSION_100", "100"), + ("GST_GLSL_VERSION_110", "110"), + ("GST_GLSL_VERSION_120", "120"), + ("GST_GLSL_VERSION_130", "130"), + ("GST_GLSL_VERSION_140", "140"), + ("GST_GLSL_VERSION_150", "150"), + ("GST_GLSL_VERSION_300", "300"), + ("GST_GLSL_VERSION_310", "310"), + ("GST_GLSL_VERSION_320", "320"), + ("GST_GLSL_VERSION_330", "330"), + ("GST_GLSL_VERSION_400", "400"), + ("GST_GLSL_VERSION_410", "410"), + ("GST_GLSL_VERSION_420", "420"), + ("GST_GLSL_VERSION_430", "430"), + ("GST_GLSL_VERSION_440", "440"), + ("GST_GLSL_VERSION_450", "450"), + ("GST_GLSL_VERSION_NONE", "0"), + ("GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_ALLOC", "1"), + ("GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_BUFFER", "16"), + ("GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_USER", "65536"), + ("GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_VIDEO", "8"), + ("GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_WRAP_GPU_HANDLE", "4"), + ("GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_WRAP_SYSMEM", "2"), + ("GST_GL_ALPHA", "6406"), + ("GST_GL_API_ANY", "4294967295"), + ("GST_GL_API_GLES1", "32768"), + ("GST_GL_API_GLES1_NAME", "gles1"), + ("GST_GL_API_GLES2", "65536"), + ("GST_GL_API_GLES2_NAME", "gles2"), + ("GST_GL_API_NONE", "0"), + ("GST_GL_API_OPENGL", "1"), + ("GST_GL_API_OPENGL3", "2"), + ("GST_GL_API_OPENGL3_NAME", "opengl3"), + ("GST_GL_API_OPENGL_NAME", "opengl"), + ("GST_GL_BASE_MEMORY_ALLOCATOR_NAME", "GLBaseMemory"), + ("GST_GL_BASE_MEMORY_ERROR_FAILED", "0"), + ("GST_GL_BASE_MEMORY_ERROR_OLD_LIBS", "1"), + ("GST_GL_BASE_MEMORY_ERROR_RESOURCE_UNAVAILABLE", "2"), + ("GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD", "1048576"), + ("GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD", "2097152"), + ("GST_GL_BUFFER_ALLOCATOR_NAME", "GLBuffer"), + ("GST_GL_COLOR_CONVERT_FORMATS", "{ RGBA, RGB, RGBx, BGR, BGRx, BGRA, xRGB, xBGR, ARGB, ABGR, Y444, I420, YV12, Y42B, Y41B, NV12, NV21, YUY2, UYVY, AYUV, GRAY8, GRAY16_LE, GRAY16_BE, RGB16, BGR16 }"), + ("GST_GL_COLOR_CONVERT_VIDEO_CAPS", "video/x-raw("), + ("GST_GL_CONTEXT_ERROR_CREATE_CONTEXT", "4"), + ("GST_GL_CONTEXT_ERROR_FAILED", "0"), + ("GST_GL_CONTEXT_ERROR_OLD_LIBS", "3"), + ("GST_GL_CONTEXT_ERROR_RESOURCE_UNAVAILABLE", "5"), + ("GST_GL_CONTEXT_ERROR_WRONG_API", "2"), + ("GST_GL_CONTEXT_ERROR_WRONG_CONFIG", "1"), + ("GST_GL_CONTEXT_TYPE_CGL", "gst.gl.context.CGL"), + ("GST_GL_CONTEXT_TYPE_EAGL", "gst.gl.context.EAGL"), + ("GST_GL_CONTEXT_TYPE_EGL", "gst.gl.context.EGL"), + ("GST_GL_CONTEXT_TYPE_GLX", "gst.gl.context.GLX"), + ("GST_GL_CONTEXT_TYPE_WGL", "gst.gl.context.WGL"), + ("GST_GL_DEPTH24_STENCIL8", "35056"), + ("GST_GL_DEPTH_COMPONENT16", "33189"), + ("GST_GL_DISPLAY_CONTEXT_TYPE", "gst.gl.GLDisplay"), + ("GST_GL_DISPLAY_EGL_NAME", "gst.gl.display.egl"), + ("GST_GL_DISPLAY_TYPE_ANY", "4294967295"), + ("GST_GL_DISPLAY_TYPE_COCOA", "4"), + ("GST_GL_DISPLAY_TYPE_DISPMANX", "16"), + ("GST_GL_DISPLAY_TYPE_EGL", "32"), + ("GST_GL_DISPLAY_TYPE_GBM", "128"), + ("GST_GL_DISPLAY_TYPE_NONE", "0"), + ("GST_GL_DISPLAY_TYPE_VIV_FB", "64"), + ("GST_GL_DISPLAY_TYPE_WAYLAND", "2"), + ("GST_GL_DISPLAY_TYPE_WIN32", "8"), + ("GST_GL_DISPLAY_TYPE_X11", "1"), + ("GST_GL_LUMINANCE", "6409"), + ("GST_GL_LUMINANCE_ALPHA", "6410"), + ("GST_GL_MEMORY_ALLOCATOR_NAME", "GLMemory"), + ("GST_GL_MEMORY_PBO_ALLOCATOR_NAME", "GLMemoryPBO"), + ("GST_GL_MEMORY_VIDEO_FORMATS_STR", "{ RGBA, BGRA, RGBx, BGRx, ARGB, ABGR, xRGB, xBGR, RGB, BGR, RGB16, BGR16, AYUV, I420, YV12, NV12, NV21, YUY2, UYVY, Y41B, Y42B, Y444, GRAY8, GRAY16_LE, GRAY16_BE }"), + ("GST_GL_PLATFORM_ANY", "4294967295"), + ("GST_GL_PLATFORM_CGL", "8"), + ("GST_GL_PLATFORM_EAGL", "16"), + ("GST_GL_PLATFORM_EGL", "1"), + ("GST_GL_PLATFORM_GLX", "2"), + ("GST_GL_PLATFORM_NONE", "0"), + ("GST_GL_PLATFORM_WGL", "4"), + ("GST_GL_QUERY_NONE", "0"), + ("GST_GL_QUERY_TIMESTAMP", "2"), + ("GST_GL_QUERY_TIME_ELAPSED", "1"), + ("GST_GL_R8", "33321"), + ("GST_GL_RED", "6403"), + ("GST_GL_RENDERBUFFER_ALLOCATOR_NAME", "GLRenderbuffer"), + ("GST_GL_RG", "33319"), + ("GST_GL_RG8", "33323"), + ("GST_GL_RGB", "6407"), + ("GST_GL_RGB565", "36194"), + ("GST_GL_RGB8", "32849"), + ("GST_GL_RGBA", "6408"), + ("GST_GL_RGBA8", "32856"), + ("GST_GL_STEREO_DOWNMIX_ANAGLYPH_AMBER_BLUE_DUBOIS", "2"), + ("GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS", "0"), + ("GST_GL_STEREO_DOWNMIX_ANAGLYPH_RED_CYAN_DUBOIS", "1"), + ("GST_GL_TEXTURE_TARGET_2D", "1"), + ("GST_GL_TEXTURE_TARGET_2D_STR", "2D"), + ("GST_GL_TEXTURE_TARGET_EXTERNAL_OES", "3"), + ("GST_GL_TEXTURE_TARGET_EXTERNAL_OES_STR", "external-oes"), + ("GST_GL_TEXTURE_TARGET_NONE", "0"), + ("GST_GL_TEXTURE_TARGET_RECTANGLE", "2"), + ("GST_GL_TEXTURE_TARGET_RECTANGLE_STR", "rectangle"), + ("GST_GL_UPLOAD_DONE", "1"), + ("GST_GL_UPLOAD_ERROR", "-1"), + ("GST_GL_UPLOAD_RECONFIGURE", "-3"), + ("GST_GL_UPLOAD_UNSUPPORTED", "-2"), + ("GST_GL_WINDOW_ERROR_FAILED", "0"), + ("GST_GL_WINDOW_ERROR_OLD_LIBS", "1"), + ("GST_GL_WINDOW_ERROR_RESOURCE_UNAVAILABLE", "2"), + ("GST_MAP_GL", "131072"), +]; + + diff --git a/gstreamer-gl-sys/tests/constant.c b/gstreamer-gl-sys/tests/constant.c new file mode 100644 index 000000000..ca2c6e574 --- /dev/null +++ b/gstreamer-gl-sys/tests/constant.c @@ -0,0 +1,27 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir @ f5fca82) +// from gir-files (https://github.com/gtk-rs/gir-files @ ???) +// DO NOT EDIT + +#include "manual.h" +#include + +int main() { + printf(_Generic((ABI_CONSTANT_NAME), + char *: "%s", + const char *: "%s", + char: "%c", + signed char: "%hhd", + unsigned char: "%hhu", + short int: "%hd", + unsigned short int: "%hu", + int: "%d", + unsigned int: "%u", + long: "%ld", + unsigned long: "%lu", + long long: "%lld", + unsigned long long: "%llu", + double: "%f", + long double: "%ld"), + ABI_CONSTANT_NAME); + return 0; +} diff --git a/gstreamer-gl-sys/tests/layout.c b/gstreamer-gl-sys/tests/layout.c new file mode 100644 index 000000000..0d766ac33 --- /dev/null +++ b/gstreamer-gl-sys/tests/layout.c @@ -0,0 +1,12 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir @ f5fca82) +// from gir-files (https://github.com/gtk-rs/gir-files @ ???) +// DO NOT EDIT + +#include "manual.h" +#include +#include + +int main() { + printf("%zu\n%zu", sizeof(ABI_TYPE_NAME), alignof(ABI_TYPE_NAME)); + return 0; +} diff --git a/gstreamer-gl-sys/tests/manual.h b/gstreamer-gl-sys/tests/manual.h new file mode 100644 index 000000000..466e7b581 --- /dev/null +++ b/gstreamer-gl-sys/tests/manual.h @@ -0,0 +1,3 @@ +// Feel free to edit this file, it won't be regenerated by gir generator unless removed. + +#include