// This file was generated by gir (https://github.com/gtk-rs/gir @ d1e88f9)
// from gir-files (https://github.com/gtk-rs/gir-files @ 63dd366)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal
)]

extern crate glib_sys as glib;
extern crate gobject_sys as gobject;
extern crate gstreamer_base_sys as gst_base;
extern crate gstreamer_sys as gst;
extern crate gstreamer_video_sys as gst_video;
extern crate libc;

mod manual;

pub use manual::*;

#[allow(unused_imports)]
use libc::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
    intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type GstGLBaseMemoryError = c_int;
pub const GST_GL_BASE_MEMORY_ERROR_FAILED: GstGLBaseMemoryError = 0;
pub const GST_GL_BASE_MEMORY_ERROR_OLD_LIBS: GstGLBaseMemoryError = 1;
pub const GST_GL_BASE_MEMORY_ERROR_RESOURCE_UNAVAILABLE: GstGLBaseMemoryError = 2;

pub type GstGLContextError = c_int;
pub const GST_GL_CONTEXT_ERROR_FAILED: GstGLContextError = 0;
pub const GST_GL_CONTEXT_ERROR_WRONG_CONFIG: GstGLContextError = 1;
pub const GST_GL_CONTEXT_ERROR_WRONG_API: GstGLContextError = 2;
pub const GST_GL_CONTEXT_ERROR_OLD_LIBS: GstGLContextError = 3;
pub const GST_GL_CONTEXT_ERROR_CREATE_CONTEXT: GstGLContextError = 4;
pub const GST_GL_CONTEXT_ERROR_RESOURCE_UNAVAILABLE: GstGLContextError = 5;

pub type GstGLFormat = c_int;
pub const GST_GL_LUMINANCE: GstGLFormat = 6409;
pub const GST_GL_ALPHA: GstGLFormat = 6406;
pub const GST_GL_LUMINANCE_ALPHA: GstGLFormat = 6410;
pub const GST_GL_RED: GstGLFormat = 6403;
pub const GST_GL_R8: GstGLFormat = 33321;
pub const GST_GL_RG: GstGLFormat = 33319;
pub const GST_GL_RG8: GstGLFormat = 33323;
pub const GST_GL_RGB: GstGLFormat = 6407;
pub const GST_GL_RGB8: GstGLFormat = 32849;
pub const GST_GL_RGB565: GstGLFormat = 36194;
pub const GST_GL_RGB16: GstGLFormat = 32852;
pub const GST_GL_RGBA: GstGLFormat = 6408;
pub const GST_GL_RGBA8: GstGLFormat = 32856;
pub const GST_GL_RGBA16: GstGLFormat = 32859;
pub const GST_GL_DEPTH_COMPONENT16: GstGLFormat = 33189;
pub const GST_GL_DEPTH24_STENCIL8: GstGLFormat = 35056;

pub type GstGLQueryType = c_int;
pub const GST_GL_QUERY_NONE: GstGLQueryType = 0;
pub const GST_GL_QUERY_TIME_ELAPSED: GstGLQueryType = 1;
pub const GST_GL_QUERY_TIMESTAMP: GstGLQueryType = 2;

pub type GstGLSLError = c_int;
pub const GST_GLSL_ERROR_COMPILE: GstGLSLError = 0;
pub const GST_GLSL_ERROR_LINK: GstGLSLError = 1;
pub const GST_GLSL_ERROR_PROGRAM: GstGLSLError = 2;

pub type GstGLSLVersion = c_int;
pub const GST_GLSL_VERSION_NONE: GstGLSLVersion = 0;
pub const GST_GLSL_VERSION_100: GstGLSLVersion = 100;
pub const GST_GLSL_VERSION_110: GstGLSLVersion = 110;
pub const GST_GLSL_VERSION_120: GstGLSLVersion = 120;
pub const GST_GLSL_VERSION_130: GstGLSLVersion = 130;
pub const GST_GLSL_VERSION_140: GstGLSLVersion = 140;
pub const GST_GLSL_VERSION_150: GstGLSLVersion = 150;
pub const GST_GLSL_VERSION_300: GstGLSLVersion = 300;
pub const GST_GLSL_VERSION_310: GstGLSLVersion = 310;
pub const GST_GLSL_VERSION_320: GstGLSLVersion = 320;
pub const GST_GLSL_VERSION_330: GstGLSLVersion = 330;
pub const GST_GLSL_VERSION_400: GstGLSLVersion = 400;
pub const GST_GLSL_VERSION_410: GstGLSLVersion = 410;
pub const GST_GLSL_VERSION_420: GstGLSLVersion = 420;
pub const GST_GLSL_VERSION_430: GstGLSLVersion = 430;
pub const GST_GLSL_VERSION_440: GstGLSLVersion = 440;
pub const GST_GLSL_VERSION_450: GstGLSLVersion = 450;

pub type GstGLStereoDownmix = c_int;
pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS: GstGLStereoDownmix = 0;
pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_RED_CYAN_DUBOIS: GstGLStereoDownmix = 1;
pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_AMBER_BLUE_DUBOIS: GstGLStereoDownmix = 2;

pub type GstGLTextureTarget = c_int;
pub const GST_GL_TEXTURE_TARGET_NONE: GstGLTextureTarget = 0;
pub const GST_GL_TEXTURE_TARGET_2D: GstGLTextureTarget = 1;
pub const GST_GL_TEXTURE_TARGET_RECTANGLE: GstGLTextureTarget = 2;
pub const GST_GL_TEXTURE_TARGET_EXTERNAL_OES: GstGLTextureTarget = 3;

pub type GstGLUploadReturn = c_int;
pub const GST_GL_UPLOAD_DONE: GstGLUploadReturn = 1;
pub const GST_GL_UPLOAD_ERROR: GstGLUploadReturn = -1;
pub const GST_GL_UPLOAD_UNSUPPORTED: GstGLUploadReturn = -2;
pub const GST_GL_UPLOAD_RECONFIGURE: GstGLUploadReturn = -3;
pub const GST_GL_UPLOAD_UNSHARED_GL_CONTEXT: GstGLUploadReturn = -100;

pub type GstGLWindowError = c_int;
pub const GST_GL_WINDOW_ERROR_FAILED: GstGLWindowError = 0;
pub const GST_GL_WINDOW_ERROR_OLD_LIBS: GstGLWindowError = 1;
pub const GST_GL_WINDOW_ERROR_RESOURCE_UNAVAILABLE: GstGLWindowError = 2;

// Constants
pub const GST_BUFFER_POOL_OPTION_GL_SYNC_META: *const c_char =
    b"GstBufferPoolOptionGLSyncMeta\0" as *const u8 as *const c_char;
pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_2D: *const c_char =
    b"GstBufferPoolOptionGLTextureTarget2D\0" as *const u8 as *const c_char;
pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_EXTERNAL_OES: *const c_char =
    b"GstBufferPoolOptionGLTextureTargetExternalOES\0" as *const u8 as *const c_char;
pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_RECTANGLE: *const c_char =
    b"GstBufferPoolOptionGLTextureTargetRectangle\0" as *const u8 as *const c_char;
pub const GST_CAPS_FEATURE_MEMORY_GL_BUFFER: *const c_char =
    b"memory:GLBuffer\0" as *const u8 as *const c_char;
pub const GST_CAPS_FEATURE_MEMORY_GL_MEMORY: *const c_char =
    b"memory:GLMemory\0" as *const u8 as *const c_char;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_ALLOC: c_int = 1;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_BUFFER: c_int = 16;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_USER: c_int = 65536;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_VIDEO: c_int = 8;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_WRAP_GPU_HANDLE: c_int = 4;
pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_WRAP_SYSMEM: c_int = 2;
pub const GST_GL_API_GLES1_NAME: *const c_char = b"gles1\0" as *const u8 as *const c_char;
pub const GST_GL_API_GLES2_NAME: *const c_char = b"gles2\0" as *const u8 as *const c_char;
pub const GST_GL_API_OPENGL3_NAME: *const c_char = b"opengl3\0" as *const u8 as *const c_char;
pub const GST_GL_API_OPENGL_NAME: *const c_char = b"opengl\0" as *const u8 as *const c_char;
pub const GST_GL_BASE_MEMORY_ALLOCATOR_NAME: *const c_char =
    b"GLBaseMemory\0" as *const u8 as *const c_char;
pub const GST_GL_BUFFER_ALLOCATOR_NAME: *const c_char = b"GLBuffer\0" as *const u8 as *const c_char;
pub const GST_GL_COLOR_CONVERT_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, VUYA, GRAY8, GRAY16_LE, GRAY16_BE, RGB16, BGR16, ARGB64 }\0" as *const u8 as *const c_char;
pub const GST_GL_CONTEXT_TYPE_CGL: *const c_char =
    b"gst.gl.context.CGL\0" as *const u8 as *const c_char;
pub const GST_GL_CONTEXT_TYPE_EAGL: *const c_char =
    b"gst.gl.context.EAGL\0" as *const u8 as *const c_char;
pub const GST_GL_CONTEXT_TYPE_EGL: *const c_char =
    b"gst.gl.context.EGL\0" as *const u8 as *const c_char;
pub const GST_GL_CONTEXT_TYPE_GLX: *const c_char =
    b"gst.gl.context.GLX\0" as *const u8 as *const c_char;
pub const GST_GL_CONTEXT_TYPE_WGL: *const c_char =
    b"gst.gl.context.WGL\0" as *const u8 as *const c_char;
pub const GST_GL_DISPLAY_CONTEXT_TYPE: *const c_char =
    b"gst.gl.GLDisplay\0" as *const u8 as *const c_char;
pub const GST_GL_MEMORY_ALLOCATOR_NAME: *const c_char = b"GLMemory\0" as *const u8 as *const c_char;
pub const GST_GL_MEMORY_PBO_ALLOCATOR_NAME: *const c_char =
    b"GLMemoryPBO\0" as *const u8 as *const c_char;
pub const GST_GL_MEMORY_VIDEO_FORMATS_STR: *const c_char = b"{ RGBA, BGRA, RGBx, BGRx, ARGB, ABGR, xRGB, xBGR, RGB, BGR, RGB16, BGR16, AYUV, VUYA, I420, YV12, NV12, NV21, YUY2, UYVY, Y41B, Y42B, Y444, GRAY8, GRAY16_LE, GRAY16_BE, ARGB64 }\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<unsafe extern "C" fn(*mut GstGLAllocationParams, *mut GstGLAllocationParams)>;
pub type GstGLAllocationParamsFreeFunc = Option<unsafe extern "C" fn(gpointer)>;
pub type GstGLAsyncDebugLogGetMessage = Option<unsafe extern "C" fn(gpointer) -> *mut c_char>;
pub type GstGLBaseMemoryAllocatorAllocFunction = Option<
    unsafe extern "C" fn(
        *mut GstGLBaseMemoryAllocator,
        *mut GstGLAllocationParams,
    ) -> *mut GstGLBaseMemory,
>;
pub type GstGLBaseMemoryAllocatorCopyFunction =
    Option<unsafe extern "C" fn(*mut GstGLBaseMemory, ssize_t, ssize_t) -> *mut GstGLBaseMemory>;
pub type GstGLBaseMemoryAllocatorCreateFunction =
    Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut *mut glib::GError) -> gboolean>;
pub type GstGLBaseMemoryAllocatorDestroyFunction =
    Option<unsafe extern "C" fn(*mut GstGLBaseMemory)>;
pub type GstGLBaseMemoryAllocatorMapFunction =
    Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut gst::GstMapInfo, size_t) -> gpointer>;
pub type GstGLBaseMemoryAllocatorUnmapFunction =
    Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut gst::GstMapInfo)>;
pub type GstGLContextThreadFunc = Option<unsafe extern "C" fn(*mut GstGLContext, gpointer)>;
pub type GstGLFilterRenderFunc =
    Option<unsafe extern "C" fn(*mut GstGLFilter, *mut GstGLMemory, gpointer) -> gboolean>;
pub type GstGLFramebufferFunc = Option<unsafe extern "C" fn(gpointer) -> gboolean>;
pub type GstGLWindowCB = Option<unsafe extern "C" fn(gpointer)>;
pub type GstGLWindowResizeCB = Option<unsafe extern "C" fn(gpointer, c_uint, c_uint)>;

// Records
#[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<unsafe extern "C" fn(*mut GstGLBaseFilter) -> gboolean>,
    pub gl_stop: Option<unsafe extern "C" fn(*mut GstGLBaseFilter)>,
    pub gl_set_caps: Option<
        unsafe extern "C" fn(
            *mut GstGLBaseFilter,
            *mut gst::GstCaps,
            *mut gst::GstCaps,
        ) -> gboolean,
    >,
    pub _padding: [gpointer; 4],
}

impl ::std::fmt::Debug for GstGLBaseFilterClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLBaseFilterClass @ {:?}", self 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);

pub type GstGLBaseFilterPrivate = *mut _GstGLBaseFilterPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLBaseMemory {
    pub mem: gst::GstMemory,
    pub context: *mut GstGLContext,
    pub lock: glib::GMutex,
    pub map_flags: gst::GstMapFlags,
    pub map_count: c_int,
    pub gl_map_count: c_int,
    pub data: gpointer,
    pub query: *mut GstGLQuery,
    pub alloc_size: size_t,
    pub alloc_data: gpointer,
    pub notify: glib::GDestroyNotify,
    pub user_data: gpointer,
    pub _padding: [gpointer; 4],
}

impl ::std::fmt::Debug for GstGLBaseMemory {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLBaseMemory @ {:?}", 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);

pub type GstGLBufferPoolPrivate = *mut _GstGLBufferPoolPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLColorConvertClass {
    pub object_class: gst::GstObjectClass,
    pub _padding: [gpointer; 4],
}

impl ::std::fmt::Debug for GstGLColorConvertClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLColorConvertClass @ {:?}", self as *const _))
            .finish()
    }
}

#[repr(C)]
pub struct _GstGLColorConvertPrivate(c_void);

pub type GstGLColorConvertPrivate = *mut _GstGLColorConvertPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLContextClass {
    pub parent_class: gst::GstObjectClass,
    pub get_current_context: Option<unsafe extern "C" fn() -> uintptr_t>,
    pub get_gl_context: Option<unsafe extern "C" fn(*mut GstGLContext) -> uintptr_t>,
    pub get_gl_api: Option<unsafe extern "C" fn(*mut GstGLContext) -> GstGLAPI>,
    pub get_gl_platform: Option<unsafe extern "C" fn(*mut GstGLContext) -> GstGLPlatform>,
    pub get_proc_address: Option<unsafe extern "C" fn(GstGLAPI, *const c_char) -> gpointer>,
    pub activate: Option<unsafe extern "C" fn(*mut GstGLContext, gboolean) -> gboolean>,
    pub choose_format:
        Option<unsafe extern "C" fn(*mut GstGLContext, *mut *mut glib::GError) -> gboolean>,
    pub create_context: Option<
        unsafe extern "C" fn(
            *mut GstGLContext,
            GstGLAPI,
            *mut GstGLContext,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub destroy_context: Option<unsafe extern "C" fn(*mut GstGLContext)>,
    pub swap_buffers: Option<unsafe extern "C" fn(*mut GstGLContext)>,
    pub check_feature: Option<unsafe extern "C" fn(*mut GstGLContext, *const c_char) -> gboolean>,
    pub get_gl_platform_version:
        Option<unsafe extern "C" fn(*mut GstGLContext, *mut c_int, *mut c_int)>,
    pub _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);

pub type GstGLContextPrivate = *mut _GstGLContextPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLDisplayClass {
    pub object_class: gst::GstObjectClass,
    pub get_handle: Option<unsafe extern "C" fn(*mut GstGLDisplay) -> uintptr_t>,
    pub create_window: Option<unsafe extern "C" fn(*mut GstGLDisplay) -> *mut GstGLWindow>,
    pub _padding: [gpointer; 4],
}

impl ::std::fmt::Debug for GstGLDisplayClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLDisplayClass @ {:?}", self as *const _))
            .field("object_class", &self.object_class)
            .field("get_handle", &self.get_handle)
            .field("create_window", &self.create_window)
            .finish()
    }
}

#[cfg(any(feature = "egl", feature = "dox"))]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLDisplayEGLClass {
    pub object_class: GstGLDisplayClass,
    pub _padding: [gpointer; 4],
}

#[cfg(any(feature = "egl", feature = "dox"))]
impl ::std::fmt::Debug for GstGLDisplayEGLClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLDisplayEGLClass @ {:?}", self as *const _))
            .field("object_class", &self.object_class)
            .field("_padding", &self._padding)
            .finish()
    }
}

#[repr(C)]
pub struct _GstGLDisplayPrivate(c_void);

pub type GstGLDisplayPrivate = *mut _GstGLDisplayPrivate;

#[cfg(any(feature = "wayland", feature = "dox"))]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLDisplayWaylandClass {
    pub object_class: GstGLDisplayClass,
    pub _padding: [gpointer; 4],
}

#[cfg(any(feature = "wayland", feature = "dox"))]
impl ::std::fmt::Debug for GstGLDisplayWaylandClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GstGLDisplayWaylandClass @ {:?}",
            self as *const _
        ))
        .field("object_class", &self.object_class)
        .field("_padding", &self._padding)
        .finish()
    }
}

#[cfg(any(feature = "x11", feature = "dox"))]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLDisplayX11Class {
    pub object_class: GstGLDisplayClass,
    pub _padding: [gpointer; 4],
}

#[cfg(any(feature = "x11", feature = "dox"))]
impl ::std::fmt::Debug for GstGLDisplayX11Class {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLDisplayX11Class @ {:?}", self as *const _))
            .field("object_class", &self.object_class)
            .field("_padding", &self._padding)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLFilterClass {
    pub parent_class: GstGLBaseFilterClass,
    pub set_caps: Option<
        unsafe extern "C" fn(*mut GstGLFilter, *mut gst::GstCaps, *mut gst::GstCaps) -> gboolean,
    >,
    pub filter: Option<
        unsafe extern "C" fn(
            *mut GstGLFilter,
            *mut gst::GstBuffer,
            *mut gst::GstBuffer,
        ) -> gboolean,
    >,
    pub filter_texture: Option<
        unsafe extern "C" fn(*mut GstGLFilter, *mut GstGLMemory, *mut GstGLMemory) -> gboolean,
    >,
    pub init_fbo: Option<unsafe extern "C" fn(*mut GstGLFilter) -> gboolean>,
    pub transform_internal_caps: Option<
        unsafe extern "C" fn(
            *mut GstGLFilter,
            gst::GstPadDirection,
            *mut gst::GstCaps,
            *mut gst::GstCaps,
        ) -> *mut gst::GstCaps,
    >,
    pub _padding: [gpointer; 4],
}

impl ::std::fmt::Debug for GstGLFilterClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLFilterClass @ {:?}", self 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);

pub type GstGLFramebufferPrivate = *mut _GstGLFramebufferPrivate;

#[repr(C)]
pub struct _GstGLFuncs(c_void);

pub type GstGLFuncs = *mut _GstGLFuncs;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLMemory {
    pub mem: GstGLBaseMemory,
    pub tex_id: c_uint,
    pub tex_target: GstGLTextureTarget,
    pub tex_format: GstGLFormat,
    pub info: gst_video::GstVideoInfo,
    pub valign: gst_video::GstVideoAlignment,
    pub plane: c_uint,
    pub tex_scaling: [c_float; 2],
    pub texture_wrapped: gboolean,
    pub unpack_length: c_uint,
    pub tex_width: c_uint,
    pub _padding: [gpointer; 4],
}

impl ::std::fmt::Debug for GstGLMemory {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLMemory @ {:?}", 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("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("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);

pub type GstGLSLStagePrivate = *mut _GstGLSLStagePrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLShaderClass {
    pub parent_class: gst::GstObjectClass,
}

impl ::std::fmt::Debug for GstGLShaderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLShaderClass @ {:?}", self as *const _))
            .finish()
    }
}

#[repr(C)]
pub struct _GstGLShaderPrivate(c_void);

pub type GstGLShaderPrivate = *mut _GstGLShaderPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLSyncMeta {
    pub parent: gst::GstMeta,
    pub context: *mut GstGLContext,
    pub data: gpointer,
    pub set_sync: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
    pub set_sync_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
    pub wait: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
    pub wait_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
    pub wait_cpu: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
    pub wait_cpu_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
    pub copy: Option<
        unsafe extern "C" fn(
            *mut GstGLSyncMeta,
            *mut gst::GstBuffer,
            *mut GstGLSyncMeta,
            *mut gst::GstBuffer,
        ),
    >,
    pub free: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
    pub free_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
}

impl ::std::fmt::Debug for GstGLSyncMeta {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLSyncMeta @ {:?}", self 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);

pub type GstGLUploadPrivate = *mut _GstGLUploadPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLVideoAllocationParams {
    pub parent: GstGLAllocationParams,
    pub v_info: *mut gst_video::GstVideoInfo,
    pub plane: c_uint,
    pub valign: *mut gst_video::GstVideoAlignment,
    pub target: GstGLTextureTarget,
    pub tex_format: GstGLFormat,
    pub _padding: [gpointer; 4],
}

impl ::std::fmt::Debug for GstGLVideoAllocationParams {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GstGLVideoAllocationParams @ {:?}",
            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);

pub type GstGLViewConvertPrivate = *mut _GstGLViewConvertPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLWindowClass {
    pub parent_class: gst::GstObjectClass,
    pub get_display: Option<unsafe extern "C" fn(*mut GstGLWindow) -> uintptr_t>,
    pub set_window_handle: Option<unsafe extern "C" fn(*mut GstGLWindow, uintptr_t)>,
    pub get_window_handle: Option<unsafe extern "C" fn(*mut GstGLWindow) -> uintptr_t>,
    pub draw: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
    pub run: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
    pub quit: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
    pub send_message: Option<unsafe extern "C" fn(*mut GstGLWindow, GstGLWindowCB, gpointer)>,
    pub send_message_async: Option<
        unsafe extern "C" fn(*mut GstGLWindow, GstGLWindowCB, gpointer, glib::GDestroyNotify),
    >,
    pub open: Option<unsafe extern "C" fn(*mut GstGLWindow, *mut *mut glib::GError) -> gboolean>,
    pub close: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
    pub handle_events: Option<unsafe extern "C" fn(*mut GstGLWindow, gboolean)>,
    pub set_preferred_size: Option<unsafe extern "C" fn(*mut GstGLWindow, c_int, c_int)>,
    pub show: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
    pub set_render_rectangle:
        Option<unsafe extern "C" fn(*mut GstGLWindow, c_int, c_int, c_int, c_int) -> gboolean>,
    pub queue_resize: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
    pub controls_viewport: Option<unsafe extern "C" fn(*mut GstGLWindow) -> gboolean>,
    pub _reserved: [gpointer; 3],
}

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)
            .field("controls_viewport", &self.controls_viewport)
            .finish()
    }
}

#[repr(C)]
pub struct _GstGLWindowPrivate(c_void);

pub type GstGLWindowPrivate = *mut _GstGLWindowPrivate;

// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLBaseFilter {
    pub parent: gst_base::GstBaseTransform,
    pub display: *mut GstGLDisplay,
    pub context: *mut GstGLContext,
    pub in_caps: *mut gst::GstCaps,
    pub out_caps: *mut gst::GstCaps,
    pub _padding: [gpointer; 4],
    pub priv_: *mut GstGLBaseFilterPrivate,
}

impl ::std::fmt::Debug for GstGLBaseFilter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLBaseFilter @ {:?}", 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()
    }
}

#[cfg(any(feature = "egl", feature = "dox"))]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLDisplayEGL {
    pub parent: GstGLDisplay,
    pub display: gpointer,
    pub foreign_display: gboolean,
    pub _padding: [gpointer; 4],
}

#[cfg(any(feature = "egl", feature = "dox"))]
impl ::std::fmt::Debug for GstGLDisplayEGL {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLDisplayEGL @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .finish()
    }
}

#[cfg(any(feature = "wayland", feature = "dox"))]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLDisplayWayland {
    pub parent: GstGLDisplay,
    pub display: gpointer,
    pub registry: gpointer,
    pub compositor: gpointer,
    pub subcompositor: gpointer,
    pub shell: gpointer,
    pub foreign_display: gboolean,
    pub _padding: [gpointer; 4],
}

#[cfg(any(feature = "wayland", feature = "dox"))]
impl ::std::fmt::Debug for GstGLDisplayWayland {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLDisplayWayland @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("display", &self.display)
            .field("registry", &self.registry)
            .field("compositor", &self.compositor)
            .field("subcompositor", &self.subcompositor)
            .field("shell", &self.shell)
            .finish()
    }
}

#[cfg(any(feature = "x11", feature = "dox"))]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GstGLDisplayX11 {
    pub parent: GstGLDisplay,
    pub name: *mut c_char,
    pub display: gpointer,
    pub xcb_connection: gpointer,
    pub foreign_display: gboolean,
    pub _padding: [gpointer; 4],
}

#[cfg(any(feature = "x11", feature = "dox"))]
impl ::std::fmt::Debug for GstGLDisplayX11 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GstGLDisplayX11 @ {:?}", 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 _))
            .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" {

    //=========================================================================
    // GstGLBaseMemoryError
    //=========================================================================
    pub fn gst_gl_base_memory_error_get_type() -> GType;
    pub fn gst_gl_base_memory_error_quark() -> glib::GQuark;

    //=========================================================================
    // GstGLContextError
    //=========================================================================
    pub fn gst_gl_context_error_get_type() -> GType;
    pub fn gst_gl_context_error_quark() -> glib::GQuark;

    //=========================================================================
    // GstGLFormat
    //=========================================================================
    pub fn gst_gl_format_get_type() -> GType;
    pub fn gst_gl_format_from_video_info(
        context: *mut GstGLContext,
        vinfo: *mut gst_video::GstVideoInfo,
        plane: c_uint,
    ) -> GstGLFormat;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_format_is_supported(context: *mut GstGLContext, format: GstGLFormat) -> gboolean;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_format_type_from_sized_gl_format(
        format: GstGLFormat,
        unsized_format: *mut GstGLFormat,
        gl_type: *mut c_uint,
    );
    pub fn gst_gl_format_type_n_bytes(format: c_uint, type_: c_uint) -> c_uint;

    //=========================================================================
    // GstGLQueryType
    //=========================================================================
    pub fn gst_gl_query_type_get_type() -> GType;

    //=========================================================================
    // GstGLSLError
    //=========================================================================
    pub fn gst_glsl_error_get_type() -> GType;
    pub fn gst_glsl_error_quark() -> glib::GQuark;

    //=========================================================================
    // GstGLSLVersion
    //=========================================================================
    pub fn gst_glsl_version_get_type() -> GType;
    pub fn gst_glsl_version_from_string(string: *const c_char) -> GstGLSLVersion;
    pub fn gst_glsl_version_profile_from_string(
        string: *const c_char,
        version_ret: *mut GstGLSLVersion,
        profile_ret: *mut GstGLSLProfile,
    ) -> gboolean;
    pub fn gst_glsl_version_profile_to_string(
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
    ) -> *mut c_char;
    pub fn gst_glsl_version_to_string(version: GstGLSLVersion) -> *const c_char;

    //=========================================================================
    // GstGLStereoDownmix
    //=========================================================================
    pub fn gst_gl_stereo_downmix_get_type() -> GType;

    //=========================================================================
    // GstGLTextureTarget
    //=========================================================================
    pub fn gst_gl_texture_target_get_type() -> GType;
    pub fn gst_gl_texture_target_from_gl(target: c_uint) -> GstGLTextureTarget;
    pub fn gst_gl_texture_target_from_string(str: *const c_char) -> GstGLTextureTarget;
    pub fn gst_gl_texture_target_to_buffer_pool_option(target: GstGLTextureTarget)
        -> *const c_char;
    pub fn gst_gl_texture_target_to_gl(target: GstGLTextureTarget) -> c_uint;
    pub fn gst_gl_texture_target_to_string(target: GstGLTextureTarget) -> *const c_char;

    //=========================================================================
    // GstGLUploadReturn
    //=========================================================================
    pub fn gst_gl_upload_return_get_type() -> GType;

    //=========================================================================
    // GstGLWindowError
    //=========================================================================
    pub fn gst_gl_window_error_get_type() -> GType;
    pub fn gst_gl_window_error_quark() -> glib::GQuark;

    //=========================================================================
    // GstGLAPI
    //=========================================================================
    pub fn gst_gl_api_get_type() -> GType;
    pub fn gst_gl_api_from_string(api_s: *const c_char) -> GstGLAPI;
    pub fn gst_gl_api_to_string(api: GstGLAPI) -> *mut c_char;

    //=========================================================================
    // GstGLBaseMemoryTransfer
    //=========================================================================
    pub fn gst_gl_base_memory_transfer_get_type() -> GType;

    //=========================================================================
    // GstGLDisplayType
    //=========================================================================
    pub fn gst_gl_display_type_get_type() -> GType;

    //=========================================================================
    // GstGLPlatform
    //=========================================================================
    pub fn gst_gl_platform_get_type() -> GType;
    pub fn gst_gl_platform_from_string(platform_s: *const c_char) -> GstGLPlatform;
    pub fn gst_gl_platform_to_string(platform: GstGLPlatform) -> *mut c_char;

    //=========================================================================
    // GstGLSLProfile
    //=========================================================================
    pub fn gst_glsl_profile_get_type() -> GType;
    pub fn gst_glsl_profile_from_string(string: *const c_char) -> GstGLSLProfile;
    pub fn gst_glsl_profile_to_string(profile: GstGLSLProfile) -> *const c_char;

    //=========================================================================
    // GstGLAllocationParams
    //=========================================================================
    pub fn gst_gl_allocation_params_get_type() -> GType;
    pub fn gst_gl_allocation_params_copy(
        src: *mut GstGLAllocationParams,
    ) -> *mut GstGLAllocationParams;
    pub fn gst_gl_allocation_params_copy_data(
        src: *mut GstGLAllocationParams,
        dest: *mut GstGLAllocationParams,
    );
    pub fn gst_gl_allocation_params_free(params: *mut GstGLAllocationParams);
    pub fn gst_gl_allocation_params_free_data(params: *mut GstGLAllocationParams);
    pub fn gst_gl_allocation_params_init(
        params: *mut GstGLAllocationParams,
        struct_size: size_t,
        alloc_flags: c_uint,
        copy: GstGLAllocationParamsCopyFunc,
        free: GstGLAllocationParamsFreeFunc,
        context: *mut GstGLContext,
        alloc_size: size_t,
        alloc_params: *mut gst::GstAllocationParams,
        wrapped_data: gpointer,
        gl_handle: gpointer,
        user_data: gpointer,
        notify: glib::GDestroyNotify,
    ) -> gboolean;

    //=========================================================================
    // GstGLAsyncDebug
    //=========================================================================
    pub fn gst_gl_async_debug_free(ad: *mut GstGLAsyncDebug);
    pub fn gst_gl_async_debug_freeze(ad: *mut GstGLAsyncDebug);
    pub fn gst_gl_async_debug_init(ad: *mut GstGLAsyncDebug);
    pub fn gst_gl_async_debug_output_log_msg(ad: *mut GstGLAsyncDebug);
    pub fn gst_gl_async_debug_store_log_msg(
        ad: *mut GstGLAsyncDebug,
        cat: *mut gst::GstDebugCategory,
        level: gst::GstDebugLevel,
        file: *const c_char,
        function: *const c_char,
        line: c_int,
        object: *mut gobject::GObject,
        format: *const c_char,
        ...
    );
    //pub fn gst_gl_async_debug_store_log_msg_valist(ad: *mut GstGLAsyncDebug, cat: *mut gst::GstDebugCategory, level: gst::GstDebugLevel, file: *const c_char, function: *const c_char, line: c_int, object: *mut gobject::GObject, format: *const c_char, varargs: /*Unimplemented*/va_list);
    pub fn gst_gl_async_debug_thaw(ad: *mut GstGLAsyncDebug);
    pub fn gst_gl_async_debug_unset(ad: *mut GstGLAsyncDebug);
    pub fn gst_gl_async_debug_new() -> *mut GstGLAsyncDebug;

    //=========================================================================
    // GstGLBaseMemory
    //=========================================================================
    pub fn gst_gl_base_memory_get_type() -> GType;
    pub fn gst_gl_base_memory_alloc_data(gl_mem: *mut GstGLBaseMemory) -> gboolean;
    pub fn gst_gl_base_memory_init(
        mem: *mut GstGLBaseMemory,
        allocator: *mut gst::GstAllocator,
        parent: *mut gst::GstMemory,
        context: *mut GstGLContext,
        params: *mut gst::GstAllocationParams,
        size: size_t,
        user_data: gpointer,
        notify: glib::GDestroyNotify,
    );
    pub fn gst_gl_base_memory_memcpy(
        src: *mut GstGLBaseMemory,
        dest: *mut GstGLBaseMemory,
        offset: ssize_t,
        size: ssize_t,
    ) -> gboolean;
    pub fn gst_gl_base_memory_alloc(
        allocator: *mut GstGLBaseMemoryAllocator,
        params: *mut GstGLAllocationParams,
    ) -> *mut GstGLBaseMemory;
    pub fn gst_gl_base_memory_init_once();

    //=========================================================================
    // GstGLBuffer
    //=========================================================================
    pub fn gst_gl_buffer_init_once();

    //=========================================================================
    // GstGLBufferAllocationParams
    //=========================================================================
    pub fn gst_gl_buffer_allocation_params_get_type() -> GType;
    pub fn gst_gl_buffer_allocation_params_new(
        context: *mut GstGLContext,
        alloc_size: size_t,
        alloc_params: *mut gst::GstAllocationParams,
        gl_target: c_uint,
        gl_usage: c_uint,
    ) -> *mut GstGLBufferAllocationParams;

    //=========================================================================
    // GstGLMemory
    //=========================================================================
    pub fn gst_gl_memory_copy_into(
        gl_mem: *mut GstGLMemory,
        tex_id: c_uint,
        target: GstGLTextureTarget,
        tex_format: GstGLFormat,
        width: c_int,
        height: c_int,
    ) -> gboolean;
    pub fn gst_gl_memory_copy_teximage(
        src: *mut GstGLMemory,
        tex_id: c_uint,
        out_target: GstGLTextureTarget,
        out_tex_format: GstGLFormat,
        out_width: c_int,
        out_height: c_int,
    ) -> gboolean;
    pub fn gst_gl_memory_get_texture_format(gl_mem: *mut GstGLMemory) -> GstGLFormat;
    pub fn gst_gl_memory_get_texture_height(gl_mem: *mut GstGLMemory) -> c_int;
    pub fn gst_gl_memory_get_texture_id(gl_mem: *mut GstGLMemory) -> c_uint;
    pub fn gst_gl_memory_get_texture_target(gl_mem: *mut GstGLMemory) -> GstGLTextureTarget;
    pub fn gst_gl_memory_get_texture_width(gl_mem: *mut GstGLMemory) -> c_int;
    pub fn gst_gl_memory_init(
        mem: *mut GstGLMemory,
        allocator: *mut gst::GstAllocator,
        parent: *mut gst::GstMemory,
        context: *mut GstGLContext,
        target: GstGLTextureTarget,
        tex_format: GstGLFormat,
        params: *mut gst::GstAllocationParams,
        info: *mut gst_video::GstVideoInfo,
        plane: c_uint,
        valign: *mut gst_video::GstVideoAlignment,
        user_data: gpointer,
        notify: glib::GDestroyNotify,
    );
    pub fn gst_gl_memory_read_pixels(gl_mem: *mut GstGLMemory, read_pointer: gpointer) -> gboolean;
    pub fn gst_gl_memory_texsubimage(gl_mem: *mut GstGLMemory, read_pointer: gpointer);
    pub fn gst_gl_memory_init_once();
    pub fn gst_gl_memory_setup_buffer(
        allocator: *mut GstGLMemoryAllocator,
        buffer: *mut gst::GstBuffer,
        params: *mut GstGLVideoAllocationParams,
        tex_formats: *mut GstGLFormat,
        wrapped_data: *mut gpointer,
        n_wrapped_pointers: size_t,
    ) -> gboolean;

    //=========================================================================
    // GstGLMemoryPBO
    //=========================================================================
    pub fn gst_gl_memory_pbo_copy_into_texture(
        gl_mem: *mut GstGLMemoryPBO,
        tex_id: c_uint,
        target: GstGLTextureTarget,
        tex_format: GstGLFormat,
        width: c_int,
        height: c_int,
        stride: c_int,
        respecify: gboolean,
    ) -> gboolean;
    pub fn gst_gl_memory_pbo_download_transfer(gl_mem: *mut GstGLMemoryPBO);
    pub fn gst_gl_memory_pbo_upload_transfer(gl_mem: *mut GstGLMemoryPBO);
    pub fn gst_gl_memory_pbo_init_once();

    //=========================================================================
    // GstGLQuery
    //=========================================================================
    pub fn gst_gl_query_counter(query: *mut GstGLQuery);
    pub fn gst_gl_query_end(query: *mut GstGLQuery);
    pub fn gst_gl_query_free(query: *mut GstGLQuery);
    pub fn gst_gl_query_init(
        query: *mut GstGLQuery,
        context: *mut GstGLContext,
        query_type: GstGLQueryType,
    );
    pub fn gst_gl_query_result(query: *mut GstGLQuery) -> u64;
    pub fn gst_gl_query_start(query: *mut GstGLQuery);
    pub fn gst_gl_query_unset(query: *mut GstGLQuery);
    pub fn gst_gl_query_local_gl_context(
        element: *mut gst::GstElement,
        direction: gst::GstPadDirection,
        context_ptr: *mut *mut GstGLContext,
    ) -> gboolean;
    pub fn gst_gl_query_new(
        context: *mut GstGLContext,
        query_type: GstGLQueryType,
    ) -> *mut GstGLQuery;

    //=========================================================================
    // GstGLRenderbuffer
    //=========================================================================
    pub fn gst_gl_renderbuffer_get_format(gl_mem: *mut GstGLRenderbuffer) -> GstGLFormat;
    pub fn gst_gl_renderbuffer_get_height(gl_mem: *mut GstGLRenderbuffer) -> c_int;
    pub fn gst_gl_renderbuffer_get_id(gl_mem: *mut GstGLRenderbuffer) -> c_uint;
    pub fn gst_gl_renderbuffer_get_width(gl_mem: *mut GstGLRenderbuffer) -> c_int;
    pub fn gst_gl_renderbuffer_init_once();

    //=========================================================================
    // GstGLRenderbufferAllocationParams
    //=========================================================================
    pub fn gst_gl_renderbuffer_allocation_params_get_type() -> GType;
    pub fn gst_gl_renderbuffer_allocation_params_new(
        context: *mut GstGLContext,
        alloc_params: *mut gst::GstAllocationParams,
        renderbuffer_format: GstGLFormat,
        width: c_uint,
        height: c_uint,
    ) -> *mut GstGLRenderbufferAllocationParams;
    pub fn gst_gl_renderbuffer_allocation_params_new_wrapped(
        context: *mut GstGLContext,
        alloc_params: *mut gst::GstAllocationParams,
        renderbuffer_format: GstGLFormat,
        width: c_uint,
        height: c_uint,
        gl_handle: gpointer,
        user_data: gpointer,
        notify: glib::GDestroyNotify,
    ) -> *mut GstGLRenderbufferAllocationParams;

    //=========================================================================
    // GstGLSyncMeta
    //=========================================================================
    pub fn gst_gl_sync_meta_set_sync_point(
        sync_meta: *mut GstGLSyncMeta,
        context: *mut GstGLContext,
    );
    pub fn gst_gl_sync_meta_wait(sync_meta: *mut GstGLSyncMeta, context: *mut GstGLContext);
    pub fn gst_gl_sync_meta_wait_cpu(sync_meta: *mut GstGLSyncMeta, context: *mut GstGLContext);
    pub fn gst_gl_sync_meta_get_info() -> *const gst::GstMetaInfo;

    //=========================================================================
    // GstGLVideoAllocationParams
    //=========================================================================
    pub fn gst_gl_video_allocation_params_get_type() -> GType;
    pub fn gst_gl_video_allocation_params_new(
        context: *mut GstGLContext,
        alloc_params: *mut gst::GstAllocationParams,
        v_info: *mut gst_video::GstVideoInfo,
        plane: c_uint,
        valign: *mut gst_video::GstVideoAlignment,
        target: GstGLTextureTarget,
        tex_format: GstGLFormat,
    ) -> *mut GstGLVideoAllocationParams;
    pub fn gst_gl_video_allocation_params_new_wrapped_data(
        context: *mut GstGLContext,
        alloc_params: *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;
    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;
    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;
    pub fn gst_gl_video_allocation_params_copy_data(
        src_vid: *mut GstGLVideoAllocationParams,
        dest_vid: *mut GstGLVideoAllocationParams,
    );
    pub fn gst_gl_video_allocation_params_free_data(params: *mut GstGLVideoAllocationParams);
    pub fn gst_gl_video_allocation_params_init_full(
        params: *mut GstGLVideoAllocationParams,
        struct_size: size_t,
        alloc_flags: c_uint,
        copy: GstGLAllocationParamsCopyFunc,
        free: GstGLAllocationParamsFreeFunc,
        context: *mut GstGLContext,
        alloc_params: *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;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_base_filter_find_gl_context(filter: *mut GstGLBaseFilter) -> gboolean;

    //=========================================================================
    // 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;
    pub fn gst_gl_color_convert_new(context: *mut GstGLContext) -> *mut GstGLColorConvert;
    pub fn gst_gl_color_convert_fixate_caps(
        context: *mut GstGLContext,
        direction: gst::GstPadDirection,
        caps: *mut gst::GstCaps,
        other: *mut gst::GstCaps,
    ) -> *mut gst::GstCaps;
    pub fn gst_gl_color_convert_transform_caps(
        context: *mut GstGLContext,
        direction: gst::GstPadDirection,
        caps: *mut gst::GstCaps,
        filter: *mut gst::GstCaps,
    ) -> *mut gst::GstCaps;
    pub fn gst_gl_color_convert_decide_allocation(
        convert: *mut GstGLColorConvert,
        query: *mut gst::GstQuery,
    ) -> gboolean;
    pub fn gst_gl_color_convert_perform(
        convert: *mut GstGLColorConvert,
        inbuf: *mut gst::GstBuffer,
    ) -> *mut gst::GstBuffer;
    pub fn gst_gl_color_convert_set_caps(
        convert: *mut GstGLColorConvert,
        in_caps: *mut gst::GstCaps,
        out_caps: *mut gst::GstCaps,
    ) -> gboolean;

    //=========================================================================
    // GstGLContext
    //=========================================================================
    pub fn gst_gl_context_get_type() -> GType;
    pub fn gst_gl_context_new(display: *mut GstGLDisplay) -> *mut GstGLContext;
    pub fn gst_gl_context_new_wrapped(
        display: *mut GstGLDisplay,
        handle: uintptr_t,
        context_type: GstGLPlatform,
        available_apis: GstGLAPI,
    ) -> *mut GstGLContext;
    pub fn gst_gl_context_default_get_proc_address(
        gl_api: GstGLAPI,
        name: *const c_char,
    ) -> gpointer;
    pub fn gst_gl_context_get_current() -> *mut GstGLContext;
    pub fn gst_gl_context_get_current_gl_api(
        platform: GstGLPlatform,
        major: *mut c_uint,
        minor: *mut c_uint,
    ) -> GstGLAPI;
    pub fn gst_gl_context_get_current_gl_context(context_type: GstGLPlatform) -> uintptr_t;
    pub fn gst_gl_context_get_proc_address_with_platform(
        context_type: GstGLPlatform,
        gl_api: GstGLAPI,
        name: *const c_char,
    ) -> gpointer;
    pub fn gst_gl_context_activate(context: *mut GstGLContext, activate: gboolean) -> gboolean;
    pub fn gst_gl_context_can_share(
        context: *mut GstGLContext,
        other_context: *mut GstGLContext,
    ) -> gboolean;
    pub fn gst_gl_context_check_feature(
        context: *mut GstGLContext,
        feature: *const c_char,
    ) -> gboolean;
    pub fn gst_gl_context_check_framebuffer_status(
        context: *mut GstGLContext,
        fbo_target: c_uint,
    ) -> gboolean;
    pub fn gst_gl_context_check_gl_version(
        context: *mut GstGLContext,
        api: GstGLAPI,
        maj: c_int,
        min: c_int,
    ) -> gboolean;
    pub fn gst_gl_context_clear_framebuffer(context: *mut GstGLContext);
    pub fn gst_gl_context_clear_shader(context: *mut GstGLContext);
    pub fn gst_gl_context_create(
        context: *mut GstGLContext,
        other_context: *mut GstGLContext,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gst_gl_context_destroy(context: *mut GstGLContext);
    pub fn gst_gl_context_fill_info(
        context: *mut GstGLContext,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gst_gl_context_get_display(context: *mut GstGLContext) -> *mut GstGLDisplay;
    pub fn gst_gl_context_get_gl_api(context: *mut GstGLContext) -> GstGLAPI;
    pub fn gst_gl_context_get_gl_context(context: *mut GstGLContext) -> uintptr_t;
    pub fn gst_gl_context_get_gl_platform(context: *mut GstGLContext) -> GstGLPlatform;
    pub fn gst_gl_context_get_gl_platform_version(
        context: *mut GstGLContext,
        major: *mut c_int,
        minor: *mut c_int,
    );
    pub fn gst_gl_context_get_gl_version(
        context: *mut GstGLContext,
        maj: *mut c_int,
        min: *mut c_int,
    );
    pub fn gst_gl_context_get_proc_address(
        context: *mut GstGLContext,
        name: *const c_char,
    ) -> gpointer;
    pub fn gst_gl_context_get_thread(context: *mut GstGLContext) -> *mut glib::GThread;
    pub fn gst_gl_context_get_window(context: *mut GstGLContext) -> *mut GstGLWindow;
    pub fn gst_gl_context_is_shared(context: *mut GstGLContext) -> gboolean;
    pub fn gst_gl_context_set_shared_with(context: *mut GstGLContext, share: *mut GstGLContext);
    pub fn gst_gl_context_set_window(
        context: *mut GstGLContext,
        window: *mut GstGLWindow,
    ) -> gboolean;
    pub fn gst_gl_context_supports_glsl_profile_version(
        context: *mut GstGLContext,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
    ) -> gboolean;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_context_supports_precision(
        context: *mut GstGLContext,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
    ) -> gboolean;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_context_supports_precision_highp(
        context: *mut GstGLContext,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
    ) -> gboolean;
    pub fn gst_gl_context_swap_buffers(context: *mut GstGLContext);
    pub fn gst_gl_context_thread_add(
        context: *mut GstGLContext,
        func: GstGLContextThreadFunc,
        data: gpointer,
    );

    //=========================================================================
    // GstGLDisplay
    //=========================================================================
    pub fn gst_gl_display_get_type() -> GType;
    pub fn gst_gl_display_new() -> *mut GstGLDisplay;
    pub fn gst_gl_display_add_context(
        display: *mut GstGLDisplay,
        context: *mut GstGLContext,
    ) -> gboolean;
    pub fn gst_gl_display_create_context(
        display: *mut GstGLDisplay,
        other_context: *mut GstGLContext,
        p_context: *mut *mut GstGLContext,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gst_gl_display_create_window(display: *mut GstGLDisplay) -> *mut GstGLWindow;
    pub fn gst_gl_display_filter_gl_api(display: *mut GstGLDisplay, gl_api: GstGLAPI);
    pub fn gst_gl_display_find_window(
        display: *mut GstGLDisplay,
        data: gpointer,
        compare_func: glib::GCompareFunc,
    ) -> *mut GstGLWindow;
    pub fn gst_gl_display_get_gl_api(display: *mut GstGLDisplay) -> GstGLAPI;
    pub fn gst_gl_display_get_gl_api_unlocked(display: *mut GstGLDisplay) -> GstGLAPI;
    pub fn gst_gl_display_get_gl_context_for_thread(
        display: *mut GstGLDisplay,
        thread: *mut glib::GThread,
    ) -> *mut GstGLContext;
    pub fn gst_gl_display_get_handle(display: *mut GstGLDisplay) -> uintptr_t;
    pub fn gst_gl_display_get_handle_type(display: *mut GstGLDisplay) -> GstGLDisplayType;
    pub fn gst_gl_display_remove_window(
        display: *mut GstGLDisplay,
        window: *mut GstGLWindow,
    ) -> gboolean;

    //=========================================================================
    // GstGLDisplayEGL
    //=========================================================================
    #[cfg(any(feature = "egl", feature = "dox"))]
    pub fn gst_gl_display_egl_get_type() -> GType;
    #[cfg(any(feature = "egl", feature = "dox"))]
    pub fn gst_gl_display_egl_new() -> *mut GstGLDisplayEGL;
    #[cfg(any(feature = "egl", feature = "dox"))]
    pub fn gst_gl_display_egl_new_with_egl_display(display: gpointer) -> *mut GstGLDisplayEGL;
    #[cfg(any(feature = "egl", feature = "dox"))]
    pub fn gst_gl_display_egl_get_from_native(
        type_: GstGLDisplayType,
        display: uintptr_t,
    ) -> gpointer;

    //=========================================================================
    // GstGLDisplayWayland
    //=========================================================================
    #[cfg(any(feature = "wayland", feature = "dox"))]
    pub fn gst_gl_display_wayland_get_type() -> GType;
    #[cfg(any(feature = "wayland", feature = "dox"))]
    pub fn gst_gl_display_wayland_new(name: *const c_char) -> *mut GstGLDisplayWayland;
    #[cfg(any(feature = "wayland", feature = "dox"))]
    pub fn gst_gl_display_wayland_new_with_display(display: gpointer) -> *mut GstGLDisplayWayland;

    //=========================================================================
    // GstGLDisplayX11
    //=========================================================================
    #[cfg(any(feature = "x11", feature = "dox"))]
    pub fn gst_gl_display_x11_get_type() -> GType;
    #[cfg(any(feature = "x11", feature = "dox"))]
    pub fn gst_gl_display_x11_new(name: *const c_char) -> *mut GstGLDisplayX11;
    #[cfg(any(feature = "x11", feature = "dox"))]
    pub fn gst_gl_display_x11_new_with_display(display: gpointer) -> *mut GstGLDisplayX11;

    //=========================================================================
    // GstGLFilter
    //=========================================================================
    pub fn gst_gl_filter_get_type() -> GType;
    pub fn gst_gl_filter_add_rgba_pad_templates(klass: *mut GstGLFilterClass);
    pub fn gst_gl_filter_draw_fullscreen_quad(filter: *mut GstGLFilter);
    pub fn gst_gl_filter_filter_texture(
        filter: *mut GstGLFilter,
        inbuf: *mut gst::GstBuffer,
        outbuf: *mut gst::GstBuffer,
    ) -> gboolean;
    pub fn gst_gl_filter_render_to_target(
        filter: *mut GstGLFilter,
        input: *mut GstGLMemory,
        output: *mut GstGLMemory,
        func: GstGLFilterRenderFunc,
        data: gpointer,
    ) -> gboolean;
    pub fn gst_gl_filter_render_to_target_with_shader(
        filter: *mut GstGLFilter,
        input: *mut GstGLMemory,
        output: *mut GstGLMemory,
        shader: *mut GstGLShader,
    );

    //=========================================================================
    // GstGLFramebuffer
    //=========================================================================
    pub fn gst_gl_framebuffer_get_type() -> GType;
    pub fn gst_gl_framebuffer_new(context: *mut GstGLContext) -> *mut GstGLFramebuffer;
    pub fn gst_gl_framebuffer_new_with_default_depth(
        context: *mut GstGLContext,
        width: c_uint,
        height: c_uint,
    ) -> *mut GstGLFramebuffer;
    pub fn gst_gl_framebuffer_attach(
        fb: *mut GstGLFramebuffer,
        attachment_point: c_uint,
        mem: *mut GstGLBaseMemory,
    );
    pub fn gst_gl_framebuffer_bind(fb: *mut GstGLFramebuffer);
    pub fn gst_gl_framebuffer_draw_to_texture(
        fb: *mut GstGLFramebuffer,
        mem: *mut GstGLMemory,
        func: GstGLFramebufferFunc,
        user_data: gpointer,
    ) -> gboolean;
    pub fn gst_gl_framebuffer_get_effective_dimensions(
        fb: *mut GstGLFramebuffer,
        width: *mut c_uint,
        height: *mut c_uint,
    );
    pub fn gst_gl_framebuffer_get_id(fb: *mut GstGLFramebuffer) -> c_uint;

    //=========================================================================
    // GstGLMemoryAllocator
    //=========================================================================
    pub fn gst_gl_memory_allocator_get_type() -> GType;
    pub fn gst_gl_memory_allocator_get_default(
        context: *mut GstGLContext,
    ) -> *mut GstGLMemoryAllocator;

    //=========================================================================
    // GstGLMemoryPBOAllocator
    //=========================================================================
    pub fn gst_gl_memory_pbo_allocator_get_type() -> GType;

    //=========================================================================
    // GstGLOverlayCompositor
    //=========================================================================
    pub fn gst_gl_overlay_compositor_get_type() -> GType;
    pub fn gst_gl_overlay_compositor_new(context: *mut GstGLContext)
        -> *mut GstGLOverlayCompositor;
    pub fn gst_gl_overlay_compositor_add_caps(caps: *mut gst::GstCaps) -> *mut gst::GstCaps;
    pub fn gst_gl_overlay_compositor_draw_overlays(compositor: *mut GstGLOverlayCompositor);
    pub fn gst_gl_overlay_compositor_free_overlays(compositor: *mut GstGLOverlayCompositor);
    pub fn gst_gl_overlay_compositor_upload_overlays(
        compositor: *mut GstGLOverlayCompositor,
        buf: *mut gst::GstBuffer,
    );

    //=========================================================================
    // GstGLRenderbufferAllocator
    //=========================================================================
    pub fn gst_gl_renderbuffer_allocator_get_type() -> GType;

    //=========================================================================
    // GstGLSLStage
    //=========================================================================
    pub fn gst_glsl_stage_get_type() -> GType;
    pub fn gst_glsl_stage_new(context: *mut GstGLContext, type_: c_uint) -> *mut GstGLSLStage;
    pub fn gst_glsl_stage_new_default_fragment(context: *mut GstGLContext) -> *mut GstGLSLStage;
    pub fn gst_glsl_stage_new_default_vertex(context: *mut GstGLContext) -> *mut GstGLSLStage;
    pub fn gst_glsl_stage_new_with_string(
        context: *mut GstGLContext,
        type_: c_uint,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
        str: *const c_char,
    ) -> *mut GstGLSLStage;
    pub fn gst_glsl_stage_new_with_strings(
        context: *mut GstGLContext,
        type_: c_uint,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
        n_strings: c_int,
        str: *mut *const c_char,
    ) -> *mut GstGLSLStage;
    pub fn gst_glsl_stage_compile(
        stage: *mut GstGLSLStage,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gst_glsl_stage_get_handle(stage: *mut GstGLSLStage) -> c_uint;
    pub fn gst_glsl_stage_get_profile(stage: *mut GstGLSLStage) -> GstGLSLProfile;
    pub fn gst_glsl_stage_get_shader_type(stage: *mut GstGLSLStage) -> c_uint;
    pub fn gst_glsl_stage_get_version(stage: *mut GstGLSLStage) -> GstGLSLVersion;
    pub fn gst_glsl_stage_set_strings(
        stage: *mut GstGLSLStage,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
        n_strings: c_int,
        str: *mut *const c_char,
    ) -> gboolean;

    //=========================================================================
    // GstGLShader
    //=========================================================================
    pub fn gst_gl_shader_get_type() -> GType;
    pub fn gst_gl_shader_new(context: *mut GstGLContext) -> *mut GstGLShader;
    pub fn gst_gl_shader_new_default(
        context: *mut GstGLContext,
        error: *mut *mut glib::GError,
    ) -> *mut GstGLShader;
    pub fn gst_gl_shader_new_link_with_stages(
        context: *mut GstGLContext,
        error: *mut *mut glib::GError,
        ...
    ) -> *mut GstGLShader;
    pub fn gst_gl_shader_new_with_stages(
        context: *mut GstGLContext,
        error: *mut *mut glib::GError,
        ...
    ) -> *mut GstGLShader;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_shader_string_fragment_external_oes_get_default(
        context: *mut GstGLContext,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
    ) -> *mut c_char;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_shader_string_fragment_get_default(
        context: *mut GstGLContext,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
    ) -> *mut c_char;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_shader_string_get_highest_precision(
        context: *mut GstGLContext,
        version: GstGLSLVersion,
        profile: GstGLSLProfile,
    ) -> *const c_char;
    pub fn gst_gl_shader_attach(shader: *mut GstGLShader, stage: *mut GstGLSLStage) -> gboolean;
    pub fn gst_gl_shader_attach_unlocked(
        shader: *mut GstGLShader,
        stage: *mut GstGLSLStage,
    ) -> gboolean;
    pub fn gst_gl_shader_bind_attribute_location(
        shader: *mut GstGLShader,
        index: c_uint,
        name: *const c_char,
    );
    pub fn gst_gl_shader_bind_frag_data_location(
        shader: *mut GstGLShader,
        index: c_uint,
        name: *const c_char,
    );
    pub fn gst_gl_shader_compile_attach_stage(
        shader: *mut GstGLShader,
        stage: *mut GstGLSLStage,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gst_gl_shader_detach(shader: *mut GstGLShader, stage: *mut GstGLSLStage);
    pub fn gst_gl_shader_detach_unlocked(shader: *mut GstGLShader, stage: *mut GstGLSLStage);
    pub fn gst_gl_shader_get_attribute_location(
        shader: *mut GstGLShader,
        name: *const c_char,
    ) -> c_int;
    pub fn gst_gl_shader_get_program_handle(shader: *mut GstGLShader) -> c_int;
    pub fn gst_gl_shader_is_linked(shader: *mut GstGLShader) -> gboolean;
    pub fn gst_gl_shader_link(shader: *mut GstGLShader, error: *mut *mut glib::GError) -> gboolean;
    pub fn gst_gl_shader_release(shader: *mut GstGLShader);
    pub fn gst_gl_shader_release_unlocked(shader: *mut GstGLShader);
    pub fn gst_gl_shader_set_uniform_1f(
        shader: *mut GstGLShader,
        name: *const c_char,
        value: c_float,
    );
    pub fn gst_gl_shader_set_uniform_1fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_uint,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_1i(
        shader: *mut GstGLShader,
        name: *const c_char,
        value: c_int,
    );
    pub fn gst_gl_shader_set_uniform_1iv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_uint,
        value: *const c_int,
    );
    pub fn gst_gl_shader_set_uniform_2f(
        shader: *mut GstGLShader,
        name: *const c_char,
        v0: c_float,
        v1: c_float,
    );
    pub fn gst_gl_shader_set_uniform_2fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_uint,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_2i(
        shader: *mut GstGLShader,
        name: *const c_char,
        v0: c_int,
        v1: c_int,
    );
    pub fn gst_gl_shader_set_uniform_2iv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_uint,
        value: *const c_int,
    );
    pub fn gst_gl_shader_set_uniform_3f(
        shader: *mut GstGLShader,
        name: *const c_char,
        v0: c_float,
        v1: c_float,
        v2: c_float,
    );
    pub fn gst_gl_shader_set_uniform_3fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_uint,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_3i(
        shader: *mut GstGLShader,
        name: *const c_char,
        v0: c_int,
        v1: c_int,
        v2: c_int,
    );
    pub fn gst_gl_shader_set_uniform_3iv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_uint,
        value: *const c_int,
    );
    pub fn gst_gl_shader_set_uniform_4f(
        shader: *mut GstGLShader,
        name: *const c_char,
        v0: c_float,
        v1: c_float,
        v2: c_float,
        v3: c_float,
    );
    pub fn gst_gl_shader_set_uniform_4fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_uint,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_4i(
        shader: *mut GstGLShader,
        name: *const c_char,
        v0: c_int,
        v1: c_int,
        v2: c_int,
        v3: c_int,
    );
    pub fn gst_gl_shader_set_uniform_4iv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_uint,
        value: *const c_int,
    );
    pub fn gst_gl_shader_set_uniform_matrix_2fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_matrix_2x3fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_matrix_2x4fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_matrix_3fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_matrix_3x2fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_matrix_3x4fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_matrix_4fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_matrix_4x2fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_set_uniform_matrix_4x3fv(
        shader: *mut GstGLShader,
        name: *const c_char,
        count: c_int,
        transpose: gboolean,
        value: *const c_float,
    );
    pub fn gst_gl_shader_use(shader: *mut GstGLShader);

    //=========================================================================
    // GstGLUpload
    //=========================================================================
    pub fn gst_gl_upload_get_type() -> GType;
    pub fn gst_gl_upload_new(context: *mut GstGLContext) -> *mut GstGLUpload;
    pub fn gst_gl_upload_get_input_template_caps() -> *mut gst::GstCaps;
    pub fn gst_gl_upload_get_caps(
        upload: *mut GstGLUpload,
        in_caps: *mut *mut gst::GstCaps,
        out_caps: *mut *mut gst::GstCaps,
    );
    pub fn gst_gl_upload_perform_with_buffer(
        upload: *mut GstGLUpload,
        buffer: *mut gst::GstBuffer,
        outbuf_ptr: *mut *mut gst::GstBuffer,
    ) -> GstGLUploadReturn;
    pub fn gst_gl_upload_propose_allocation(
        upload: *mut GstGLUpload,
        decide_query: *mut gst::GstQuery,
        query: *mut gst::GstQuery,
    );
    pub fn gst_gl_upload_set_caps(
        upload: *mut GstGLUpload,
        in_caps: *mut gst::GstCaps,
        out_caps: *mut gst::GstCaps,
    ) -> gboolean;
    pub fn gst_gl_upload_set_context(upload: *mut GstGLUpload, context: *mut GstGLContext);
    pub fn gst_gl_upload_transform_caps(
        upload: *mut GstGLUpload,
        context: *mut GstGLContext,
        direction: gst::GstPadDirection,
        caps: *mut gst::GstCaps,
        filter: *mut gst::GstCaps,
    ) -> *mut gst::GstCaps;

    //=========================================================================
    // GstGLViewConvert
    //=========================================================================
    pub fn gst_gl_view_convert_get_type() -> GType;
    pub fn gst_gl_view_convert_new() -> *mut GstGLViewConvert;
    pub fn gst_gl_view_convert_fixate_caps(
        viewconvert: *mut GstGLViewConvert,
        direction: gst::GstPadDirection,
        caps: *mut gst::GstCaps,
        othercaps: *mut gst::GstCaps,
    ) -> *mut gst::GstCaps;
    pub fn gst_gl_view_convert_get_output(
        viewconvert: *mut GstGLViewConvert,
        outbuf_ptr: *mut *mut gst::GstBuffer,
    ) -> gst::GstFlowReturn;
    pub fn gst_gl_view_convert_perform(
        viewconvert: *mut GstGLViewConvert,
        inbuf: *mut gst::GstBuffer,
    ) -> *mut gst::GstBuffer;
    pub fn gst_gl_view_convert_reset(viewconvert: *mut GstGLViewConvert);
    pub fn gst_gl_view_convert_set_caps(
        viewconvert: *mut GstGLViewConvert,
        in_caps: *mut gst::GstCaps,
        out_caps: *mut gst::GstCaps,
    ) -> gboolean;
    pub fn gst_gl_view_convert_set_context(
        viewconvert: *mut GstGLViewConvert,
        context: *mut GstGLContext,
    );
    pub fn gst_gl_view_convert_submit_input_buffer(
        viewconvert: *mut GstGLViewConvert,
        is_discont: gboolean,
        input: *mut gst::GstBuffer,
    ) -> gst::GstFlowReturn;
    pub fn gst_gl_view_convert_transform_caps(
        viewconvert: *mut GstGLViewConvert,
        direction: gst::GstPadDirection,
        caps: *mut gst::GstCaps,
        filter: *mut gst::GstCaps,
    ) -> *mut gst::GstCaps;

    //=========================================================================
    // GstGLWindow
    //=========================================================================
    pub fn gst_gl_window_get_type() -> GType;
    pub fn gst_gl_window_new(display: *mut GstGLDisplay) -> *mut GstGLWindow;
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    pub fn gst_gl_window_controls_viewport(window: *mut GstGLWindow) -> gboolean;
    pub fn gst_gl_window_draw(window: *mut GstGLWindow);
    pub fn gst_gl_window_get_context(window: *mut GstGLWindow) -> *mut GstGLContext;
    pub fn gst_gl_window_get_display(window: *mut GstGLWindow) -> uintptr_t;
    pub fn gst_gl_window_get_surface_dimensions(
        window: *mut GstGLWindow,
        width: *mut c_uint,
        height: *mut c_uint,
    );
    pub fn gst_gl_window_get_window_handle(window: *mut GstGLWindow) -> uintptr_t;
    pub fn gst_gl_window_handle_events(window: *mut GstGLWindow, handle_events: gboolean);
    pub fn gst_gl_window_queue_resize(window: *mut GstGLWindow);
    pub fn gst_gl_window_quit(window: *mut GstGLWindow);
    pub fn gst_gl_window_resize(window: *mut GstGLWindow, width: c_uint, height: c_uint);
    pub fn gst_gl_window_run(window: *mut GstGLWindow);
    pub fn gst_gl_window_send_key_event(
        window: *mut GstGLWindow,
        event_type: *const c_char,
        key_str: *const c_char,
    );
    pub fn gst_gl_window_send_message(
        window: *mut GstGLWindow,
        callback: GstGLWindowCB,
        data: gpointer,
    );
    pub fn gst_gl_window_send_message_async(
        window: *mut GstGLWindow,
        callback: GstGLWindowCB,
        data: gpointer,
        destroy: glib::GDestroyNotify,
    );
    pub fn gst_gl_window_send_mouse_event(
        window: *mut GstGLWindow,
        event_type: *const c_char,
        button: c_int,
        posx: c_double,
        posy: c_double,
    );
    pub fn gst_gl_window_set_close_callback(
        window: *mut GstGLWindow,
        callback: GstGLWindowCB,
        data: gpointer,
        destroy_notify: glib::GDestroyNotify,
    );
    pub fn gst_gl_window_set_draw_callback(
        window: *mut GstGLWindow,
        callback: GstGLWindowCB,
        data: gpointer,
        destroy_notify: glib::GDestroyNotify,
    );
    pub fn gst_gl_window_set_preferred_size(window: *mut GstGLWindow, width: c_int, height: c_int);
    pub fn gst_gl_window_set_render_rectangle(
        window: *mut GstGLWindow,
        x: c_int,
        y: c_int,
        width: c_int,
        height: c_int,
    ) -> gboolean;
    pub fn gst_gl_window_set_resize_callback(
        window: *mut GstGLWindow,
        callback: GstGLWindowResizeCB,
        data: gpointer,
        destroy_notify: glib::GDestroyNotify,
    );
    pub fn gst_gl_window_set_window_handle(window: *mut GstGLWindow, handle: uintptr_t);
    pub fn gst_gl_window_show(window: *mut GstGLWindow);

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn gst_buffer_add_gl_sync_meta(
        context: *mut GstGLContext,
        buffer: *mut gst::GstBuffer,
    ) -> *mut GstGLSyncMeta;
    pub fn gst_buffer_add_gl_sync_meta_full(
        context: *mut GstGLContext,
        buffer: *mut gst::GstBuffer,
        data: gpointer,
    ) -> *mut GstGLSyncMeta;
    pub fn gst_buffer_pool_config_get_gl_allocation_params(
        config: *mut gst::GstStructure,
    ) -> *mut GstGLAllocationParams;
    pub fn gst_buffer_pool_config_set_gl_allocation_params(
        config: *mut gst::GstStructure,
        params: *mut GstGLAllocationParams,
    );
    pub fn gst_context_get_gl_display(
        context: *mut gst::GstContext,
        display: *mut *mut GstGLDisplay,
    ) -> gboolean;
    pub fn gst_context_set_gl_display(context: *mut gst::GstContext, display: *mut GstGLDisplay);
    pub fn gst_gl_check_extension(name: *const c_char, ext: *const c_char) -> gboolean;
    pub fn gst_gl_element_propagate_display_context(
        element: *mut gst::GstElement,
        display: *mut GstGLDisplay,
    );
    pub fn gst_gl_ensure_element_data(
        element: gpointer,
        display_ptr: *mut *mut GstGLDisplay,
        other_context_ptr: *mut *mut GstGLContext,
    ) -> gboolean;
    pub fn gst_gl_get_plane_data_size(
        info: *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;
    pub fn gst_gl_insert_debug_marker(context: *mut GstGLContext, format: *const c_char, ...);
    pub fn gst_gl_sized_gl_format_from_gl_format_type(
        context: *mut GstGLContext,
        format: c_uint,
        type_: c_uint,
    ) -> c_uint;
    pub fn gst_gl_stereo_downmix_mode_get_type() -> GType;
    pub fn gst_gl_sync_meta_api_get_type() -> GType;
    pub fn gst_gl_value_get_texture_target_mask(
        value: *const gobject::GValue,
    ) -> GstGLTextureTarget;
    pub fn gst_gl_value_set_texture_target(
        value: *mut gobject::GValue,
        target: GstGLTextureTarget,
    ) -> gboolean;
    pub fn gst_gl_value_set_texture_target_from_mask(
        value: *mut gobject::GValue,
        target_mask: GstGLTextureTarget,
    ) -> gboolean;
    pub fn gst_gl_version_to_glsl_version(
        gl_api: GstGLAPI,
        maj: c_int,
        min: c_int,
    ) -> GstGLSLVersion;
    pub fn gst_glsl_string_get_version_profile(
        s: *const c_char,
        version: *mut GstGLSLVersion,
        profile: *mut GstGLSLProfile,
    ) -> gboolean;
    pub fn gst_is_gl_base_memory(mem: *mut gst::GstMemory) -> gboolean;
    pub fn gst_is_gl_buffer(mem: *mut gst::GstMemory) -> gboolean;
    pub fn gst_is_gl_memory(mem: *mut gst::GstMemory) -> gboolean;
    pub fn gst_is_gl_memory_pbo(mem: *mut gst::GstMemory) -> gboolean;
    pub fn gst_is_gl_renderbuffer(mem: *mut gst::GstMemory) -> gboolean;

}