1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
4// DO NOT EDIT
5
6#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use glib_sys as glib;
16use gobject_sys as gobject;
17use gstreamer_base_sys as gst_base;
18use gstreamer_sys as gst;
19use gstreamer_video_sys as gst_video;
20
21mod manual;
22
23pub use manual::*;
24
25#[cfg(unix)]
26#[allow(unused_imports)]
27use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
28#[allow(unused_imports)]
29use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
30#[allow(unused_imports)]
31use std::ffi::{
32 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
33};
34
35#[allow(unused_imports)]
36use glib::{gboolean, gconstpointer, gpointer, GType};
37
38// Enums
39pub type GstGLBaseMemoryError = c_int;
40pub const GST_GL_BASE_MEMORY_ERROR_FAILED: GstGLBaseMemoryError = 0;
41pub const GST_GL_BASE_MEMORY_ERROR_OLD_LIBS: GstGLBaseMemoryError = 1;
42pub const GST_GL_BASE_MEMORY_ERROR_RESOURCE_UNAVAILABLE: GstGLBaseMemoryError = 2;
43
44pub type GstGLConfigCaveat = c_int;
45pub const GST_GL_CONFIG_CAVEAT_NONE: GstGLConfigCaveat = 0;
46pub const GST_GL_CONFIG_CAVEAT_SLOW: GstGLConfigCaveat = 1;
47pub const GST_GL_CONFIG_CAVEAT_NON_CONFORMANT: GstGLConfigCaveat = 2;
48
49pub type GstGLContextError = c_int;
50pub const GST_GL_CONTEXT_ERROR_FAILED: GstGLContextError = 0;
51pub const GST_GL_CONTEXT_ERROR_WRONG_CONFIG: GstGLContextError = 1;
52pub const GST_GL_CONTEXT_ERROR_WRONG_API: GstGLContextError = 2;
53pub const GST_GL_CONTEXT_ERROR_OLD_LIBS: GstGLContextError = 3;
54pub const GST_GL_CONTEXT_ERROR_CREATE_CONTEXT: GstGLContextError = 4;
55pub const GST_GL_CONTEXT_ERROR_RESOURCE_UNAVAILABLE: GstGLContextError = 5;
56
57pub type GstGLFormat = c_int;
58pub const GST_GL_LUMINANCE: GstGLFormat = 6409;
59pub const GST_GL_ALPHA: GstGLFormat = 6406;
60pub const GST_GL_LUMINANCE_ALPHA: GstGLFormat = 6410;
61pub const GST_GL_RED: GstGLFormat = 6403;
62pub const GST_GL_R8: GstGLFormat = 33321;
63pub const GST_GL_RG: GstGLFormat = 33319;
64pub const GST_GL_RG8: GstGLFormat = 33323;
65pub const GST_GL_RGB: GstGLFormat = 6407;
66pub const GST_GL_RGB8: GstGLFormat = 32849;
67pub const GST_GL_RGB565: GstGLFormat = 36194;
68pub const GST_GL_RGB16: GstGLFormat = 32852;
69pub const GST_GL_RGBA: GstGLFormat = 6408;
70pub const GST_GL_RGBA8: GstGLFormat = 32856;
71pub const GST_GL_RGBA16: GstGLFormat = 32859;
72pub const GST_GL_DEPTH_COMPONENT16: GstGLFormat = 33189;
73pub const GST_GL_DEPTH24_STENCIL8: GstGLFormat = 35056;
74pub const GST_GL_RGB10_A2: GstGLFormat = 32857;
75pub const GST_GL_R16: GstGLFormat = 33322;
76pub const GST_GL_RG16: GstGLFormat = 33324;
77
78pub type GstGLQueryType = c_int;
79pub const GST_GL_QUERY_NONE: GstGLQueryType = 0;
80pub const GST_GL_QUERY_TIME_ELAPSED: GstGLQueryType = 1;
81pub const GST_GL_QUERY_TIMESTAMP: GstGLQueryType = 2;
82
83pub type GstGLSLError = c_int;
84pub const GST_GLSL_ERROR_COMPILE: GstGLSLError = 0;
85pub const GST_GLSL_ERROR_LINK: GstGLSLError = 1;
86pub const GST_GLSL_ERROR_PROGRAM: GstGLSLError = 2;
87
88pub type GstGLSLVersion = c_int;
89pub const GST_GLSL_VERSION_NONE: GstGLSLVersion = 0;
90pub const GST_GLSL_VERSION_100: GstGLSLVersion = 100;
91pub const GST_GLSL_VERSION_110: GstGLSLVersion = 110;
92pub const GST_GLSL_VERSION_120: GstGLSLVersion = 120;
93pub const GST_GLSL_VERSION_130: GstGLSLVersion = 130;
94pub const GST_GLSL_VERSION_140: GstGLSLVersion = 140;
95pub const GST_GLSL_VERSION_150: GstGLSLVersion = 150;
96pub const GST_GLSL_VERSION_300: GstGLSLVersion = 300;
97pub const GST_GLSL_VERSION_310: GstGLSLVersion = 310;
98pub const GST_GLSL_VERSION_320: GstGLSLVersion = 320;
99pub const GST_GLSL_VERSION_330: GstGLSLVersion = 330;
100pub const GST_GLSL_VERSION_400: GstGLSLVersion = 400;
101pub const GST_GLSL_VERSION_410: GstGLSLVersion = 410;
102pub const GST_GLSL_VERSION_420: GstGLSLVersion = 420;
103pub const GST_GLSL_VERSION_430: GstGLSLVersion = 430;
104pub const GST_GLSL_VERSION_440: GstGLSLVersion = 440;
105pub const GST_GLSL_VERSION_450: GstGLSLVersion = 450;
106
107pub type GstGLStereoDownmix = c_int;
108pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS: GstGLStereoDownmix = 0;
109pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_RED_CYAN_DUBOIS: GstGLStereoDownmix = 1;
110pub const GST_GL_STEREO_DOWNMIX_ANAGLYPH_AMBER_BLUE_DUBOIS: GstGLStereoDownmix = 2;
111
112pub type GstGLTextureTarget = c_int;
113pub const GST_GL_TEXTURE_TARGET_NONE: GstGLTextureTarget = 0;
114pub const GST_GL_TEXTURE_TARGET_2D: GstGLTextureTarget = 1;
115pub const GST_GL_TEXTURE_TARGET_RECTANGLE: GstGLTextureTarget = 2;
116pub const GST_GL_TEXTURE_TARGET_EXTERNAL_OES: GstGLTextureTarget = 3;
117
118pub type GstGLUploadReturn = c_int;
119pub const GST_GL_UPLOAD_DONE: GstGLUploadReturn = 1;
120pub const GST_GL_UPLOAD_ERROR: GstGLUploadReturn = -1;
121pub const GST_GL_UPLOAD_UNSUPPORTED: GstGLUploadReturn = -2;
122pub const GST_GL_UPLOAD_RECONFIGURE: GstGLUploadReturn = -3;
123pub const GST_GL_UPLOAD_UNSHARED_GL_CONTEXT: GstGLUploadReturn = -100;
124
125pub type GstGLWindowError = c_int;
126pub const GST_GL_WINDOW_ERROR_FAILED: GstGLWindowError = 0;
127pub const GST_GL_WINDOW_ERROR_OLD_LIBS: GstGLWindowError = 1;
128pub const GST_GL_WINDOW_ERROR_RESOURCE_UNAVAILABLE: GstGLWindowError = 2;
129
130// Constants
131pub const GST_BUFFER_POOL_OPTION_GL_SYNC_META: &[u8] = b"GstBufferPoolOptionGLSyncMeta\0";
132pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_2D: &[u8] =
133 b"GstBufferPoolOptionGLTextureTarget2D\0";
134pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_EXTERNAL_OES: &[u8] =
135 b"GstBufferPoolOptionGLTextureTargetExternalOES\0";
136pub const GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_RECTANGLE: &[u8] =
137 b"GstBufferPoolOptionGLTextureTargetRectangle\0";
138pub const GST_CAPS_FEATURE_MEMORY_GL_BUFFER: &[u8] = b"memory:GLBuffer\0";
139pub const GST_CAPS_FEATURE_MEMORY_GL_MEMORY: &[u8] = b"memory:GLMemory\0";
140pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_ALLOC: c_int = 1;
141pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_BUFFER: c_int = 16;
142pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_USER: c_int = 65536;
143pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_VIDEO: c_int = 8;
144pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_WRAP_GPU_HANDLE: c_int = 4;
145pub const GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_WRAP_SYSMEM: c_int = 2;
146pub const GST_GL_API_GLES1_NAME: &[u8] = b"gles1\0";
147pub const GST_GL_API_GLES2_NAME: &[u8] = b"gles2\0";
148pub const GST_GL_API_OPENGL3_NAME: &[u8] = b"opengl3\0";
149pub const GST_GL_API_OPENGL_NAME: &[u8] = b"opengl\0";
150pub const GST_GL_BASE_MEMORY_ALLOCATOR_NAME: &[u8] = b"GLBaseMemory\0";
151pub const GST_GL_BUFFER_ALLOCATOR_NAME: &[u8] = b"GLBuffer\0";
152pub const GST_GL_CONFIG_STRUCTURE_NAME: &[u8] = b"gst-gl-context-config\0";
153pub const GST_GL_CONTEXT_TYPE_CGL: &[u8] = b"gst.gl.context.CGL\0";
154pub const GST_GL_CONTEXT_TYPE_EAGL: &[u8] = b"gst.gl.context.EAGL\0";
155pub const GST_GL_CONTEXT_TYPE_EGL: &[u8] = b"gst.gl.context.EGL\0";
156pub const GST_GL_CONTEXT_TYPE_GLX: &[u8] = b"gst.gl.context.GLX\0";
157pub const GST_GL_CONTEXT_TYPE_WGL: &[u8] = b"gst.gl.context.WGL\0";
158pub const GST_GL_DISPLAY_CONTEXT_TYPE: &[u8] = b"gst.gl.GLDisplay\0";
159pub const GST_GL_MEMORY_ALLOCATOR_NAME: &[u8] = b"GLMemory\0";
160pub const GST_GL_MEMORY_PBO_ALLOCATOR_NAME: &[u8] = b"GLMemoryPBO\0";
161pub const GST_GL_RENDERBUFFER_ALLOCATOR_NAME: &[u8] = b"GLRenderbuffer\0";
162pub const GST_GL_TEXTURE_TARGET_2D_STR: &[u8] = b"2D\0";
163pub const GST_GL_TEXTURE_TARGET_EXTERNAL_OES_STR: &[u8] = b"external-oes\0";
164pub const GST_GL_TEXTURE_TARGET_RECTANGLE_STR: &[u8] = b"rectangle\0";
165pub const GST_MAP_GL: c_int = 131072;
166
167// Flags
168pub type GstGLAPI = c_uint;
169pub const GST_GL_API_NONE: GstGLAPI = 0;
170pub const GST_GL_API_OPENGL: GstGLAPI = 1;
171pub const GST_GL_API_OPENGL3: GstGLAPI = 2;
172pub const GST_GL_API_GLES1: GstGLAPI = 32768;
173pub const GST_GL_API_GLES2: GstGLAPI = 65536;
174pub const GST_GL_API_ANY: GstGLAPI = 4294967295;
175
176pub type GstGLBaseMemoryTransfer = c_uint;
177pub const GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD: GstGLBaseMemoryTransfer = 1048576;
178pub const GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD: GstGLBaseMemoryTransfer = 2097152;
179
180pub type GstGLConfigSurfaceType = c_uint;
181pub const GST_GL_CONFIG_SURFACE_TYPE_NONE: GstGLConfigSurfaceType = 0;
182pub const GST_GL_CONFIG_SURFACE_TYPE_WINDOW: GstGLConfigSurfaceType = 1;
183pub const GST_GL_CONFIG_SURFACE_TYPE_PBUFFER: GstGLConfigSurfaceType = 2;
184pub const GST_GL_CONFIG_SURFACE_TYPE_PIXMAP: GstGLConfigSurfaceType = 4;
185
186pub type GstGLDisplayType = c_uint;
187pub const GST_GL_DISPLAY_TYPE_NONE: GstGLDisplayType = 0;
188pub const GST_GL_DISPLAY_TYPE_X11: GstGLDisplayType = 1;
189pub const GST_GL_DISPLAY_TYPE_WAYLAND: GstGLDisplayType = 2;
190pub const GST_GL_DISPLAY_TYPE_COCOA: GstGLDisplayType = 4;
191pub const GST_GL_DISPLAY_TYPE_WIN32: GstGLDisplayType = 8;
192pub const GST_GL_DISPLAY_TYPE_DISPMANX: GstGLDisplayType = 16;
193pub const GST_GL_DISPLAY_TYPE_EGL: GstGLDisplayType = 32;
194pub const GST_GL_DISPLAY_TYPE_VIV_FB: GstGLDisplayType = 64;
195pub const GST_GL_DISPLAY_TYPE_GBM: GstGLDisplayType = 128;
196#[cfg(feature = "v1_18")]
197#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
198pub const GST_GL_DISPLAY_TYPE_EGL_DEVICE: GstGLDisplayType = 256;
199#[cfg(feature = "v1_20")]
200#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
201pub const GST_GL_DISPLAY_TYPE_EAGL: GstGLDisplayType = 512;
202#[cfg(feature = "v1_20")]
203#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
204pub const GST_GL_DISPLAY_TYPE_WINRT: GstGLDisplayType = 1024;
205#[cfg(feature = "v1_20")]
206#[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
207pub const GST_GL_DISPLAY_TYPE_ANDROID: GstGLDisplayType = 2048;
208#[cfg(feature = "v1_24")]
209#[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
210pub const GST_GL_DISPLAY_TYPE_EGL_SURFACELESS: GstGLDisplayType = 4096;
211pub const GST_GL_DISPLAY_TYPE_ANY: GstGLDisplayType = 4294967295;
212
213pub type GstGLDrmFormatFlags = c_uint;
214#[cfg(feature = "v1_26")]
215#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
216pub const GST_GL_DRM_FORMAT_INCLUDE_EXTERNAL: GstGLDrmFormatFlags = 1;
217#[cfg(feature = "v1_26")]
218#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
219pub const GST_GL_DRM_FORMAT_LINEAR_ONLY: GstGLDrmFormatFlags = 2;
220#[cfg(feature = "v1_26")]
221#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
222pub const GST_GL_DRM_FORMAT_INCLUDE_EMULATED: GstGLDrmFormatFlags = 4;
223
224pub type GstGLPlatform = c_uint;
225pub const GST_GL_PLATFORM_NONE: GstGLPlatform = 0;
226pub const GST_GL_PLATFORM_EGL: GstGLPlatform = 1;
227pub const GST_GL_PLATFORM_GLX: GstGLPlatform = 2;
228pub const GST_GL_PLATFORM_WGL: GstGLPlatform = 4;
229pub const GST_GL_PLATFORM_CGL: GstGLPlatform = 8;
230pub const GST_GL_PLATFORM_EAGL: GstGLPlatform = 16;
231pub const GST_GL_PLATFORM_ANY: GstGLPlatform = 4294967295;
232
233pub type GstGLSLProfile = c_uint;
234pub const GST_GLSL_PROFILE_NONE: GstGLSLProfile = 0;
235pub const GST_GLSL_PROFILE_ES: GstGLSLProfile = 1;
236pub const GST_GLSL_PROFILE_CORE: GstGLSLProfile = 2;
237pub const GST_GLSL_PROFILE_COMPATIBILITY: GstGLSLProfile = 4;
238pub const GST_GLSL_PROFILE_ANY: GstGLSLProfile = 4294967295;
239
240// Callbacks
241pub type GstGLAllocationParamsCopyFunc =
242 Option<unsafe extern "C" fn(*mut GstGLAllocationParams, *mut GstGLAllocationParams)>;
243pub type GstGLAllocationParamsFreeFunc = Option<unsafe extern "C" fn(gpointer)>;
244pub type GstGLAsyncDebugLogGetMessage = Option<unsafe extern "C" fn(gpointer) -> *mut c_char>;
245pub type GstGLBaseMemoryAllocatorAllocFunction = Option<
246 unsafe extern "C" fn(
247 *mut GstGLBaseMemoryAllocator,
248 *mut GstGLAllocationParams,
249 ) -> *mut GstGLBaseMemory,
250>;
251pub type GstGLBaseMemoryAllocatorCopyFunction =
252 Option<unsafe extern "C" fn(*mut GstGLBaseMemory, ssize_t, ssize_t) -> *mut GstGLBaseMemory>;
253pub type GstGLBaseMemoryAllocatorCreateFunction =
254 Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut *mut glib::GError) -> gboolean>;
255pub type GstGLBaseMemoryAllocatorDestroyFunction =
256 Option<unsafe extern "C" fn(*mut GstGLBaseMemory)>;
257pub type GstGLBaseMemoryAllocatorMapFunction =
258 Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut gst::GstMapInfo, size_t) -> gpointer>;
259pub type GstGLBaseMemoryAllocatorUnmapFunction =
260 Option<unsafe extern "C" fn(*mut GstGLBaseMemory, *mut gst::GstMapInfo)>;
261pub type GstGLContextThreadFunc = Option<unsafe extern "C" fn(*mut GstGLContext, gpointer)>;
262pub type GstGLFilterRenderFunc =
263 Option<unsafe extern "C" fn(*mut GstGLFilter, *mut GstGLMemory, gpointer) -> gboolean>;
264pub type GstGLFramebufferFunc = Option<unsafe extern "C" fn(gpointer) -> gboolean>;
265pub type GstGLWindowCB = Option<unsafe extern "C" fn(gpointer)>;
266pub type GstGLWindowResizeCB = Option<unsafe extern "C" fn(gpointer, c_uint, c_uint)>;
267
268// Records
269#[derive(Copy, Clone)]
270#[repr(C)]
271pub struct GstGLAllocationParams {
272 pub struct_size: size_t,
273 pub copy: GstGLAllocationParamsCopyFunc,
274 pub free: GstGLAllocationParamsFreeFunc,
275 pub alloc_flags: c_uint,
276 pub alloc_size: size_t,
277 pub alloc_params: *mut gst::GstAllocationParams,
278 pub context: *mut GstGLContext,
279 pub notify: glib::GDestroyNotify,
280 pub user_data: gpointer,
281 pub wrapped_data: gpointer,
282 pub gl_handle: gpointer,
283 pub _padding: [gpointer; 4],
284}
285
286impl ::std::fmt::Debug for GstGLAllocationParams {
287 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
288 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLAllocationParams @ {self:p}"))
289 .field("struct_size", &self.struct_size)
290 .field("copy", &self.copy)
291 .field("free", &self.free)
292 .field("alloc_flags", &self.alloc_flags)
293 .field("alloc_size", &self.alloc_size)
294 .field("alloc_params", &self.alloc_params)
295 .field("context", &self.context)
296 .field("notify", &self.notify)
297 .field("user_data", &self.user_data)
298 .field("wrapped_data", &self.wrapped_data)
299 .field(name:"gl_handle", &self.gl_handle)
300 .finish()
301 }
302}
303
304#[derive(Copy, Clone)]
305#[repr(C)]
306pub struct GstGLAsyncDebug {
307 pub state_flags: c_uint,
308 pub cat: *mut gst::GstDebugCategory,
309 pub level: gst::GstDebugLevel,
310 pub file: *const c_char,
311 pub function: *const c_char,
312 pub line: c_int,
313 pub object: *mut gobject::GObject,
314 pub debug_msg: *mut c_char,
315 pub callback: GstGLAsyncDebugLogGetMessage,
316 pub user_data: gpointer,
317 pub notify: glib::GDestroyNotify,
318 pub _padding: [gpointer; 4],
319}
320
321impl ::std::fmt::Debug for GstGLAsyncDebug {
322 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
323 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLAsyncDebug @ {self:p}"))
324 .finish()
325 }
326}
327
328#[derive(Copy, Clone)]
329#[repr(C)]
330pub struct GstGLBaseFilterClass {
331 pub parent_class: gst_base::GstBaseTransformClass,
332 pub supported_gl_api: GstGLAPI,
333 pub gl_start: Option<unsafe extern "C" fn(*mut GstGLBaseFilter) -> gboolean>,
334 pub gl_stop: Option<unsafe extern "C" fn(*mut GstGLBaseFilter)>,
335 pub gl_set_caps: Option<
336 unsafe extern "C" fn(
337 *mut GstGLBaseFilter,
338 *mut gst::GstCaps,
339 *mut gst::GstCaps,
340 ) -> gboolean,
341 >,
342 pub _padding: [gpointer; 4],
343}
344
345impl ::std::fmt::Debug for GstGLBaseFilterClass {
346 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
347 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseFilterClass @ {self:p}"))
348 .field("parent_class", &self.parent_class)
349 .field("supported_gl_api", &self.supported_gl_api)
350 .field("gl_start", &self.gl_start)
351 .field("gl_stop", &self.gl_stop)
352 .field(name:"gl_set_caps", &self.gl_set_caps)
353 .finish()
354 }
355}
356
357#[repr(C)]
358#[allow(dead_code)]
359pub struct _GstGLBaseFilterPrivate {
360 _data: [u8; 0],
361 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
362}
363
364pub type GstGLBaseFilterPrivate = _GstGLBaseFilterPrivate;
365
366#[derive(Copy, Clone)]
367#[repr(C)]
368pub struct GstGLBaseMemory {
369 pub mem: gst::GstMemory,
370 pub context: *mut GstGLContext,
371 pub lock: glib::GMutex,
372 pub map_flags: gst::GstMapFlags,
373 pub map_count: c_int,
374 pub gl_map_count: c_int,
375 pub data: gpointer,
376 pub query: *mut GstGLQuery,
377 pub alloc_size: size_t,
378 pub alloc_data: gpointer,
379 pub notify: glib::GDestroyNotify,
380 pub user_data: gpointer,
381 pub _padding: [gpointer; 4],
382}
383
384impl ::std::fmt::Debug for GstGLBaseMemory {
385 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
386 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseMemory @ {self:p}"))
387 .field("mem", &self.mem)
388 .field("context", &self.context)
389 .field("lock", &self.lock)
390 .field("map_flags", &self.map_flags)
391 .field("map_count", &self.map_count)
392 .field("gl_map_count", &self.gl_map_count)
393 .field("data", &self.data)
394 .field(name:"query", &self.query)
395 .finish()
396 }
397}
398
399#[derive(Copy, Clone)]
400#[repr(C)]
401pub struct GstGLBaseMemoryAllocatorClass {
402 pub parent_class: gst::GstAllocatorClass,
403 pub alloc: GstGLBaseMemoryAllocatorAllocFunction,
404 pub create: GstGLBaseMemoryAllocatorCreateFunction,
405 pub map: GstGLBaseMemoryAllocatorMapFunction,
406 pub unmap: GstGLBaseMemoryAllocatorUnmapFunction,
407 pub copy: GstGLBaseMemoryAllocatorCopyFunction,
408 pub destroy: GstGLBaseMemoryAllocatorDestroyFunction,
409 pub _padding: [gpointer; 4],
410}
411
412impl ::std::fmt::Debug for GstGLBaseMemoryAllocatorClass {
413 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
414 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseMemoryAllocatorClass @ {self:p}"))
415 .field("parent_class", &self.parent_class)
416 .field("alloc", &self.alloc)
417 .field("create", &self.create)
418 .field("map", &self.map)
419 .field("unmap", &self.unmap)
420 .field("copy", &self.copy)
421 .field(name:"destroy", &self.destroy)
422 .finish()
423 }
424}
425
426#[derive(Copy, Clone)]
427#[repr(C)]
428pub struct GstGLBaseMixerClass {
429 pub parent_class: gst_video::GstVideoAggregatorClass,
430 pub supported_gl_api: GstGLAPI,
431 pub gl_start: Option<unsafe extern "C" fn(*mut GstGLBaseMixer) -> gboolean>,
432 pub gl_stop: Option<unsafe extern "C" fn(*mut GstGLBaseMixer)>,
433 pub _padding: [gpointer; 4],
434}
435
436impl ::std::fmt::Debug for GstGLBaseMixerClass {
437 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
438 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseMixerClass @ {self:p}"))
439 .field("parent_class", &self.parent_class)
440 .field("supported_gl_api", &self.supported_gl_api)
441 .field("gl_start", &self.gl_start)
442 .field(name:"gl_stop", &self.gl_stop)
443 .finish()
444 }
445}
446
447#[derive(Copy, Clone)]
448#[repr(C)]
449pub struct GstGLBaseMixerPadClass {
450 pub parent_class: gst_video::GstVideoAggregatorPadClass,
451 pub _padding: [gpointer; 4],
452}
453
454impl ::std::fmt::Debug for GstGLBaseMixerPadClass {
455 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
456 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseMixerPadClass @ {self:p}"))
457 .field(name:"parent_class", &self.parent_class)
458 .finish()
459 }
460}
461
462#[repr(C)]
463#[allow(dead_code)]
464pub struct _GstGLBaseMixerPrivate {
465 _data: [u8; 0],
466 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
467}
468
469pub type GstGLBaseMixerPrivate = _GstGLBaseMixerPrivate;
470
471#[derive(Copy, Clone)]
472#[repr(C)]
473pub struct GstGLBaseSrcClass {
474 pub parent_class: gst_base::GstPushSrcClass,
475 pub supported_gl_api: GstGLAPI,
476 pub gl_start: Option<unsafe extern "C" fn(*mut GstGLBaseSrc) -> gboolean>,
477 pub gl_stop: Option<unsafe extern "C" fn(*mut GstGLBaseSrc)>,
478 pub fill_gl_memory:
479 Option<unsafe extern "C" fn(*mut GstGLBaseSrc, *mut GstGLMemory) -> gboolean>,
480 pub _padding: [gpointer; 4],
481}
482
483impl ::std::fmt::Debug for GstGLBaseSrcClass {
484 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
485 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseSrcClass @ {self:p}"))
486 .field("parent_class", &self.parent_class)
487 .field("supported_gl_api", &self.supported_gl_api)
488 .field("gl_start", &self.gl_start)
489 .field("gl_stop", &self.gl_stop)
490 .field(name:"fill_gl_memory", &self.fill_gl_memory)
491 .finish()
492 }
493}
494
495#[repr(C)]
496#[allow(dead_code)]
497pub struct _GstGLBaseSrcPrivate {
498 _data: [u8; 0],
499 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
500}
501
502pub type GstGLBaseSrcPrivate = _GstGLBaseSrcPrivate;
503
504#[derive(Copy, Clone)]
505#[repr(C)]
506pub struct GstGLBuffer {
507 pub mem: GstGLBaseMemory,
508 pub id: c_uint,
509 pub target: c_uint,
510 pub usage_hints: c_uint,
511}
512
513impl ::std::fmt::Debug for GstGLBuffer {
514 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
515 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBuffer @ {self:p}"))
516 .field("mem", &self.mem)
517 .field("id", &self.id)
518 .field("target", &self.target)
519 .field(name:"usage_hints", &self.usage_hints)
520 .finish()
521 }
522}
523
524#[derive(Copy, Clone)]
525#[repr(C)]
526pub struct GstGLBufferAllocationParams {
527 pub parent: GstGLAllocationParams,
528 pub gl_target: c_uint,
529 pub gl_usage: c_uint,
530 pub _padding: [gpointer; 4],
531}
532
533impl ::std::fmt::Debug for GstGLBufferAllocationParams {
534 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
535 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBufferAllocationParams @ {self:p}"))
536 .field("parent", &self.parent)
537 .field("gl_target", &self.gl_target)
538 .field(name:"gl_usage", &self.gl_usage)
539 .finish()
540 }
541}
542
543#[derive(Copy, Clone)]
544#[repr(C)]
545pub struct GstGLBufferAllocatorClass {
546 pub parent_class: GstGLBaseMemoryAllocatorClass,
547 pub _padding: [gpointer; 4],
548}
549
550impl ::std::fmt::Debug for GstGLBufferAllocatorClass {
551 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
552 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBufferAllocatorClass @ {self:p}"))
553 .field(name:"parent_class", &self.parent_class)
554 .finish()
555 }
556}
557
558#[derive(Copy, Clone)]
559#[repr(C)]
560pub struct GstGLBufferPoolClass {
561 pub parent_class: gst::GstBufferPoolClass,
562 pub _padding: [gpointer; 4],
563}
564
565impl ::std::fmt::Debug for GstGLBufferPoolClass {
566 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
567 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBufferPoolClass @ {self:p}"))
568 .field(name:"parent_class", &self.parent_class)
569 .finish()
570 }
571}
572
573#[repr(C)]
574#[allow(dead_code)]
575pub struct _GstGLBufferPoolPrivate {
576 _data: [u8; 0],
577 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
578}
579
580pub type GstGLBufferPoolPrivate = _GstGLBufferPoolPrivate;
581
582#[derive(Copy, Clone)]
583#[repr(C)]
584pub struct GstGLColorConvertClass {
585 pub object_class: gst::GstObjectClass,
586 pub _padding: [gpointer; 4],
587}
588
589impl ::std::fmt::Debug for GstGLColorConvertClass {
590 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
591 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLColorConvertClass @ {self:p}"))
592 .finish()
593 }
594}
595
596#[repr(C)]
597#[allow(dead_code)]
598pub struct _GstGLColorConvertPrivate {
599 _data: [u8; 0],
600 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
601}
602
603pub type GstGLColorConvertPrivate = _GstGLColorConvertPrivate;
604
605#[derive(Copy, Clone)]
606#[repr(C)]
607pub struct GstGLContextClass {
608 pub parent_class: gst::GstObjectClass,
609 pub get_current_context: Option<unsafe extern "C" fn() -> uintptr_t>,
610 pub get_gl_context: Option<unsafe extern "C" fn(*mut GstGLContext) -> uintptr_t>,
611 pub get_gl_api: Option<unsafe extern "C" fn(*mut GstGLContext) -> GstGLAPI>,
612 pub get_gl_platform: Option<unsafe extern "C" fn(*mut GstGLContext) -> GstGLPlatform>,
613 pub get_proc_address: Option<unsafe extern "C" fn(GstGLAPI, *const c_char) -> gpointer>,
614 pub activate: Option<unsafe extern "C" fn(*mut GstGLContext, gboolean) -> gboolean>,
615 pub choose_format:
616 Option<unsafe extern "C" fn(*mut GstGLContext, *mut *mut glib::GError) -> gboolean>,
617 pub create_context: Option<
618 unsafe extern "C" fn(
619 *mut GstGLContext,
620 GstGLAPI,
621 *mut GstGLContext,
622 *mut *mut glib::GError,
623 ) -> gboolean,
624 >,
625 pub destroy_context: Option<unsafe extern "C" fn(*mut GstGLContext)>,
626 pub swap_buffers: Option<unsafe extern "C" fn(*mut GstGLContext)>,
627 pub check_feature: Option<unsafe extern "C" fn(*mut GstGLContext, *const c_char) -> gboolean>,
628 pub get_gl_platform_version:
629 Option<unsafe extern "C" fn(*mut GstGLContext, *mut c_int, *mut c_int)>,
630 pub get_config: Option<unsafe extern "C" fn(*mut GstGLContext) -> *mut gst::GstStructure>,
631 pub request_config:
632 Option<unsafe extern "C" fn(*mut GstGLContext, *mut gst::GstStructure) -> gboolean>,
633 pub _reserved: [gpointer; 2],
634}
635
636impl ::std::fmt::Debug for GstGLContextClass {
637 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
638 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLContextClass @ {self:p}"))
639 .field("parent_class", &self.parent_class)
640 .field("get_current_context", &self.get_current_context)
641 .field("get_gl_context", &self.get_gl_context)
642 .field("get_gl_api", &self.get_gl_api)
643 .field("get_gl_platform", &self.get_gl_platform)
644 .field("get_proc_address", &self.get_proc_address)
645 .field("activate", &self.activate)
646 .field("choose_format", &self.choose_format)
647 .field("create_context", &self.create_context)
648 .field("destroy_context", &self.destroy_context)
649 .field("swap_buffers", &self.swap_buffers)
650 .field("check_feature", &self.check_feature)
651 .field("get_gl_platform_version", &self.get_gl_platform_version)
652 .field("get_config", &self.get_config)
653 .field(name:"request_config", &self.request_config)
654 .finish()
655 }
656}
657
658#[repr(C)]
659#[allow(dead_code)]
660pub struct _GstGLContextPrivate {
661 _data: [u8; 0],
662 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
663}
664
665pub type GstGLContextPrivate = _GstGLContextPrivate;
666
667#[derive(Copy, Clone)]
668#[repr(C)]
669pub struct GstGLDisplayClass {
670 pub object_class: gst::GstObjectClass,
671 pub get_handle: Option<unsafe extern "C" fn(*mut GstGLDisplay) -> uintptr_t>,
672 pub create_window: Option<unsafe extern "C" fn(*mut GstGLDisplay) -> *mut GstGLWindow>,
673 pub _padding: [gpointer; 4],
674}
675
676impl ::std::fmt::Debug for GstGLDisplayClass {
677 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
678 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLDisplayClass @ {self:p}"))
679 .field("object_class", &self.object_class)
680 .field("get_handle", &self.get_handle)
681 .field(name:"create_window", &self.create_window)
682 .finish()
683 }
684}
685
686#[repr(C)]
687#[allow(dead_code)]
688pub struct _GstGLDisplayPrivate {
689 _data: [u8; 0],
690 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
691}
692
693pub type GstGLDisplayPrivate = _GstGLDisplayPrivate;
694
695#[derive(Copy, Clone)]
696#[repr(C)]
697pub struct GstGLFilterClass {
698 pub parent_class: GstGLBaseFilterClass,
699 pub set_caps: Option<
700 unsafe extern "C" fn(*mut GstGLFilter, *mut gst::GstCaps, *mut gst::GstCaps) -> gboolean,
701 >,
702 pub filter: Option<
703 unsafe extern "C" fn(
704 *mut GstGLFilter,
705 *mut gst::GstBuffer,
706 *mut gst::GstBuffer,
707 ) -> gboolean,
708 >,
709 pub filter_texture: Option<
710 unsafe extern "C" fn(*mut GstGLFilter, *mut GstGLMemory, *mut GstGLMemory) -> gboolean,
711 >,
712 pub init_fbo: Option<unsafe extern "C" fn(*mut GstGLFilter) -> gboolean>,
713 pub transform_internal_caps: Option<
714 unsafe extern "C" fn(
715 *mut GstGLFilter,
716 gst::GstPadDirection,
717 *mut gst::GstCaps,
718 *mut gst::GstCaps,
719 ) -> *mut gst::GstCaps,
720 >,
721 pub _padding: [gpointer; 4],
722}
723
724impl ::std::fmt::Debug for GstGLFilterClass {
725 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
726 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLFilterClass @ {self:p}"))
727 .field("parent_class", &self.parent_class)
728 .field("set_caps", &self.set_caps)
729 .field("filter", &self.filter)
730 .field("filter_texture", &self.filter_texture)
731 .field("init_fbo", &self.init_fbo)
732 .field(name:"transform_internal_caps", &self.transform_internal_caps)
733 .finish()
734 }
735}
736
737#[derive(Copy, Clone)]
738#[repr(C)]
739pub struct GstGLFramebufferClass {
740 pub object_class: gst::GstObjectClass,
741 pub _padding: [gpointer; 4],
742}
743
744impl ::std::fmt::Debug for GstGLFramebufferClass {
745 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
746 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLFramebufferClass @ {self:p}"))
747 .finish()
748 }
749}
750
751#[repr(C)]
752#[allow(dead_code)]
753pub struct _GstGLFramebufferPrivate {
754 _data: [u8; 0],
755 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
756}
757
758pub type GstGLFramebufferPrivate = _GstGLFramebufferPrivate;
759
760#[repr(C)]
761#[allow(dead_code)]
762pub struct _GstGLFuncs {
763 _data: [u8; 0],
764 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
765}
766
767pub type GstGLFuncs = _GstGLFuncs;
768
769#[derive(Copy, Clone)]
770#[repr(C)]
771pub struct GstGLMemory {
772 pub mem: GstGLBaseMemory,
773 pub tex_id: c_uint,
774 pub tex_target: GstGLTextureTarget,
775 pub tex_format: GstGLFormat,
776 pub info: gst_video::GstVideoInfo,
777 pub valign: gst_video::GstVideoAlignment,
778 pub plane: c_uint,
779 pub tex_scaling: [c_float; 2],
780 pub texture_wrapped: gboolean,
781 pub unpack_length: c_uint,
782 pub tex_width: c_uint,
783 pub _padding: [gpointer; 4],
784}
785
786impl ::std::fmt::Debug for GstGLMemory {
787 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
788 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLMemory @ {self:p}"))
789 .field("mem", &self.mem)
790 .field("tex_id", &self.tex_id)
791 .field("tex_target", &self.tex_target)
792 .field("tex_format", &self.tex_format)
793 .field("info", &self.info)
794 .field("valign", &self.valign)
795 .field("plane", &self.plane)
796 .field("tex_scaling", &self.tex_scaling)
797 .field("texture_wrapped", &self.texture_wrapped)
798 .field("unpack_length", &self.unpack_length)
799 .field(name:"tex_width", &self.tex_width)
800 .finish()
801 }
802}
803
804#[derive(Copy, Clone)]
805#[repr(C)]
806pub struct GstGLMemoryAllocatorClass {
807 pub parent_class: GstGLBaseMemoryAllocatorClass,
808 pub map: GstGLBaseMemoryAllocatorMapFunction,
809 pub copy: GstGLBaseMemoryAllocatorCopyFunction,
810 pub unmap: GstGLBaseMemoryAllocatorUnmapFunction,
811 pub _padding: [gpointer; 4],
812}
813
814impl ::std::fmt::Debug for GstGLMemoryAllocatorClass {
815 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
816 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLMemoryAllocatorClass @ {self:p}"))
817 .field("map", &self.map)
818 .field("copy", &self.copy)
819 .field(name:"unmap", &self.unmap)
820 .finish()
821 }
822}
823
824#[derive(Copy, Clone)]
825#[repr(C)]
826pub struct GstGLMemoryPBO {
827 pub mem: GstGLMemory,
828 pub pbo: *mut GstGLBuffer,
829 pub _padding: [gpointer; 4],
830}
831
832impl ::std::fmt::Debug for GstGLMemoryPBO {
833 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
834 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLMemoryPBO @ {self:p}"))
835 .finish()
836 }
837}
838
839#[derive(Copy, Clone)]
840#[repr(C)]
841pub struct GstGLMemoryPBOAllocatorClass {
842 pub parent_class: GstGLMemoryAllocatorClass,
843 pub _padding: [gpointer; 4],
844}
845
846impl ::std::fmt::Debug for GstGLMemoryPBOAllocatorClass {
847 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
848 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLMemoryPBOAllocatorClass @ {self:p}"))
849 .field(name:"parent_class", &self.parent_class)
850 .finish()
851 }
852}
853
854#[derive(Copy, Clone)]
855#[repr(C)]
856pub struct GstGLMixerClass {
857 pub parent_class: GstGLBaseMixerClass,
858 pub process_buffers:
859 Option<unsafe extern "C" fn(*mut GstGLMixer, *mut gst::GstBuffer) -> gboolean>,
860 pub process_textures:
861 Option<unsafe extern "C" fn(*mut GstGLMixer, *mut GstGLMemory) -> gboolean>,
862 pub _padding: [gpointer; 4],
863}
864
865impl ::std::fmt::Debug for GstGLMixerClass {
866 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
867 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLMixerClass @ {self:p}"))
868 .field("parent_class", &self.parent_class)
869 .field("process_buffers", &self.process_buffers)
870 .field(name:"process_textures", &self.process_textures)
871 .finish()
872 }
873}
874
875#[derive(Copy, Clone)]
876#[repr(C)]
877pub struct GstGLMixerPadClass {
878 pub parent_class: GstGLBaseMixerPadClass,
879 pub _padding: [gpointer; 4],
880}
881
882impl ::std::fmt::Debug for GstGLMixerPadClass {
883 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
884 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLMixerPadClass @ {self:p}"))
885 .field(name:"parent_class", &self.parent_class)
886 .finish()
887 }
888}
889
890#[repr(C)]
891#[allow(dead_code)]
892pub struct _GstGLMixerPrivate {
893 _data: [u8; 0],
894 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
895}
896
897pub type GstGLMixerPrivate = _GstGLMixerPrivate;
898
899#[derive(Copy, Clone)]
900#[repr(C)]
901pub struct GstGLOverlayCompositorClass {
902 pub object_class: gst::GstObjectClass,
903 pub _padding: [gpointer; 4],
904}
905
906impl ::std::fmt::Debug for GstGLOverlayCompositorClass {
907 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
908 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLOverlayCompositorClass @ {self:p}"))
909 .field(name:"object_class", &self.object_class)
910 .finish()
911 }
912}
913
914#[derive(Copy, Clone)]
915#[repr(C)]
916pub struct GstGLQuery {
917 pub context: *mut GstGLContext,
918 pub query_type: c_uint,
919 pub query_id: c_uint,
920 pub supported: gboolean,
921 pub start_called: gboolean,
922 pub debug: GstGLAsyncDebug,
923 pub _padding: [gpointer; 4],
924}
925
926impl ::std::fmt::Debug for GstGLQuery {
927 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
928 f.debug_struct(&format!("GstGLQuery @ {self:p}")).finish()
929 }
930}
931
932#[derive(Copy, Clone)]
933#[repr(C)]
934pub struct GstGLRenderbuffer {
935 pub mem: GstGLBaseMemory,
936 pub renderbuffer_id: c_uint,
937 pub renderbuffer_format: GstGLFormat,
938 pub width: c_uint,
939 pub height: c_uint,
940 pub renderbuffer_wrapped: gboolean,
941 pub _padding: [gpointer; 4],
942}
943
944impl ::std::fmt::Debug for GstGLRenderbuffer {
945 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
946 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLRenderbuffer @ {self:p}"))
947 .field("renderbuffer_id", &self.renderbuffer_id)
948 .field("renderbuffer_format", &self.renderbuffer_format)
949 .field("width", &self.width)
950 .field("height", &self.height)
951 .field(name:"renderbuffer_wrapped", &self.renderbuffer_wrapped)
952 .finish()
953 }
954}
955
956#[derive(Copy, Clone)]
957#[repr(C)]
958pub struct GstGLRenderbufferAllocationParams {
959 pub parent: GstGLAllocationParams,
960 pub renderbuffer_format: GstGLFormat,
961 pub width: c_uint,
962 pub height: c_uint,
963 pub _padding: [gpointer; 4],
964}
965
966impl ::std::fmt::Debug for GstGLRenderbufferAllocationParams {
967 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
968 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLRenderbufferAllocationParams @ {self:p}"))
969 .field("renderbuffer_format", &self.renderbuffer_format)
970 .field("width", &self.width)
971 .field(name:"height", &self.height)
972 .finish()
973 }
974}
975
976#[derive(Copy, Clone)]
977#[repr(C)]
978pub struct GstGLRenderbufferAllocatorClass {
979 pub parent_class: GstGLBaseMemoryAllocatorClass,
980 pub _padding: [gpointer; 4],
981}
982
983impl ::std::fmt::Debug for GstGLRenderbufferAllocatorClass {
984 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
985 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLRenderbufferAllocatorClass @ {self:p}"))
986 .field(name:"parent_class", &self.parent_class)
987 .finish()
988 }
989}
990
991#[derive(Copy, Clone)]
992#[repr(C)]
993pub struct GstGLSLStageClass {
994 pub parent: gst::GstObjectClass,
995 pub _padding: [gpointer; 4],
996}
997
998impl ::std::fmt::Debug for GstGLSLStageClass {
999 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1000 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLSLStageClass @ {self:p}"))
1001 .finish()
1002 }
1003}
1004
1005#[repr(C)]
1006#[allow(dead_code)]
1007pub struct _GstGLSLStagePrivate {
1008 _data: [u8; 0],
1009 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1010}
1011
1012pub type GstGLSLStagePrivate = _GstGLSLStagePrivate;
1013
1014#[derive(Copy, Clone)]
1015#[repr(C)]
1016pub struct GstGLShaderClass {
1017 pub parent_class: gst::GstObjectClass,
1018}
1019
1020impl ::std::fmt::Debug for GstGLShaderClass {
1021 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1022 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLShaderClass @ {self:p}"))
1023 .finish()
1024 }
1025}
1026
1027#[repr(C)]
1028#[allow(dead_code)]
1029pub struct _GstGLShaderPrivate {
1030 _data: [u8; 0],
1031 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1032}
1033
1034pub type GstGLShaderPrivate = _GstGLShaderPrivate;
1035
1036#[derive(Copy, Clone)]
1037#[repr(C)]
1038pub struct GstGLSyncMeta {
1039 pub parent: gst::GstMeta,
1040 pub context: *mut GstGLContext,
1041 pub data: gpointer,
1042 pub set_sync: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
1043 pub set_sync_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
1044 pub wait: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
1045 pub wait_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
1046 pub wait_cpu: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
1047 pub wait_cpu_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
1048 pub copy: Option<
1049 unsafe extern "C" fn(
1050 *mut GstGLSyncMeta,
1051 *mut gst::GstBuffer,
1052 *mut GstGLSyncMeta,
1053 *mut gst::GstBuffer,
1054 ),
1055 >,
1056 pub free: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
1057 pub free_gl: Option<unsafe extern "C" fn(*mut GstGLSyncMeta, *mut GstGLContext)>,
1058}
1059
1060impl ::std::fmt::Debug for GstGLSyncMeta {
1061 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1062 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLSyncMeta @ {self:p}"))
1063 .field("parent", &self.parent)
1064 .field("context", &self.context)
1065 .field("data", &self.data)
1066 .field("set_sync", &self.set_sync)
1067 .field("set_sync_gl", &self.set_sync_gl)
1068 .field("wait", &self.wait)
1069 .field("wait_gl", &self.wait_gl)
1070 .field("wait_cpu", &self.wait_cpu)
1071 .field("wait_cpu_gl", &self.wait_cpu_gl)
1072 .field("copy", &self.copy)
1073 .field("free", &self.free)
1074 .field(name:"free_gl", &self.free_gl)
1075 .finish()
1076 }
1077}
1078
1079#[derive(Copy, Clone)]
1080#[repr(C)]
1081pub struct GstGLUploadClass {
1082 pub object_class: gst::GstObjectClass,
1083 pub _padding: [gpointer; 4],
1084}
1085
1086impl ::std::fmt::Debug for GstGLUploadClass {
1087 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1088 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLUploadClass @ {self:p}"))
1089 .field(name:"object_class", &self.object_class)
1090 .finish()
1091 }
1092}
1093
1094#[repr(C)]
1095#[allow(dead_code)]
1096pub struct _GstGLUploadPrivate {
1097 _data: [u8; 0],
1098 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1099}
1100
1101pub type GstGLUploadPrivate = _GstGLUploadPrivate;
1102
1103#[derive(Copy, Clone)]
1104#[repr(C)]
1105pub struct GstGLVideoAllocationParams {
1106 pub parent: GstGLAllocationParams,
1107 pub v_info: *mut gst_video::GstVideoInfo,
1108 pub plane: c_uint,
1109 pub valign: *mut gst_video::GstVideoAlignment,
1110 pub target: GstGLTextureTarget,
1111 pub tex_format: GstGLFormat,
1112 pub _padding: [gpointer; 4],
1113}
1114
1115impl ::std::fmt::Debug for GstGLVideoAllocationParams {
1116 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1117 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLVideoAllocationParams @ {self:p}"))
1118 .field("parent", &self.parent)
1119 .field("v_info", &self.v_info)
1120 .field("plane", &self.plane)
1121 .field("valign", &self.valign)
1122 .field("target", &self.target)
1123 .field(name:"tex_format", &self.tex_format)
1124 .finish()
1125 }
1126}
1127
1128#[derive(Copy, Clone)]
1129#[repr(C)]
1130pub struct GstGLViewConvertClass {
1131 pub object_class: gst::GstObjectClass,
1132 pub _padding: [gpointer; 4],
1133}
1134
1135impl ::std::fmt::Debug for GstGLViewConvertClass {
1136 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1137 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLViewConvertClass @ {self:p}"))
1138 .finish()
1139 }
1140}
1141
1142#[repr(C)]
1143#[allow(dead_code)]
1144pub struct _GstGLViewConvertPrivate {
1145 _data: [u8; 0],
1146 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1147}
1148
1149pub type GstGLViewConvertPrivate = _GstGLViewConvertPrivate;
1150
1151#[derive(Copy, Clone)]
1152#[repr(C)]
1153pub struct GstGLWindowClass {
1154 pub parent_class: gst::GstObjectClass,
1155 pub get_display: Option<unsafe extern "C" fn(*mut GstGLWindow) -> uintptr_t>,
1156 pub set_window_handle: Option<unsafe extern "C" fn(*mut GstGLWindow, uintptr_t)>,
1157 pub get_window_handle: Option<unsafe extern "C" fn(*mut GstGLWindow) -> uintptr_t>,
1158 pub draw: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
1159 pub run: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
1160 pub quit: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
1161 pub send_message: Option<unsafe extern "C" fn(*mut GstGLWindow, GstGLWindowCB, gpointer)>,
1162 pub send_message_async: Option<
1163 unsafe extern "C" fn(*mut GstGLWindow, GstGLWindowCB, gpointer, glib::GDestroyNotify),
1164 >,
1165 pub open: Option<unsafe extern "C" fn(*mut GstGLWindow, *mut *mut glib::GError) -> gboolean>,
1166 pub close: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
1167 pub handle_events: Option<unsafe extern "C" fn(*mut GstGLWindow, gboolean)>,
1168 pub set_preferred_size: Option<unsafe extern "C" fn(*mut GstGLWindow, c_int, c_int)>,
1169 pub show: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
1170 pub set_render_rectangle:
1171 Option<unsafe extern "C" fn(*mut GstGLWindow, c_int, c_int, c_int, c_int) -> gboolean>,
1172 pub queue_resize: Option<unsafe extern "C" fn(*mut GstGLWindow)>,
1173 pub controls_viewport: Option<unsafe extern "C" fn(*mut GstGLWindow) -> gboolean>,
1174 pub has_output_surface: Option<unsafe extern "C" fn(*mut GstGLWindow) -> gboolean>,
1175 pub _reserved: [gpointer; 2],
1176}
1177
1178impl ::std::fmt::Debug for GstGLWindowClass {
1179 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1180 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLWindowClass @ {self:p}"))
1181 .field("parent_class", &self.parent_class)
1182 .field("get_display", &self.get_display)
1183 .field("set_window_handle", &self.set_window_handle)
1184 .field("get_window_handle", &self.get_window_handle)
1185 .field("draw", &self.draw)
1186 .field("run", &self.run)
1187 .field("quit", &self.quit)
1188 .field("send_message", &self.send_message)
1189 .field("send_message_async", &self.send_message_async)
1190 .field("open", &self.open)
1191 .field("close", &self.close)
1192 .field("handle_events", &self.handle_events)
1193 .field("set_preferred_size", &self.set_preferred_size)
1194 .field("show", &self.show)
1195 .field("set_render_rectangle", &self.set_render_rectangle)
1196 .field("queue_resize", &self.queue_resize)
1197 .field("controls_viewport", &self.controls_viewport)
1198 .field(name:"has_output_surface", &self.has_output_surface)
1199 .finish()
1200 }
1201}
1202
1203#[repr(C)]
1204#[allow(dead_code)]
1205pub struct _GstGLWindowPrivate {
1206 _data: [u8; 0],
1207 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1208}
1209
1210pub type GstGLWindowPrivate = _GstGLWindowPrivate;
1211
1212// Classes
1213#[derive(Copy, Clone)]
1214#[repr(C)]
1215pub struct GstGLBaseFilter {
1216 pub parent: gst_base::GstBaseTransform,
1217 pub display: *mut GstGLDisplay,
1218 pub context: *mut GstGLContext,
1219 pub in_caps: *mut gst::GstCaps,
1220 pub out_caps: *mut gst::GstCaps,
1221 pub _padding: [gpointer; 4],
1222 pub priv_: *mut GstGLBaseFilterPrivate,
1223}
1224
1225impl ::std::fmt::Debug for GstGLBaseFilter {
1226 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1227 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseFilter @ {self:p}"))
1228 .field("parent", &self.parent)
1229 .field("display", &self.display)
1230 .field("context", &self.context)
1231 .field("in_caps", &self.in_caps)
1232 .field(name:"out_caps", &self.out_caps)
1233 .finish()
1234 }
1235}
1236
1237#[derive(Copy, Clone)]
1238#[repr(C)]
1239pub struct GstGLBaseMemoryAllocator {
1240 pub parent: gst::GstAllocator,
1241 pub fallback_mem_copy: gst::GstMemoryCopyFunction,
1242 pub _padding: [gpointer; 4],
1243}
1244
1245impl ::std::fmt::Debug for GstGLBaseMemoryAllocator {
1246 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1247 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseMemoryAllocator @ {self:p}"))
1248 .finish()
1249 }
1250}
1251
1252#[derive(Copy, Clone)]
1253#[repr(C)]
1254pub struct GstGLBaseMixer {
1255 pub parent: gst_video::GstVideoAggregator,
1256 pub display: *mut GstGLDisplay,
1257 pub context: *mut GstGLContext,
1258 pub _padding: [gpointer; 4],
1259 pub priv_: *mut GstGLBaseMixerPrivate,
1260}
1261
1262impl ::std::fmt::Debug for GstGLBaseMixer {
1263 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1264 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseMixer @ {self:p}"))
1265 .field("parent", &self.parent)
1266 .field("display", &self.display)
1267 .field(name:"context", &self.context)
1268 .finish()
1269 }
1270}
1271
1272#[derive(Copy, Clone)]
1273#[repr(C)]
1274pub struct GstGLBaseMixerPad {
1275 pub parent: gst_video::GstVideoAggregatorPad,
1276 pub _padding: [gpointer; 4],
1277}
1278
1279impl ::std::fmt::Debug for GstGLBaseMixerPad {
1280 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1281 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseMixerPad @ {self:p}"))
1282 .field(name:"parent", &self.parent)
1283 .finish()
1284 }
1285}
1286
1287#[derive(Copy, Clone)]
1288#[repr(C)]
1289pub struct GstGLBaseSrc {
1290 pub parent: gst_base::GstPushSrc,
1291 pub display: *mut GstGLDisplay,
1292 pub context: *mut GstGLContext,
1293 pub out_info: gst_video::GstVideoInfo,
1294 pub out_caps: *mut gst::GstCaps,
1295 pub running_time: gst::GstClockTime,
1296 pub _padding: [gpointer; 4],
1297 pub priv_: *mut GstGLBaseSrcPrivate,
1298}
1299
1300impl ::std::fmt::Debug for GstGLBaseSrc {
1301 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1302 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBaseSrc @ {self:p}"))
1303 .field("parent", &self.parent)
1304 .field("display", &self.display)
1305 .field("context", &self.context)
1306 .field("out_info", &self.out_info)
1307 .field("out_caps", &self.out_caps)
1308 .field(name:"running_time", &self.running_time)
1309 .finish()
1310 }
1311}
1312
1313#[derive(Copy, Clone)]
1314#[repr(C)]
1315pub struct GstGLBufferAllocator {
1316 pub parent: GstGLBaseMemoryAllocator,
1317 pub _padding: [gpointer; 4],
1318}
1319
1320impl ::std::fmt::Debug for GstGLBufferAllocator {
1321 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1322 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBufferAllocator @ {self:p}"))
1323 .field(name:"parent", &self.parent)
1324 .finish()
1325 }
1326}
1327
1328#[derive(Copy, Clone)]
1329#[repr(C)]
1330pub struct GstGLBufferPool {
1331 pub bufferpool: gst::GstBufferPool,
1332 pub context: *mut GstGLContext,
1333 pub priv_: *mut GstGLBufferPoolPrivate,
1334 pub _padding: [gpointer; 4],
1335}
1336
1337impl ::std::fmt::Debug for GstGLBufferPool {
1338 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1339 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLBufferPool @ {self:p}"))
1340 .field("bufferpool", &self.bufferpool)
1341 .field(name:"context", &self.context)
1342 .finish()
1343 }
1344}
1345
1346#[derive(Copy, Clone)]
1347#[repr(C)]
1348pub struct GstGLColorConvert {
1349 pub parent: gst::GstObject,
1350 pub context: *mut GstGLContext,
1351 pub in_info: gst_video::GstVideoInfo,
1352 pub out_info: gst_video::GstVideoInfo,
1353 pub initted: gboolean,
1354 pub passthrough: gboolean,
1355 pub inbuf: *mut gst::GstBuffer,
1356 pub outbuf: *mut gst::GstBuffer,
1357 pub fbo: *mut GstGLFramebuffer,
1358 pub shader: *mut GstGLShader,
1359 pub priv_: *mut GstGLColorConvertPrivate,
1360 pub _reserved: [gpointer; 4],
1361}
1362
1363impl ::std::fmt::Debug for GstGLColorConvert {
1364 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1365 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLColorConvert @ {self:p}"))
1366 .finish()
1367 }
1368}
1369
1370#[derive(Copy, Clone)]
1371#[repr(C)]
1372pub struct GstGLContext {
1373 pub parent: gst::GstObject,
1374 pub display: *mut GstGLDisplay,
1375 pub window: *mut GstGLWindow,
1376 pub gl_vtable: *mut GstGLFuncs,
1377 pub priv_: *mut GstGLContextPrivate,
1378 pub _reserved: [gpointer; 4],
1379}
1380
1381impl ::std::fmt::Debug for GstGLContext {
1382 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1383 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLContext @ {self:p}"))
1384 .field(name:"gl_vtable", &self.gl_vtable)
1385 .finish()
1386 }
1387}
1388
1389#[derive(Copy, Clone)]
1390#[repr(C)]
1391pub struct GstGLDisplay {
1392 pub object: gst::GstObject,
1393 pub type_: GstGLDisplayType,
1394 pub windows: *mut glib::GList,
1395 pub main_context: *mut glib::GMainContext,
1396 pub main_loop: *mut glib::GMainLoop,
1397 pub event_source: *mut glib::GSource,
1398 pub priv_: *mut GstGLDisplayPrivate,
1399}
1400
1401impl ::std::fmt::Debug for GstGLDisplay {
1402 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1403 f.debug_struct(&format!("GstGLDisplay @ {self:p}")).finish()
1404 }
1405}
1406
1407#[derive(Copy, Clone)]
1408#[repr(C)]
1409pub struct GstGLFilter {
1410 pub parent: GstGLBaseFilter,
1411 pub in_info: gst_video::GstVideoInfo,
1412 pub out_info: gst_video::GstVideoInfo,
1413 pub in_texture_target: GstGLTextureTarget,
1414 pub out_texture_target: GstGLTextureTarget,
1415 pub out_caps: *mut gst::GstCaps,
1416 pub fbo: *mut GstGLFramebuffer,
1417 pub gl_result: gboolean,
1418 pub inbuf: *mut gst::GstBuffer,
1419 pub outbuf: *mut gst::GstBuffer,
1420 pub default_shader: *mut GstGLShader,
1421 pub valid_attributes: gboolean,
1422 pub vao: c_uint,
1423 pub vbo_indices: c_uint,
1424 pub vertex_buffer: c_uint,
1425 pub draw_attr_position_loc: c_int,
1426 pub draw_attr_texture_loc: c_int,
1427 pub _padding: [gpointer; 4],
1428}
1429
1430impl ::std::fmt::Debug for GstGLFilter {
1431 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1432 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLFilter @ {self:p}"))
1433 .field("parent", &self.parent)
1434 .field("in_info", &self.in_info)
1435 .field("out_info", &self.out_info)
1436 .field("in_texture_target", &self.in_texture_target)
1437 .field("out_texture_target", &self.out_texture_target)
1438 .field("out_caps", &self.out_caps)
1439 .field(name:"fbo", &self.fbo)
1440 .finish()
1441 }
1442}
1443
1444#[derive(Copy, Clone)]
1445#[repr(C)]
1446pub struct GstGLFramebuffer {
1447 pub object: gst::GstObject,
1448 pub context: *mut GstGLContext,
1449 pub fbo_id: c_uint,
1450 pub attachments: *mut glib::GArray,
1451 pub _padding: [gpointer; 4],
1452 pub priv_: *mut GstGLFramebufferPrivate,
1453}
1454
1455impl ::std::fmt::Debug for GstGLFramebuffer {
1456 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1457 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLFramebuffer @ {self:p}"))
1458 .finish()
1459 }
1460}
1461
1462#[derive(Copy, Clone)]
1463#[repr(C)]
1464pub struct GstGLMemoryAllocator {
1465 pub parent: GstGLBaseMemoryAllocator,
1466 pub _padding: [gpointer; 4],
1467}
1468
1469impl ::std::fmt::Debug for GstGLMemoryAllocator {
1470 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1471 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLMemoryAllocator @ {self:p}"))
1472 .finish()
1473 }
1474}
1475
1476#[derive(Copy, Clone)]
1477#[repr(C)]
1478pub struct GstGLMemoryPBOAllocator {
1479 pub parent: GstGLMemoryAllocator,
1480 pub _padding: [gpointer; 4],
1481}
1482
1483impl ::std::fmt::Debug for GstGLMemoryPBOAllocator {
1484 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1485 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLMemoryPBOAllocator @ {self:p}"))
1486 .field(name:"parent", &self.parent)
1487 .finish()
1488 }
1489}
1490
1491#[derive(Copy, Clone)]
1492#[repr(C)]
1493pub struct GstGLMixer {
1494 pub parent: GstGLBaseMixer,
1495 pub out_caps: *mut gst::GstCaps,
1496 pub priv_: *mut GstGLMixerPrivate,
1497 pub _padding: [gpointer; 4],
1498}
1499
1500impl ::std::fmt::Debug for GstGLMixer {
1501 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1502 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLMixer @ {self:p}"))
1503 .field("parent", &self.parent)
1504 .field(name:"out_caps", &self.out_caps)
1505 .finish()
1506 }
1507}
1508
1509#[derive(Copy, Clone)]
1510#[repr(C)]
1511pub struct GstGLMixerPad {
1512 pub parent: GstGLBaseMixerPad,
1513 pub current_texture: c_uint,
1514 pub _padding: [gpointer; 4],
1515}
1516
1517impl ::std::fmt::Debug for GstGLMixerPad {
1518 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1519 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLMixerPad @ {self:p}"))
1520 .field("parent", &self.parent)
1521 .field(name:"current_texture", &self.current_texture)
1522 .finish()
1523 }
1524}
1525
1526#[derive(Copy, Clone)]
1527#[repr(C)]
1528pub struct GstGLOverlayCompositor {
1529 pub parent: gst::GstObject,
1530 pub context: *mut GstGLContext,
1531 pub last_window_width: c_uint,
1532 pub last_window_height: c_uint,
1533 pub overlays: *mut glib::GList,
1534 pub shader: *mut GstGLShader,
1535 pub position_attrib: c_int,
1536 pub texcoord_attrib: c_int,
1537 pub _padding: [gpointer; 4],
1538}
1539
1540impl ::std::fmt::Debug for GstGLOverlayCompositor {
1541 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1542 fDebugStruct<'_, '_>.debug_struct(&format!("GstGLOverlayCompositor @ {self:p}"))
1543 .finish()
1544 }
1545}
1546
1547#[derive(Copy, Clone)]
1548#[repr(C)]
1549pub struct GstGLRenderbufferAllocator {
1550 pub parent: GstGLBaseMemoryAllocator,
1551 pub _padding: [gpointer; 4],
1552}
1553
1554impl ::std::fmt::Debug for GstGLRenderbufferAllocator {
1555 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1556 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLRenderbufferAllocator @ {self:p}"))
1557 .field(name:"parent", &self.parent)
1558 .finish()
1559 }
1560}
1561
1562#[derive(Copy, Clone)]
1563#[repr(C)]
1564pub struct GstGLSLStage {
1565 pub parent: gst::GstObject,
1566 pub context: *mut GstGLContext,
1567 pub priv_: *mut GstGLSLStagePrivate,
1568 pub _padding: [gpointer; 4],
1569}
1570
1571impl ::std::fmt::Debug for GstGLSLStage {
1572 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1573 f.debug_struct(&format!("GstGLSLStage @ {self:p}")).finish()
1574 }
1575}
1576
1577#[derive(Copy, Clone)]
1578#[repr(C)]
1579pub struct GstGLShader {
1580 pub parent: gst::GstObject,
1581 pub context: *mut GstGLContext,
1582 pub priv_: *mut GstGLShaderPrivate,
1583 pub _padding: [gpointer; 4],
1584}
1585
1586impl ::std::fmt::Debug for GstGLShader {
1587 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1588 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLShader @ {self:p}"))
1589 .field("parent", &self.parent)
1590 .field(name:"context", &self.context)
1591 .finish()
1592 }
1593}
1594
1595#[derive(Copy, Clone)]
1596#[repr(C)]
1597pub struct GstGLUpload {
1598 pub parent: gst::GstObject,
1599 pub context: *mut GstGLContext,
1600 pub priv_: *mut GstGLUploadPrivate,
1601 pub _reserved: [gpointer; 4],
1602}
1603
1604impl ::std::fmt::Debug for GstGLUpload {
1605 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1606 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLUpload @ {self:p}"))
1607 .field("parent", &self.parent)
1608 .field(name:"context", &self.context)
1609 .finish()
1610 }
1611}
1612
1613#[derive(Copy, Clone)]
1614#[repr(C)]
1615pub struct GstGLViewConvert {
1616 pub object: gst::GstObject,
1617 pub context: *mut GstGLContext,
1618 pub shader: *mut GstGLShader,
1619 pub input_mode_override: gst_video::GstVideoMultiviewMode,
1620 pub input_flags_override: gst_video::GstVideoMultiviewFlags,
1621 pub output_mode_override: gst_video::GstVideoMultiviewMode,
1622 pub output_flags_override: gst_video::GstVideoMultiviewFlags,
1623 pub downmix_mode: GstGLStereoDownmix,
1624 pub in_info: gst_video::GstVideoInfo,
1625 pub out_info: gst_video::GstVideoInfo,
1626 pub from_texture_target: GstGLTextureTarget,
1627 pub to_texture_target: GstGLTextureTarget,
1628 pub caps_passthrough: gboolean,
1629 pub initted: gboolean,
1630 pub reconfigure: gboolean,
1631 pub fbo: *mut GstGLFramebuffer,
1632 pub priv_: *mut GstGLViewConvertPrivate,
1633 pub _padding: [gpointer; 4],
1634}
1635
1636impl ::std::fmt::Debug for GstGLViewConvert {
1637 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1638 f&mut DebugStruct<'_, '_>.debug_struct(&format!("GstGLViewConvert @ {self:p}"))
1639 .field("object", &self.object)
1640 .field("context", &self.context)
1641 .field("shader", &self.shader)
1642 .field("input_mode_override", &self.input_mode_override)
1643 .field("input_flags_override", &self.input_flags_override)
1644 .field("output_mode_override", &self.output_mode_override)
1645 .field("output_flags_override", &self.output_flags_override)
1646 .field("downmix_mode", &self.downmix_mode)
1647 .field("in_info", &self.in_info)
1648 .field("out_info", &self.out_info)
1649 .field("from_texture_target", &self.from_texture_target)
1650 .field("to_texture_target", &self.to_texture_target)
1651 .field("caps_passthrough", &self.caps_passthrough)
1652 .field("initted", &self.initted)
1653 .field("reconfigure", &self.reconfigure)
1654 .field(name:"fbo", &self.fbo)
1655 .finish()
1656 }
1657}
1658
1659#[derive(Copy, Clone)]
1660#[repr(C)]
1661pub struct GstGLWindow {
1662 pub parent: gst::GstObject,
1663 pub lock: glib::GMutex,
1664 pub display: *mut GstGLDisplay,
1665 pub context_ref: gobject::GWeakRef,
1666 pub is_drawing: gboolean,
1667 pub draw: GstGLWindowCB,
1668 pub draw_data: gpointer,
1669 pub draw_notify: glib::GDestroyNotify,
1670 pub close: GstGLWindowCB,
1671 pub close_data: gpointer,
1672 pub close_notify: glib::GDestroyNotify,
1673 pub resize: GstGLWindowResizeCB,
1674 pub resize_data: gpointer,
1675 pub resize_notify: glib::GDestroyNotify,
1676 pub queue_resize: gboolean,
1677 pub main_context: *mut glib::GMainContext,
1678 pub priv_: *mut GstGLWindowPrivate,
1679 pub _reserved: [gpointer; 4],
1680}
1681
1682impl ::std::fmt::Debug for GstGLWindow {
1683 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1684 f.debug_struct(&format!("GstGLWindow @ {self:p}")).finish()
1685 }
1686}
1687
1688unsafeextern "C" {
1689
1690 //=========================================================================
1691 // GstGLBaseMemoryError
1692 //=========================================================================
1693 pub unsafefn gst_gl_base_memory_error_get_type() -> GType;
1694 pub unsafefn gst_gl_base_memory_error_quark() -> glib::GQuark;
1695
1696 //=========================================================================
1697 // GstGLConfigCaveat
1698 //=========================================================================
1699 #[cfg(feature = "v1_20")]
1700 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1701 pub fn gst_gl_config_caveat_get_type() -> GType;
1702 #[cfg(feature = "v1_20")]
1703 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1704 pub fn gst_gl_config_caveat_to_string(caveat: GstGLConfigCaveat) -> *const c_char;
1705
1706 //=========================================================================
1707 // GstGLContextError
1708 //=========================================================================
1709 pub unsafefn gst_gl_context_error_get_type() -> GType;
1710 pub unsafefn gst_gl_context_error_quark() -> glib::GQuark;
1711
1712 //=========================================================================
1713 // GstGLFormat
1714 //=========================================================================
1715 pub unsafefn gst_gl_format_get_type() -> GType;
1716 pub unsafefn gst_gl_format_from_video_info(
1717 context: *mut GstGLContext,
1718 vinfo: *const gst_video::GstVideoInfo,
1719 plane: c_uint,
1720 ) -> GstGLFormat;
1721 #[cfg(feature = "v1_16")]
1722 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1723 pub fn gst_gl_format_is_supported(context: *mut GstGLContext, format: GstGLFormat) -> gboolean;
1724 #[cfg(feature = "v1_24")]
1725 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1726 pub fn gst_gl_format_n_components(gl_format: GstGLFormat) -> c_uint;
1727 #[cfg(feature = "v1_16")]
1728 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1729 pub fn gst_gl_format_type_from_sized_gl_format(
1730 format: GstGLFormat,
1731 unsized_format: *mut GstGLFormat,
1732 gl_type: *mut c_uint,
1733 );
1734 pub unsafefn gst_gl_format_type_n_bytes(format: c_uint, type_: c_uint) -> c_uint;
1735
1736 //=========================================================================
1737 // GstGLQueryType
1738 //=========================================================================
1739 pub unsafefn gst_gl_query_type_get_type() -> GType;
1740
1741 //=========================================================================
1742 // GstGLSLError
1743 //=========================================================================
1744 pub unsafefn gst_glsl_error_get_type() -> GType;
1745 pub unsafefn gst_glsl_error_quark() -> glib::GQuark;
1746
1747 //=========================================================================
1748 // GstGLSLVersion
1749 //=========================================================================
1750 pub unsafefn gst_glsl_version_get_type() -> GType;
1751 pub unsafefn gst_glsl_version_from_string(string: *const c_char) -> GstGLSLVersion;
1752 pub unsafefn gst_glsl_version_profile_from_string(
1753 string: *const c_char,
1754 version_ret: *mut GstGLSLVersion,
1755 profile_ret: *mut GstGLSLProfile,
1756 ) -> gboolean;
1757 pub unsafefn gst_glsl_version_profile_to_string(
1758 version: GstGLSLVersion,
1759 profile: GstGLSLProfile,
1760 ) -> *mut c_char;
1761 pub unsafefn gst_glsl_version_to_string(version: GstGLSLVersion) -> *const c_char;
1762
1763 //=========================================================================
1764 // GstGLStereoDownmix
1765 //=========================================================================
1766 pub unsafefn gst_gl_stereo_downmix_get_type() -> GType;
1767
1768 //=========================================================================
1769 // GstGLTextureTarget
1770 //=========================================================================
1771 pub unsafefn gst_gl_texture_target_get_type() -> GType;
1772 pub unsafefn gst_gl_texture_target_from_gl(target: c_uint) -> GstGLTextureTarget;
1773 pub unsafefn gst_gl_texture_target_from_string(str: *const c_char) -> GstGLTextureTarget;
1774 pub unsafefn gst_gl_texture_target_to_buffer_pool_option(target: GstGLTextureTarget)
1775 -> *const c_char;
1776 pub unsafefn gst_gl_texture_target_to_gl(target: GstGLTextureTarget) -> c_uint;
1777 pub unsafefn gst_gl_texture_target_to_string(target: GstGLTextureTarget) -> *const c_char;
1778
1779 //=========================================================================
1780 // GstGLUploadReturn
1781 //=========================================================================
1782 pub unsafefn gst_gl_upload_return_get_type() -> GType;
1783
1784 //=========================================================================
1785 // GstGLWindowError
1786 //=========================================================================
1787 pub unsafefn gst_gl_window_error_get_type() -> GType;
1788 pub unsafefn gst_gl_window_error_quark() -> glib::GQuark;
1789
1790 //=========================================================================
1791 // GstGLAPI
1792 //=========================================================================
1793 pub unsafefn gst_gl_api_get_type() -> GType;
1794 pub unsafefn gst_gl_api_from_string(api_s: *const c_char) -> GstGLAPI;
1795 pub unsafefn gst_gl_api_to_string(api: GstGLAPI) -> *mut c_char;
1796
1797 //=========================================================================
1798 // GstGLBaseMemoryTransfer
1799 //=========================================================================
1800 pub unsafefn gst_gl_base_memory_transfer_get_type() -> GType;
1801
1802 //=========================================================================
1803 // GstGLConfigSurfaceType
1804 //=========================================================================
1805 #[cfg(feature = "v1_20")]
1806 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1807 pub fn gst_gl_config_surface_type_get_type() -> GType;
1808 #[cfg(feature = "v1_20")]
1809 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1810 pub fn gst_gl_config_surface_type_to_string(
1811 surface_type: GstGLConfigSurfaceType,
1812 ) -> *const c_char;
1813
1814 //=========================================================================
1815 // GstGLDisplayType
1816 //=========================================================================
1817 pub unsafefn gst_gl_display_type_get_type() -> GType;
1818
1819 //=========================================================================
1820 // GstGLDrmFormatFlags
1821 //=========================================================================
1822 #[cfg(feature = "v1_26")]
1823 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
1824 pub fn gst_gl_drm_format_flags_get_type() -> GType;
1825
1826 //=========================================================================
1827 // GstGLPlatform
1828 //=========================================================================
1829 pub unsafefn gst_gl_platform_get_type() -> GType;
1830 pub unsafefn gst_gl_platform_from_string(platform_s: *const c_char) -> GstGLPlatform;
1831 pub unsafefn gst_gl_platform_to_string(platform: GstGLPlatform) -> *mut c_char;
1832
1833 //=========================================================================
1834 // GstGLSLProfile
1835 //=========================================================================
1836 pub unsafefn gst_glsl_profile_get_type() -> GType;
1837 pub unsafefn gst_glsl_profile_from_string(string: *const c_char) -> GstGLSLProfile;
1838 pub unsafefn gst_glsl_profile_to_string(profile: GstGLSLProfile) -> *const c_char;
1839
1840 //=========================================================================
1841 // GstGLAllocationParams
1842 //=========================================================================
1843 pub unsafefn gst_gl_allocation_params_get_type() -> GType;
1844 pub unsafefn gst_gl_allocation_params_copy(
1845 src: *mut GstGLAllocationParams,
1846 ) -> *mut GstGLAllocationParams;
1847 pub unsafefn gst_gl_allocation_params_copy_data(
1848 src: *mut GstGLAllocationParams,
1849 dest: *mut GstGLAllocationParams,
1850 );
1851 pub unsafefn gst_gl_allocation_params_free(params: *mut GstGLAllocationParams);
1852 pub unsafefn gst_gl_allocation_params_free_data(params: *mut GstGLAllocationParams);
1853 pub unsafefn gst_gl_allocation_params_init(
1854 params: *mut GstGLAllocationParams,
1855 struct_size: size_t,
1856 alloc_flags: c_uint,
1857 copy: GstGLAllocationParamsCopyFunc,
1858 free: GstGLAllocationParamsFreeFunc,
1859 context: *mut GstGLContext,
1860 alloc_size: size_t,
1861 alloc_params: *const gst::GstAllocationParams,
1862 wrapped_data: gpointer,
1863 gl_handle: gpointer,
1864 user_data: gpointer,
1865 notify: glib::GDestroyNotify,
1866 ) -> gboolean;
1867
1868 //=========================================================================
1869 // GstGLAsyncDebug
1870 //=========================================================================
1871 pub unsafefn gst_gl_async_debug_free(ad: *mut GstGLAsyncDebug);
1872 pub unsafefn gst_gl_async_debug_freeze(ad: *mut GstGLAsyncDebug);
1873 pub unsafefn gst_gl_async_debug_init(ad: *mut GstGLAsyncDebug);
1874 pub unsafefn gst_gl_async_debug_output_log_msg(ad: *mut GstGLAsyncDebug);
1875 pub unsafefn gst_gl_async_debug_store_log_msg(
1876 ad: *mut GstGLAsyncDebug,
1877 cat: *mut gst::GstDebugCategory,
1878 level: gst::GstDebugLevel,
1879 file: *const c_char,
1880 function: *const c_char,
1881 line: c_int,
1882 object: *mut gobject::GObject,
1883 format: *const c_char,
1884 ...
1885 );
1886 //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);
1887 pub unsafefn gst_gl_async_debug_thaw(ad: *mut GstGLAsyncDebug);
1888 pub unsafefn gst_gl_async_debug_unset(ad: *mut GstGLAsyncDebug);
1889 pub unsafefn gst_gl_async_debug_new() -> *mut GstGLAsyncDebug;
1890
1891 //=========================================================================
1892 // GstGLBaseMemory
1893 //=========================================================================
1894 pub unsafefn gst_gl_base_memory_get_type() -> GType;
1895 pub unsafefn gst_gl_base_memory_alloc_data(gl_mem: *mut GstGLBaseMemory) -> gboolean;
1896 pub unsafefn gst_gl_base_memory_init(
1897 mem: *mut GstGLBaseMemory,
1898 allocator: *mut gst::GstAllocator,
1899 parent: *mut gst::GstMemory,
1900 context: *mut GstGLContext,
1901 params: *const gst::GstAllocationParams,
1902 size: size_t,
1903 user_data: gpointer,
1904 notify: glib::GDestroyNotify,
1905 );
1906 pub unsafefn gst_gl_base_memory_memcpy(
1907 src: *mut GstGLBaseMemory,
1908 dest: *mut GstGLBaseMemory,
1909 offset: ssize_t,
1910 size: ssize_t,
1911 ) -> gboolean;
1912 pub unsafefn gst_gl_base_memory_alloc(
1913 allocator: *mut GstGLBaseMemoryAllocator,
1914 params: *mut GstGLAllocationParams,
1915 ) -> *mut GstGLBaseMemory;
1916 pub unsafefn gst_gl_base_memory_init_once();
1917
1918 //=========================================================================
1919 // GstGLBuffer
1920 //=========================================================================
1921 #[cfg(feature = "v1_20")]
1922 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1923 pub fn gst_gl_buffer_get_type() -> GType;
1924 pub unsafefn gst_gl_buffer_init_once();
1925
1926 //=========================================================================
1927 // GstGLBufferAllocationParams
1928 //=========================================================================
1929 pub unsafefn gst_gl_buffer_allocation_params_get_type() -> GType;
1930 pub unsafefn gst_gl_buffer_allocation_params_new(
1931 context: *mut GstGLContext,
1932 alloc_size: size_t,
1933 alloc_params: *const gst::GstAllocationParams,
1934 gl_target: c_uint,
1935 gl_usage: c_uint,
1936 ) -> *mut GstGLBufferAllocationParams;
1937
1938 //=========================================================================
1939 // GstGLMemory
1940 //=========================================================================
1941 #[cfg(feature = "v1_20")]
1942 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1943 pub fn gst_gl_memory_get_type() -> GType;
1944 pub unsafefn gst_gl_memory_copy_into(
1945 gl_mem: *mut GstGLMemory,
1946 tex_id: c_uint,
1947 target: GstGLTextureTarget,
1948 tex_format: GstGLFormat,
1949 width: c_int,
1950 height: c_int,
1951 ) -> gboolean;
1952 pub unsafefn gst_gl_memory_copy_teximage(
1953 src: *mut GstGLMemory,
1954 tex_id: c_uint,
1955 out_target: GstGLTextureTarget,
1956 out_tex_format: GstGLFormat,
1957 out_width: c_int,
1958 out_height: c_int,
1959 ) -> gboolean;
1960 pub unsafefn gst_gl_memory_get_texture_format(gl_mem: *mut GstGLMemory) -> GstGLFormat;
1961 pub unsafefn gst_gl_memory_get_texture_height(gl_mem: *mut GstGLMemory) -> c_int;
1962 pub unsafefn gst_gl_memory_get_texture_id(gl_mem: *mut GstGLMemory) -> c_uint;
1963 pub unsafefn gst_gl_memory_get_texture_target(gl_mem: *mut GstGLMemory) -> GstGLTextureTarget;
1964 pub unsafefn gst_gl_memory_get_texture_width(gl_mem: *mut GstGLMemory) -> c_int;
1965 pub unsafefn gst_gl_memory_init(
1966 mem: *mut GstGLMemory,
1967 allocator: *mut gst::GstAllocator,
1968 parent: *mut gst::GstMemory,
1969 context: *mut GstGLContext,
1970 target: GstGLTextureTarget,
1971 tex_format: GstGLFormat,
1972 params: *const gst::GstAllocationParams,
1973 info: *const gst_video::GstVideoInfo,
1974 plane: c_uint,
1975 valign: *const gst_video::GstVideoAlignment,
1976 user_data: gpointer,
1977 notify: glib::GDestroyNotify,
1978 );
1979 pub unsafefn gst_gl_memory_read_pixels(gl_mem: *mut GstGLMemory, write_pointer: gpointer)
1980 -> gboolean;
1981 pub unsafefn gst_gl_memory_texsubimage(gl_mem: *mut GstGLMemory, read_pointer: gpointer);
1982 pub unsafefn gst_gl_memory_init_once();
1983 pub unsafefn gst_gl_memory_setup_buffer(
1984 allocator: *mut GstGLMemoryAllocator,
1985 buffer: *mut gst::GstBuffer,
1986 params: *mut GstGLVideoAllocationParams,
1987 tex_formats: *mut GstGLFormat,
1988 wrapped_data: *mut gpointer,
1989 n_wrapped_pointers: size_t,
1990 ) -> gboolean;
1991
1992 //=========================================================================
1993 // GstGLMemoryPBO
1994 //=========================================================================
1995 #[cfg(feature = "v1_20")]
1996 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1997 pub fn gst_gl_memory_pbo_get_type() -> GType;
1998 pub unsafefn gst_gl_memory_pbo_copy_into_texture(
1999 gl_mem: *mut GstGLMemoryPBO,
2000 tex_id: c_uint,
2001 target: GstGLTextureTarget,
2002 tex_format: GstGLFormat,
2003 width: c_int,
2004 height: c_int,
2005 stride: c_int,
2006 respecify: gboolean,
2007 ) -> gboolean;
2008 pub unsafefn gst_gl_memory_pbo_download_transfer(gl_mem: *mut GstGLMemoryPBO);
2009 pub unsafefn gst_gl_memory_pbo_upload_transfer(gl_mem: *mut GstGLMemoryPBO);
2010 pub unsafefn gst_gl_memory_pbo_init_once();
2011
2012 //=========================================================================
2013 // GstGLMixerClass
2014 //=========================================================================
2015 #[cfg(feature = "v1_24")]
2016 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2017 pub fn gst_gl_mixer_class_add_rgba_pad_templates(klass: *mut GstGLMixerClass);
2018
2019 //=========================================================================
2020 // GstGLQuery
2021 //=========================================================================
2022 pub unsafefn gst_gl_query_counter(query: *mut GstGLQuery);
2023 pub unsafefn gst_gl_query_end(query: *mut GstGLQuery);
2024 pub unsafefn gst_gl_query_free(query: *mut GstGLQuery);
2025 pub unsafefn gst_gl_query_init(
2026 query: *mut GstGLQuery,
2027 context: *mut GstGLContext,
2028 query_type: GstGLQueryType,
2029 );
2030 pub unsafefn gst_gl_query_result(query: *mut GstGLQuery) -> u64;
2031 pub unsafefn gst_gl_query_start(query: *mut GstGLQuery);
2032 pub unsafefn gst_gl_query_unset(query: *mut GstGLQuery);
2033 pub unsafefn gst_gl_query_local_gl_context(
2034 element: *mut gst::GstElement,
2035 direction: gst::GstPadDirection,
2036 context_ptr: *mut *mut GstGLContext,
2037 ) -> gboolean;
2038 pub unsafefn gst_gl_query_new(
2039 context: *mut GstGLContext,
2040 query_type: GstGLQueryType,
2041 ) -> *mut GstGLQuery;
2042
2043 //=========================================================================
2044 // GstGLRenderbuffer
2045 //=========================================================================
2046 #[cfg(feature = "v1_20")]
2047 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2048 pub fn gst_gl_renderbuffer_get_type() -> GType;
2049 pub unsafefn gst_gl_renderbuffer_get_format(gl_mem: *mut GstGLRenderbuffer) -> GstGLFormat;
2050 pub unsafefn gst_gl_renderbuffer_get_height(gl_mem: *mut GstGLRenderbuffer) -> c_int;
2051 pub unsafefn gst_gl_renderbuffer_get_id(gl_mem: *mut GstGLRenderbuffer) -> c_uint;
2052 pub unsafefn gst_gl_renderbuffer_get_width(gl_mem: *mut GstGLRenderbuffer) -> c_int;
2053 pub unsafefn gst_gl_renderbuffer_init_once();
2054
2055 //=========================================================================
2056 // GstGLRenderbufferAllocationParams
2057 //=========================================================================
2058 pub unsafefn gst_gl_renderbuffer_allocation_params_get_type() -> GType;
2059 pub unsafefn gst_gl_renderbuffer_allocation_params_new(
2060 context: *mut GstGLContext,
2061 alloc_params: *const gst::GstAllocationParams,
2062 renderbuffer_format: GstGLFormat,
2063 width: c_uint,
2064 height: c_uint,
2065 ) -> *mut GstGLRenderbufferAllocationParams;
2066 pub unsafefn gst_gl_renderbuffer_allocation_params_new_wrapped(
2067 context: *mut GstGLContext,
2068 alloc_params: *const gst::GstAllocationParams,
2069 renderbuffer_format: GstGLFormat,
2070 width: c_uint,
2071 height: c_uint,
2072 gl_handle: gpointer,
2073 user_data: gpointer,
2074 notify: glib::GDestroyNotify,
2075 ) -> *mut GstGLRenderbufferAllocationParams;
2076
2077 //=========================================================================
2078 // GstGLSyncMeta
2079 //=========================================================================
2080 pub unsafefn gst_gl_sync_meta_set_sync_point(
2081 sync_meta: *mut GstGLSyncMeta,
2082 context: *mut GstGLContext,
2083 );
2084 pub unsafefn gst_gl_sync_meta_wait(sync_meta: *mut GstGLSyncMeta, context: *mut GstGLContext);
2085 pub unsafefn gst_gl_sync_meta_wait_cpu(sync_meta: *mut GstGLSyncMeta, context: *mut GstGLContext);
2086 pub unsafefn gst_gl_sync_meta_get_info() -> *const gst::GstMetaInfo;
2087
2088 //=========================================================================
2089 // GstGLVideoAllocationParams
2090 //=========================================================================
2091 pub unsafefn gst_gl_video_allocation_params_get_type() -> GType;
2092 pub unsafefn gst_gl_video_allocation_params_new(
2093 context: *mut GstGLContext,
2094 alloc_params: *const gst::GstAllocationParams,
2095 v_info: *const gst_video::GstVideoInfo,
2096 plane: c_uint,
2097 valign: *const gst_video::GstVideoAlignment,
2098 target: GstGLTextureTarget,
2099 tex_format: GstGLFormat,
2100 ) -> *mut GstGLVideoAllocationParams;
2101 pub unsafefn gst_gl_video_allocation_params_new_wrapped_data(
2102 context: *mut GstGLContext,
2103 alloc_params: *const gst::GstAllocationParams,
2104 v_info: *const gst_video::GstVideoInfo,
2105 plane: c_uint,
2106 valign: *const gst_video::GstVideoAlignment,
2107 target: GstGLTextureTarget,
2108 tex_format: GstGLFormat,
2109 wrapped_data: gpointer,
2110 user_data: gpointer,
2111 notify: glib::GDestroyNotify,
2112 ) -> *mut GstGLVideoAllocationParams;
2113 pub unsafefn gst_gl_video_allocation_params_new_wrapped_gl_handle(
2114 context: *mut GstGLContext,
2115 alloc_params: *const gst::GstAllocationParams,
2116 v_info: *const gst_video::GstVideoInfo,
2117 plane: c_uint,
2118 valign: *const gst_video::GstVideoAlignment,
2119 target: GstGLTextureTarget,
2120 tex_format: GstGLFormat,
2121 gl_handle: gpointer,
2122 user_data: gpointer,
2123 notify: glib::GDestroyNotify,
2124 ) -> *mut GstGLVideoAllocationParams;
2125 pub unsafefn gst_gl_video_allocation_params_new_wrapped_texture(
2126 context: *mut GstGLContext,
2127 alloc_params: *const gst::GstAllocationParams,
2128 v_info: *const gst_video::GstVideoInfo,
2129 plane: c_uint,
2130 valign: *const gst_video::GstVideoAlignment,
2131 target: GstGLTextureTarget,
2132 tex_format: GstGLFormat,
2133 tex_id: c_uint,
2134 user_data: gpointer,
2135 notify: glib::GDestroyNotify,
2136 ) -> *mut GstGLVideoAllocationParams;
2137 pub unsafefn gst_gl_video_allocation_params_copy_data(
2138 src_vid: *mut GstGLVideoAllocationParams,
2139 dest_vid: *mut GstGLVideoAllocationParams,
2140 );
2141 pub unsafefn gst_gl_video_allocation_params_free_data(params: *mut GstGLVideoAllocationParams);
2142 pub unsafefn gst_gl_video_allocation_params_init_full(
2143 params: *mut GstGLVideoAllocationParams,
2144 struct_size: size_t,
2145 alloc_flags: c_uint,
2146 copy: GstGLAllocationParamsCopyFunc,
2147 free: GstGLAllocationParamsFreeFunc,
2148 context: *mut GstGLContext,
2149 alloc_params: *const gst::GstAllocationParams,
2150 v_info: *const gst_video::GstVideoInfo,
2151 plane: c_uint,
2152 valign: *const gst_video::GstVideoAlignment,
2153 target: GstGLTextureTarget,
2154 tex_format: GstGLFormat,
2155 wrapped_data: gpointer,
2156 gl_handle: gpointer,
2157 user_data: gpointer,
2158 notify: glib::GDestroyNotify,
2159 ) -> gboolean;
2160
2161 //=========================================================================
2162 // GstGLBaseFilter
2163 //=========================================================================
2164 pub unsafefn gst_gl_base_filter_get_type() -> GType;
2165 #[cfg(feature = "v1_16")]
2166 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2167 pub fn gst_gl_base_filter_find_gl_context(filter: *mut GstGLBaseFilter) -> gboolean;
2168 #[cfg(feature = "v1_18")]
2169 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2170 pub fn gst_gl_base_filter_get_gl_context(filter: *mut GstGLBaseFilter) -> *mut GstGLContext;
2171
2172 //=========================================================================
2173 // GstGLBaseMemoryAllocator
2174 //=========================================================================
2175 pub unsafefn gst_gl_base_memory_allocator_get_type() -> GType;
2176
2177 //=========================================================================
2178 // GstGLBaseMixer
2179 //=========================================================================
2180 #[cfg(feature = "v1_24")]
2181 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2182 pub fn gst_gl_base_mixer_get_type() -> GType;
2183 #[cfg(feature = "v1_24")]
2184 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2185 pub fn gst_gl_base_mixer_get_gl_context(mix: *mut GstGLBaseMixer) -> *mut GstGLContext;
2186
2187 //=========================================================================
2188 // GstGLBaseMixerPad
2189 //=========================================================================
2190 #[cfg(feature = "v1_24")]
2191 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2192 pub fn gst_gl_base_mixer_pad_get_type() -> GType;
2193
2194 //=========================================================================
2195 // GstGLBaseSrc
2196 //=========================================================================
2197 #[cfg(feature = "v1_18")]
2198 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2199 pub fn gst_gl_base_src_get_type() -> GType;
2200
2201 //=========================================================================
2202 // GstGLBufferAllocator
2203 //=========================================================================
2204 pub unsafefn gst_gl_buffer_allocator_get_type() -> GType;
2205
2206 //=========================================================================
2207 // GstGLBufferPool
2208 //=========================================================================
2209 pub unsafefn gst_gl_buffer_pool_get_type() -> GType;
2210 pub unsafefn gst_gl_buffer_pool_new(context: *mut GstGLContext) -> *mut gst::GstBufferPool;
2211 #[cfg(feature = "v1_20")]
2212 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2213 pub fn gst_gl_buffer_pool_get_gl_allocation_params(
2214 pool: *mut GstGLBufferPool,
2215 ) -> *mut GstGLAllocationParams;
2216
2217 //=========================================================================
2218 // GstGLColorConvert
2219 //=========================================================================
2220 pub unsafefn gst_gl_color_convert_get_type() -> GType;
2221 pub unsafefn gst_gl_color_convert_new(context: *mut GstGLContext) -> *mut GstGLColorConvert;
2222 pub unsafefn gst_gl_color_convert_fixate_caps(
2223 context: *mut GstGLContext,
2224 direction: gst::GstPadDirection,
2225 caps: *mut gst::GstCaps,
2226 other: *mut gst::GstCaps,
2227 ) -> *mut gst::GstCaps;
2228 #[cfg(feature = "v1_24")]
2229 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2230 pub fn gst_gl_color_convert_swizzle_shader_string(context: *mut GstGLContext) -> *mut c_char;
2231 pub unsafefn gst_gl_color_convert_transform_caps(
2232 context: *mut GstGLContext,
2233 direction: gst::GstPadDirection,
2234 caps: *mut gst::GstCaps,
2235 filter: *mut gst::GstCaps,
2236 ) -> *mut gst::GstCaps;
2237 #[cfg(feature = "v1_24")]
2238 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2239 pub fn gst_gl_color_convert_yuv_to_rgb_shader_string(context: *mut GstGLContext)
2240 -> *mut c_char;
2241 pub unsafefn gst_gl_color_convert_decide_allocation(
2242 convert: *mut GstGLColorConvert,
2243 query: *mut gst::GstQuery,
2244 ) -> gboolean;
2245 pub unsafefn gst_gl_color_convert_perform(
2246 convert: *mut GstGLColorConvert,
2247 inbuf: *mut gst::GstBuffer,
2248 ) -> *mut gst::GstBuffer;
2249 pub unsafefn gst_gl_color_convert_set_caps(
2250 convert: *mut GstGLColorConvert,
2251 in_caps: *mut gst::GstCaps,
2252 out_caps: *mut gst::GstCaps,
2253 ) -> gboolean;
2254
2255 //=========================================================================
2256 // GstGLContext
2257 //=========================================================================
2258 pub unsafefn gst_gl_context_get_type() -> GType;
2259 pub unsafefn gst_gl_context_new(display: *mut GstGLDisplay) -> *mut GstGLContext;
2260 pub unsafefn gst_gl_context_new_wrapped(
2261 display: *mut GstGLDisplay,
2262 handle: uintptr_t,
2263 context_type: GstGLPlatform,
2264 available_apis: GstGLAPI,
2265 ) -> *mut GstGLContext;
2266 pub unsafefn gst_gl_context_default_get_proc_address(
2267 gl_api: GstGLAPI,
2268 name: *const c_char,
2269 ) -> gpointer;
2270 pub unsafefn gst_gl_context_get_current() -> *mut GstGLContext;
2271 pub unsafefn gst_gl_context_get_current_gl_api(
2272 platform: GstGLPlatform,
2273 major: *mut c_uint,
2274 minor: *mut c_uint,
2275 ) -> GstGLAPI;
2276 pub unsafefn gst_gl_context_get_current_gl_context(context_type: GstGLPlatform) -> uintptr_t;
2277 pub unsafefn gst_gl_context_get_proc_address_with_platform(
2278 context_type: GstGLPlatform,
2279 gl_api: GstGLAPI,
2280 name: *const c_char,
2281 ) -> gpointer;
2282 pub unsafefn gst_gl_context_activate(context: *mut GstGLContext, activate: gboolean) -> gboolean;
2283 pub unsafefn gst_gl_context_can_share(
2284 context: *mut GstGLContext,
2285 other_context: *mut GstGLContext,
2286 ) -> gboolean;
2287 pub unsafefn gst_gl_context_check_feature(
2288 context: *mut GstGLContext,
2289 feature: *const c_char,
2290 ) -> gboolean;
2291 pub unsafefn gst_gl_context_check_framebuffer_status(
2292 context: *mut GstGLContext,
2293 fbo_target: c_uint,
2294 ) -> gboolean;
2295 pub unsafefn gst_gl_context_check_gl_version(
2296 context: *mut GstGLContext,
2297 api: GstGLAPI,
2298 maj: c_int,
2299 min: c_int,
2300 ) -> gboolean;
2301 pub unsafefn gst_gl_context_clear_framebuffer(context: *mut GstGLContext);
2302 pub unsafefn gst_gl_context_clear_shader(context: *mut GstGLContext);
2303 pub unsafefn gst_gl_context_create(
2304 context: *mut GstGLContext,
2305 other_context: *mut GstGLContext,
2306 error: *mut *mut glib::GError,
2307 ) -> gboolean;
2308 pub unsafefn gst_gl_context_destroy(context: *mut GstGLContext);
2309 pub unsafefn gst_gl_context_fill_info(
2310 context: *mut GstGLContext,
2311 error: *mut *mut glib::GError,
2312 ) -> gboolean;
2313 #[cfg(feature = "v1_20")]
2314 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2315 pub fn gst_gl_context_get_config(context: *mut GstGLContext) -> *mut gst::GstStructure;
2316 pub unsafefn gst_gl_context_get_display(context: *mut GstGLContext) -> *mut GstGLDisplay;
2317 pub unsafefn gst_gl_context_get_gl_api(context: *mut GstGLContext) -> GstGLAPI;
2318 pub unsafefn gst_gl_context_get_gl_context(context: *mut GstGLContext) -> uintptr_t;
2319 pub unsafefn gst_gl_context_get_gl_platform(context: *mut GstGLContext) -> GstGLPlatform;
2320 pub unsafefn gst_gl_context_get_gl_platform_version(
2321 context: *mut GstGLContext,
2322 major: *mut c_int,
2323 minor: *mut c_int,
2324 );
2325 pub unsafefn gst_gl_context_get_gl_version(
2326 context: *mut GstGLContext,
2327 maj: *mut c_int,
2328 min: *mut c_int,
2329 );
2330 pub unsafefn gst_gl_context_get_proc_address(
2331 context: *mut GstGLContext,
2332 name: *const c_char,
2333 ) -> gpointer;
2334 pub unsafefn gst_gl_context_get_thread(context: *mut GstGLContext) -> *mut glib::GThread;
2335 pub unsafefn gst_gl_context_get_window(context: *mut GstGLContext) -> *mut GstGLWindow;
2336 pub unsafefn gst_gl_context_is_shared(context: *mut GstGLContext) -> gboolean;
2337 #[cfg(feature = "v1_20")]
2338 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2339 pub fn gst_gl_context_request_config(
2340 context: *mut GstGLContext,
2341 gl_config: *mut gst::GstStructure,
2342 ) -> gboolean;
2343 pub unsafefn gst_gl_context_set_shared_with(context: *mut GstGLContext, share: *mut GstGLContext);
2344 pub unsafefn gst_gl_context_set_window(
2345 context: *mut GstGLContext,
2346 window: *mut GstGLWindow,
2347 ) -> gboolean;
2348 pub unsafefn gst_gl_context_supports_glsl_profile_version(
2349 context: *mut GstGLContext,
2350 version: GstGLSLVersion,
2351 profile: GstGLSLProfile,
2352 ) -> gboolean;
2353 #[cfg(feature = "v1_16")]
2354 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2355 pub fn gst_gl_context_supports_precision(
2356 context: *mut GstGLContext,
2357 version: GstGLSLVersion,
2358 profile: GstGLSLProfile,
2359 ) -> gboolean;
2360 #[cfg(feature = "v1_16")]
2361 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2362 pub fn gst_gl_context_supports_precision_highp(
2363 context: *mut GstGLContext,
2364 version: GstGLSLVersion,
2365 profile: GstGLSLProfile,
2366 ) -> gboolean;
2367 pub unsafefn gst_gl_context_swap_buffers(context: *mut GstGLContext);
2368 pub unsafefn gst_gl_context_thread_add(
2369 context: *mut GstGLContext,
2370 func: GstGLContextThreadFunc,
2371 data: gpointer,
2372 );
2373
2374 //=========================================================================
2375 // GstGLDisplay
2376 //=========================================================================
2377 pub unsafefn gst_gl_display_get_type() -> GType;
2378 pub unsafefn gst_gl_display_new() -> *mut GstGLDisplay;
2379 #[cfg(feature = "v1_20")]
2380 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2381 pub fn gst_gl_display_new_with_type(type_: GstGLDisplayType) -> *mut GstGLDisplay;
2382 pub unsafefn gst_gl_display_add_context(
2383 display: *mut GstGLDisplay,
2384 context: *mut GstGLContext,
2385 ) -> gboolean;
2386 pub unsafefn gst_gl_display_create_context(
2387 display: *mut GstGLDisplay,
2388 other_context: *mut GstGLContext,
2389 p_context: *mut *mut GstGLContext,
2390 error: *mut *mut glib::GError,
2391 ) -> gboolean;
2392 pub unsafefn gst_gl_display_create_window(display: *mut GstGLDisplay) -> *mut GstGLWindow;
2393 #[cfg(feature = "v1_24")]
2394 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2395 pub fn gst_gl_display_ensure_context(
2396 display: *mut GstGLDisplay,
2397 other_context: *mut GstGLContext,
2398 context: *mut *mut GstGLContext,
2399 error: *mut *mut glib::GError,
2400 ) -> gboolean;
2401 pub unsafefn gst_gl_display_filter_gl_api(display: *mut GstGLDisplay, gl_api: GstGLAPI);
2402 pub unsafefn gst_gl_display_find_window(
2403 display: *mut GstGLDisplay,
2404 data: gpointer,
2405 compare_func: glib::GCompareFunc,
2406 ) -> *mut GstGLWindow;
2407 pub unsafefn gst_gl_display_get_gl_api(display: *mut GstGLDisplay) -> GstGLAPI;
2408 pub unsafefn gst_gl_display_get_gl_api_unlocked(display: *mut GstGLDisplay) -> GstGLAPI;
2409 pub unsafefn gst_gl_display_get_gl_context_for_thread(
2410 display: *mut GstGLDisplay,
2411 thread: *mut glib::GThread,
2412 ) -> *mut GstGLContext;
2413 pub unsafefn gst_gl_display_get_handle(display: *mut GstGLDisplay) -> uintptr_t;
2414 pub unsafefn gst_gl_display_get_handle_type(display: *mut GstGLDisplay) -> GstGLDisplayType;
2415 #[cfg(feature = "v1_18")]
2416 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2417 pub fn gst_gl_display_remove_context(display: *mut GstGLDisplay, context: *mut GstGLContext);
2418 pub unsafefn gst_gl_display_remove_window(
2419 display: *mut GstGLDisplay,
2420 window: *mut GstGLWindow,
2421 ) -> gboolean;
2422 #[cfg(feature = "v1_18")]
2423 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2424 pub fn gst_gl_display_retrieve_window(
2425 display: *mut GstGLDisplay,
2426 data: gpointer,
2427 compare_func: glib::GCompareFunc,
2428 ) -> *mut GstGLWindow;
2429
2430 //=========================================================================
2431 // GstGLFilter
2432 //=========================================================================
2433 pub unsafefn gst_gl_filter_get_type() -> GType;
2434 pub unsafefn gst_gl_filter_add_rgba_pad_templates(klass: *mut GstGLFilterClass);
2435 pub unsafefn gst_gl_filter_draw_fullscreen_quad(filter: *mut GstGLFilter);
2436 pub unsafefn gst_gl_filter_filter_texture(
2437 filter: *mut GstGLFilter,
2438 input: *mut gst::GstBuffer,
2439 output: *mut gst::GstBuffer,
2440 ) -> gboolean;
2441 pub unsafefn gst_gl_filter_render_to_target(
2442 filter: *mut GstGLFilter,
2443 input: *mut GstGLMemory,
2444 output: *mut GstGLMemory,
2445 func: GstGLFilterRenderFunc,
2446 data: gpointer,
2447 ) -> gboolean;
2448 pub unsafefn gst_gl_filter_render_to_target_with_shader(
2449 filter: *mut GstGLFilter,
2450 input: *mut GstGLMemory,
2451 output: *mut GstGLMemory,
2452 shader: *mut GstGLShader,
2453 );
2454
2455 //=========================================================================
2456 // GstGLFramebuffer
2457 //=========================================================================
2458 pub unsafefn gst_gl_framebuffer_get_type() -> GType;
2459 pub unsafefn gst_gl_framebuffer_new(context: *mut GstGLContext) -> *mut GstGLFramebuffer;
2460 pub unsafefn gst_gl_framebuffer_new_with_default_depth(
2461 context: *mut GstGLContext,
2462 width: c_uint,
2463 height: c_uint,
2464 ) -> *mut GstGLFramebuffer;
2465 pub unsafefn gst_gl_framebuffer_attach(
2466 fb: *mut GstGLFramebuffer,
2467 attachment_point: c_uint,
2468 mem: *mut GstGLBaseMemory,
2469 );
2470 pub unsafefn gst_gl_framebuffer_bind(fb: *mut GstGLFramebuffer);
2471 pub unsafefn gst_gl_framebuffer_draw_to_texture(
2472 fb: *mut GstGLFramebuffer,
2473 mem: *mut GstGLMemory,
2474 func: GstGLFramebufferFunc,
2475 user_data: gpointer,
2476 ) -> gboolean;
2477 pub unsafefn gst_gl_framebuffer_get_effective_dimensions(
2478 fb: *mut GstGLFramebuffer,
2479 width: *mut c_uint,
2480 height: *mut c_uint,
2481 );
2482 pub unsafefn gst_gl_framebuffer_get_id(fb: *mut GstGLFramebuffer) -> c_uint;
2483
2484 //=========================================================================
2485 // GstGLMemoryAllocator
2486 //=========================================================================
2487 pub unsafefn gst_gl_memory_allocator_get_type() -> GType;
2488 pub unsafefn gst_gl_memory_allocator_get_default(
2489 context: *mut GstGLContext,
2490 ) -> *mut GstGLMemoryAllocator;
2491
2492 //=========================================================================
2493 // GstGLMemoryPBOAllocator
2494 //=========================================================================
2495 pub unsafefn gst_gl_memory_pbo_allocator_get_type() -> GType;
2496
2497 //=========================================================================
2498 // GstGLMixer
2499 //=========================================================================
2500 #[cfg(feature = "v1_24")]
2501 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2502 pub fn gst_gl_mixer_get_type() -> GType;
2503 #[cfg(feature = "v1_24")]
2504 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2505 pub fn gst_gl_mixer_get_framebuffer(mix: *mut GstGLMixer) -> *mut GstGLFramebuffer;
2506 #[cfg(feature = "v1_24")]
2507 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2508 pub fn gst_gl_mixer_process_textures(
2509 mix: *mut GstGLMixer,
2510 outbuf: *mut gst::GstBuffer,
2511 ) -> gboolean;
2512
2513 //=========================================================================
2514 // GstGLMixerPad
2515 //=========================================================================
2516 #[cfg(feature = "v1_24")]
2517 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2518 pub fn gst_gl_mixer_pad_get_type() -> GType;
2519
2520 //=========================================================================
2521 // GstGLOverlayCompositor
2522 //=========================================================================
2523 pub unsafefn gst_gl_overlay_compositor_get_type() -> GType;
2524 pub unsafefn gst_gl_overlay_compositor_new(context: *mut GstGLContext)
2525 -> *mut GstGLOverlayCompositor;
2526 pub unsafefn gst_gl_overlay_compositor_add_caps(caps: *mut gst::GstCaps) -> *mut gst::GstCaps;
2527 pub unsafefn gst_gl_overlay_compositor_draw_overlays(compositor: *mut GstGLOverlayCompositor);
2528 pub unsafefn gst_gl_overlay_compositor_free_overlays(compositor: *mut GstGLOverlayCompositor);
2529 pub unsafefn gst_gl_overlay_compositor_upload_overlays(
2530 compositor: *mut GstGLOverlayCompositor,
2531 buf: *mut gst::GstBuffer,
2532 );
2533
2534 //=========================================================================
2535 // GstGLRenderbufferAllocator
2536 //=========================================================================
2537 pub unsafefn gst_gl_renderbuffer_allocator_get_type() -> GType;
2538
2539 //=========================================================================
2540 // GstGLSLStage
2541 //=========================================================================
2542 pub unsafefn gst_glsl_stage_get_type() -> GType;
2543 pub unsafefn gst_glsl_stage_new(context: *mut GstGLContext, type_: c_uint) -> *mut GstGLSLStage;
2544 pub unsafefn gst_glsl_stage_new_default_fragment(context: *mut GstGLContext) -> *mut GstGLSLStage;
2545 pub unsafefn gst_glsl_stage_new_default_vertex(context: *mut GstGLContext) -> *mut GstGLSLStage;
2546 pub unsafefn gst_glsl_stage_new_with_string(
2547 context: *mut GstGLContext,
2548 type_: c_uint,
2549 version: GstGLSLVersion,
2550 profile: GstGLSLProfile,
2551 str: *const c_char,
2552 ) -> *mut GstGLSLStage;
2553 pub unsafefn gst_glsl_stage_new_with_strings(
2554 context: *mut GstGLContext,
2555 type_: c_uint,
2556 version: GstGLSLVersion,
2557 profile: GstGLSLProfile,
2558 n_strings: c_int,
2559 str: *mut *const c_char,
2560 ) -> *mut GstGLSLStage;
2561 pub unsafefn gst_glsl_stage_compile(
2562 stage: *mut GstGLSLStage,
2563 error: *mut *mut glib::GError,
2564 ) -> gboolean;
2565 pub unsafefn gst_glsl_stage_get_handle(stage: *mut GstGLSLStage) -> c_uint;
2566 pub unsafefn gst_glsl_stage_get_profile(stage: *mut GstGLSLStage) -> GstGLSLProfile;
2567 pub unsafefn gst_glsl_stage_get_shader_type(stage: *mut GstGLSLStage) -> c_uint;
2568 pub unsafefn gst_glsl_stage_get_version(stage: *mut GstGLSLStage) -> GstGLSLVersion;
2569 pub unsafefn gst_glsl_stage_set_strings(
2570 stage: *mut GstGLSLStage,
2571 version: GstGLSLVersion,
2572 profile: GstGLSLProfile,
2573 n_strings: c_int,
2574 str: *mut *const c_char,
2575 ) -> gboolean;
2576
2577 //=========================================================================
2578 // GstGLShader
2579 //=========================================================================
2580 pub unsafefn gst_gl_shader_get_type() -> GType;
2581 pub unsafefn gst_gl_shader_new(context: *mut GstGLContext) -> *mut GstGLShader;
2582 pub unsafefn gst_gl_shader_new_default(
2583 context: *mut GstGLContext,
2584 error: *mut *mut glib::GError,
2585 ) -> *mut GstGLShader;
2586 pub unsafefn gst_gl_shader_new_link_with_stages(
2587 context: *mut GstGLContext,
2588 error: *mut *mut glib::GError,
2589 ...
2590 ) -> *mut GstGLShader;
2591 pub unsafefn gst_gl_shader_new_with_stages(
2592 context: *mut GstGLContext,
2593 error: *mut *mut glib::GError,
2594 ...
2595 ) -> *mut GstGLShader;
2596 #[cfg(feature = "v1_16")]
2597 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2598 pub fn gst_gl_shader_string_fragment_external_oes_get_default(
2599 context: *mut GstGLContext,
2600 version: GstGLSLVersion,
2601 profile: GstGLSLProfile,
2602 ) -> *mut c_char;
2603 #[cfg(feature = "v1_16")]
2604 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2605 pub fn gst_gl_shader_string_fragment_get_default(
2606 context: *mut GstGLContext,
2607 version: GstGLSLVersion,
2608 profile: GstGLSLProfile,
2609 ) -> *mut c_char;
2610 #[cfg(feature = "v1_16")]
2611 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2612 pub fn gst_gl_shader_string_get_highest_precision(
2613 context: *mut GstGLContext,
2614 version: GstGLSLVersion,
2615 profile: GstGLSLProfile,
2616 ) -> *const c_char;
2617 pub unsafefn gst_gl_shader_attach(shader: *mut GstGLShader, stage: *mut GstGLSLStage) -> gboolean;
2618 pub unsafefn gst_gl_shader_attach_unlocked(
2619 shader: *mut GstGLShader,
2620 stage: *mut GstGLSLStage,
2621 ) -> gboolean;
2622 pub unsafefn gst_gl_shader_bind_attribute_location(
2623 shader: *mut GstGLShader,
2624 index: c_uint,
2625 name: *const c_char,
2626 );
2627 pub unsafefn gst_gl_shader_bind_frag_data_location(
2628 shader: *mut GstGLShader,
2629 index: c_uint,
2630 name: *const c_char,
2631 );
2632 pub unsafefn gst_gl_shader_compile_attach_stage(
2633 shader: *mut GstGLShader,
2634 stage: *mut GstGLSLStage,
2635 error: *mut *mut glib::GError,
2636 ) -> gboolean;
2637 pub unsafefn gst_gl_shader_detach(shader: *mut GstGLShader, stage: *mut GstGLSLStage);
2638 pub unsafefn gst_gl_shader_detach_unlocked(shader: *mut GstGLShader, stage: *mut GstGLSLStage);
2639 pub unsafefn gst_gl_shader_get_attribute_location(
2640 shader: *mut GstGLShader,
2641 name: *const c_char,
2642 ) -> c_int;
2643 pub unsafefn gst_gl_shader_get_program_handle(shader: *mut GstGLShader) -> c_int;
2644 pub unsafefn gst_gl_shader_is_linked(shader: *mut GstGLShader) -> gboolean;
2645 pub unsafefn gst_gl_shader_link(shader: *mut GstGLShader, error: *mut *mut glib::GError) -> gboolean;
2646 pub unsafefn gst_gl_shader_release(shader: *mut GstGLShader);
2647 pub unsafefn gst_gl_shader_release_unlocked(shader: *mut GstGLShader);
2648 pub unsafefn gst_gl_shader_set_uniform_1f(
2649 shader: *mut GstGLShader,
2650 name: *const c_char,
2651 value: c_float,
2652 );
2653 pub unsafefn gst_gl_shader_set_uniform_1fv(
2654 shader: *mut GstGLShader,
2655 name: *const c_char,
2656 count: c_uint,
2657 value: *const c_float,
2658 );
2659 pub unsafefn gst_gl_shader_set_uniform_1i(
2660 shader: *mut GstGLShader,
2661 name: *const c_char,
2662 value: c_int,
2663 );
2664 pub unsafefn gst_gl_shader_set_uniform_1iv(
2665 shader: *mut GstGLShader,
2666 name: *const c_char,
2667 count: c_uint,
2668 value: *const c_int,
2669 );
2670 pub unsafefn gst_gl_shader_set_uniform_2f(
2671 shader: *mut GstGLShader,
2672 name: *const c_char,
2673 v0: c_float,
2674 v1: c_float,
2675 );
2676 pub unsafefn gst_gl_shader_set_uniform_2fv(
2677 shader: *mut GstGLShader,
2678 name: *const c_char,
2679 count: c_uint,
2680 value: *const c_float,
2681 );
2682 pub unsafefn gst_gl_shader_set_uniform_2i(
2683 shader: *mut GstGLShader,
2684 name: *const c_char,
2685 v0: c_int,
2686 v1: c_int,
2687 );
2688 pub unsafefn gst_gl_shader_set_uniform_2iv(
2689 shader: *mut GstGLShader,
2690 name: *const c_char,
2691 count: c_uint,
2692 value: *const c_int,
2693 );
2694 pub unsafefn gst_gl_shader_set_uniform_3f(
2695 shader: *mut GstGLShader,
2696 name: *const c_char,
2697 v0: c_float,
2698 v1: c_float,
2699 v2: c_float,
2700 );
2701 pub unsafefn gst_gl_shader_set_uniform_3fv(
2702 shader: *mut GstGLShader,
2703 name: *const c_char,
2704 count: c_uint,
2705 value: *const c_float,
2706 );
2707 pub unsafefn gst_gl_shader_set_uniform_3i(
2708 shader: *mut GstGLShader,
2709 name: *const c_char,
2710 v0: c_int,
2711 v1: c_int,
2712 v2: c_int,
2713 );
2714 pub unsafefn gst_gl_shader_set_uniform_3iv(
2715 shader: *mut GstGLShader,
2716 name: *const c_char,
2717 count: c_uint,
2718 value: *const c_int,
2719 );
2720 pub unsafefn gst_gl_shader_set_uniform_4f(
2721 shader: *mut GstGLShader,
2722 name: *const c_char,
2723 v0: c_float,
2724 v1: c_float,
2725 v2: c_float,
2726 v3: c_float,
2727 );
2728 pub unsafefn gst_gl_shader_set_uniform_4fv(
2729 shader: *mut GstGLShader,
2730 name: *const c_char,
2731 count: c_uint,
2732 value: *const c_float,
2733 );
2734 pub unsafefn gst_gl_shader_set_uniform_4i(
2735 shader: *mut GstGLShader,
2736 name: *const c_char,
2737 v0: c_int,
2738 v1: c_int,
2739 v2: c_int,
2740 v3: c_int,
2741 );
2742 pub unsafefn gst_gl_shader_set_uniform_4iv(
2743 shader: *mut GstGLShader,
2744 name: *const c_char,
2745 count: c_uint,
2746 value: *const c_int,
2747 );
2748 pub unsafefn gst_gl_shader_set_uniform_matrix_2fv(
2749 shader: *mut GstGLShader,
2750 name: *const c_char,
2751 count: c_int,
2752 transpose: gboolean,
2753 value: *const c_float,
2754 );
2755 pub unsafefn gst_gl_shader_set_uniform_matrix_2x3fv(
2756 shader: *mut GstGLShader,
2757 name: *const c_char,
2758 count: c_int,
2759 transpose: gboolean,
2760 value: *const c_float,
2761 );
2762 pub unsafefn gst_gl_shader_set_uniform_matrix_2x4fv(
2763 shader: *mut GstGLShader,
2764 name: *const c_char,
2765 count: c_int,
2766 transpose: gboolean,
2767 value: *const c_float,
2768 );
2769 pub unsafefn gst_gl_shader_set_uniform_matrix_3fv(
2770 shader: *mut GstGLShader,
2771 name: *const c_char,
2772 count: c_int,
2773 transpose: gboolean,
2774 value: *const c_float,
2775 );
2776 pub unsafefn gst_gl_shader_set_uniform_matrix_3x2fv(
2777 shader: *mut GstGLShader,
2778 name: *const c_char,
2779 count: c_int,
2780 transpose: gboolean,
2781 value: *const c_float,
2782 );
2783 pub unsafefn gst_gl_shader_set_uniform_matrix_3x4fv(
2784 shader: *mut GstGLShader,
2785 name: *const c_char,
2786 count: c_int,
2787 transpose: gboolean,
2788 value: *const c_float,
2789 );
2790 pub unsafefn gst_gl_shader_set_uniform_matrix_4fv(
2791 shader: *mut GstGLShader,
2792 name: *const c_char,
2793 count: c_int,
2794 transpose: gboolean,
2795 value: *const c_float,
2796 );
2797 pub unsafefn gst_gl_shader_set_uniform_matrix_4x2fv(
2798 shader: *mut GstGLShader,
2799 name: *const c_char,
2800 count: c_int,
2801 transpose: gboolean,
2802 value: *const c_float,
2803 );
2804 pub unsafefn gst_gl_shader_set_uniform_matrix_4x3fv(
2805 shader: *mut GstGLShader,
2806 name: *const c_char,
2807 count: c_int,
2808 transpose: gboolean,
2809 value: *const c_float,
2810 );
2811 pub unsafefn gst_gl_shader_use(shader: *mut GstGLShader);
2812
2813 //=========================================================================
2814 // GstGLUpload
2815 //=========================================================================
2816 pub unsafefn gst_gl_upload_get_type() -> GType;
2817 pub unsafefn gst_gl_upload_new(context: *mut GstGLContext) -> *mut GstGLUpload;
2818 pub unsafefn gst_gl_upload_get_input_template_caps() -> *mut gst::GstCaps;
2819 #[cfg(feature = "v1_24")]
2820 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2821 pub fn gst_gl_upload_fixate_caps(
2822 upload: *mut GstGLUpload,
2823 direction: gst::GstPadDirection,
2824 caps: *mut gst::GstCaps,
2825 othercaps: *mut gst::GstCaps,
2826 ) -> *mut gst::GstCaps;
2827 pub unsafefn gst_gl_upload_get_caps(
2828 upload: *mut GstGLUpload,
2829 in_caps: *mut *mut gst::GstCaps,
2830 out_caps: *mut *mut gst::GstCaps,
2831 );
2832 pub unsafefn gst_gl_upload_perform_with_buffer(
2833 upload: *mut GstGLUpload,
2834 buffer: *mut gst::GstBuffer,
2835 outbuf_ptr: *mut *mut gst::GstBuffer,
2836 ) -> GstGLUploadReturn;
2837 pub unsafefn gst_gl_upload_propose_allocation(
2838 upload: *mut GstGLUpload,
2839 decide_query: *mut gst::GstQuery,
2840 query: *mut gst::GstQuery,
2841 );
2842 pub unsafefn gst_gl_upload_set_caps(
2843 upload: *mut GstGLUpload,
2844 in_caps: *mut gst::GstCaps,
2845 out_caps: *mut gst::GstCaps,
2846 ) -> gboolean;
2847 pub unsafefn gst_gl_upload_set_context(upload: *mut GstGLUpload, context: *mut GstGLContext);
2848 pub unsafefn gst_gl_upload_transform_caps(
2849 upload: *mut GstGLUpload,
2850 context: *mut GstGLContext,
2851 direction: gst::GstPadDirection,
2852 caps: *mut gst::GstCaps,
2853 filter: *mut gst::GstCaps,
2854 ) -> *mut gst::GstCaps;
2855
2856 //=========================================================================
2857 // GstGLViewConvert
2858 //=========================================================================
2859 pub unsafefn gst_gl_view_convert_get_type() -> GType;
2860 pub unsafefn gst_gl_view_convert_new() -> *mut GstGLViewConvert;
2861 pub unsafefn gst_gl_view_convert_fixate_caps(
2862 viewconvert: *mut GstGLViewConvert,
2863 direction: gst::GstPadDirection,
2864 caps: *mut gst::GstCaps,
2865 othercaps: *mut gst::GstCaps,
2866 ) -> *mut gst::GstCaps;
2867 pub unsafefn gst_gl_view_convert_get_output(
2868 viewconvert: *mut GstGLViewConvert,
2869 outbuf_ptr: *mut *mut gst::GstBuffer,
2870 ) -> gst::GstFlowReturn;
2871 pub unsafefn gst_gl_view_convert_perform(
2872 viewconvert: *mut GstGLViewConvert,
2873 inbuf: *mut gst::GstBuffer,
2874 ) -> *mut gst::GstBuffer;
2875 pub unsafefn gst_gl_view_convert_reset(viewconvert: *mut GstGLViewConvert);
2876 pub unsafefn gst_gl_view_convert_set_caps(
2877 viewconvert: *mut GstGLViewConvert,
2878 in_caps: *mut gst::GstCaps,
2879 out_caps: *mut gst::GstCaps,
2880 ) -> gboolean;
2881 pub unsafefn gst_gl_view_convert_set_context(
2882 viewconvert: *mut GstGLViewConvert,
2883 context: *mut GstGLContext,
2884 );
2885 pub unsafefn gst_gl_view_convert_submit_input_buffer(
2886 viewconvert: *mut GstGLViewConvert,
2887 is_discont: gboolean,
2888 input: *mut gst::GstBuffer,
2889 ) -> gst::GstFlowReturn;
2890 pub unsafefn gst_gl_view_convert_transform_caps(
2891 viewconvert: *mut GstGLViewConvert,
2892 direction: gst::GstPadDirection,
2893 caps: *mut gst::GstCaps,
2894 filter: *mut gst::GstCaps,
2895 ) -> *mut gst::GstCaps;
2896
2897 //=========================================================================
2898 // GstGLWindow
2899 //=========================================================================
2900 pub unsafefn gst_gl_window_get_type() -> GType;
2901 pub unsafefn gst_gl_window_new(display: *mut GstGLDisplay) -> *mut GstGLWindow;
2902 #[cfg(feature = "v1_16")]
2903 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2904 pub fn gst_gl_window_controls_viewport(window: *mut GstGLWindow) -> gboolean;
2905 pub unsafefn gst_gl_window_draw(window: *mut GstGLWindow);
2906 pub unsafefn gst_gl_window_get_context(window: *mut GstGLWindow) -> *mut GstGLContext;
2907 pub unsafefn gst_gl_window_get_display(window: *mut GstGLWindow) -> uintptr_t;
2908 pub unsafefn gst_gl_window_get_surface_dimensions(
2909 window: *mut GstGLWindow,
2910 width: *mut c_uint,
2911 height: *mut c_uint,
2912 );
2913 pub unsafefn gst_gl_window_get_window_handle(window: *mut GstGLWindow) -> uintptr_t;
2914 pub unsafefn gst_gl_window_handle_events(window: *mut GstGLWindow, handle_events: gboolean);
2915 #[cfg(feature = "v1_18")]
2916 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2917 pub fn gst_gl_window_has_output_surface(window: *mut GstGLWindow) -> gboolean;
2918 pub unsafefn gst_gl_window_queue_resize(window: *mut GstGLWindow);
2919 pub unsafefn gst_gl_window_quit(window: *mut GstGLWindow);
2920 pub unsafefn gst_gl_window_resize(window: *mut GstGLWindow, width: c_uint, height: c_uint);
2921 pub unsafefn gst_gl_window_run(window: *mut GstGLWindow);
2922 pub unsafefn gst_gl_window_send_key_event(
2923 window: *mut GstGLWindow,
2924 event_type: *const c_char,
2925 key_str: *const c_char,
2926 );
2927 pub unsafefn gst_gl_window_send_message(
2928 window: *mut GstGLWindow,
2929 callback: GstGLWindowCB,
2930 data: gpointer,
2931 );
2932 pub unsafefn gst_gl_window_send_message_async(
2933 window: *mut GstGLWindow,
2934 callback: GstGLWindowCB,
2935 data: gpointer,
2936 destroy: glib::GDestroyNotify,
2937 );
2938 pub unsafefn gst_gl_window_send_mouse_event(
2939 window: *mut GstGLWindow,
2940 event_type: *const c_char,
2941 button: c_int,
2942 posx: c_double,
2943 posy: c_double,
2944 );
2945 #[cfg(feature = "v1_18")]
2946 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2947 pub fn gst_gl_window_send_scroll_event(
2948 window: *mut GstGLWindow,
2949 posx: c_double,
2950 posy: c_double,
2951 delta_x: c_double,
2952 delta_y: c_double,
2953 );
2954 pub unsafefn gst_gl_window_set_close_callback(
2955 window: *mut GstGLWindow,
2956 callback: GstGLWindowCB,
2957 data: gpointer,
2958 destroy_notify: glib::GDestroyNotify,
2959 );
2960 pub unsafefn gst_gl_window_set_draw_callback(
2961 window: *mut GstGLWindow,
2962 callback: GstGLWindowCB,
2963 data: gpointer,
2964 destroy_notify: glib::GDestroyNotify,
2965 );
2966 pub unsafefn gst_gl_window_set_preferred_size(window: *mut GstGLWindow, width: c_int, height: c_int);
2967 pub unsafefn gst_gl_window_set_render_rectangle(
2968 window: *mut GstGLWindow,
2969 x: c_int,
2970 y: c_int,
2971 width: c_int,
2972 height: c_int,
2973 ) -> gboolean;
2974 pub unsafefn gst_gl_window_set_resize_callback(
2975 window: *mut GstGLWindow,
2976 callback: GstGLWindowResizeCB,
2977 data: gpointer,
2978 destroy_notify: glib::GDestroyNotify,
2979 );
2980 pub unsafefn gst_gl_window_set_window_handle(window: *mut GstGLWindow, handle: uintptr_t);
2981 pub unsafefn gst_gl_window_show(window: *mut GstGLWindow);
2982
2983 //=========================================================================
2984 // Other functions
2985 //=========================================================================
2986 pub unsafefn gst_buffer_add_gl_sync_meta(
2987 context: *mut GstGLContext,
2988 buffer: *mut gst::GstBuffer,
2989 ) -> *mut GstGLSyncMeta;
2990 pub unsafefn gst_buffer_add_gl_sync_meta_full(
2991 context: *mut GstGLContext,
2992 buffer: *mut gst::GstBuffer,
2993 data: gpointer,
2994 ) -> *mut GstGLSyncMeta;
2995 pub unsafefn gst_buffer_pool_config_get_gl_allocation_params(
2996 config: *mut gst::GstStructure,
2997 ) -> *mut GstGLAllocationParams;
2998 #[cfg(feature = "v1_24")]
2999 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
3000 pub fn gst_buffer_pool_config_get_gl_min_free_queue_size(
3001 config: *mut gst::GstStructure,
3002 ) -> c_uint;
3003 pub unsafefn gst_buffer_pool_config_set_gl_allocation_params(
3004 config: *mut gst::GstStructure,
3005 params: *const GstGLAllocationParams,
3006 );
3007 #[cfg(feature = "v1_24")]
3008 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
3009 pub fn gst_buffer_pool_config_set_gl_min_free_queue_size(
3010 config: *mut gst::GstStructure,
3011 queue_size: c_uint,
3012 );
3013 pub unsafefn gst_context_get_gl_display(
3014 context: *mut gst::GstContext,
3015 display: *mut *mut GstGLDisplay,
3016 ) -> gboolean;
3017 pub unsafefn gst_context_set_gl_display(context: *mut gst::GstContext, display: *mut GstGLDisplay);
3018 pub unsafefn gst_gl_check_extension(name: *const c_char, ext: *const c_char) -> gboolean;
3019 #[cfg(feature = "v1_26")]
3020 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
3021 pub fn gst_gl_dma_buf_transform_drm_formats_to_gst_formats(
3022 context: *mut GstGLContext,
3023 src: *const gobject::GValue,
3024 flags: GstGLDrmFormatFlags,
3025 dst: *mut gobject::GValue,
3026 ) -> gboolean;
3027 #[cfg(feature = "v1_26")]
3028 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
3029 pub fn gst_gl_dma_buf_transform_gst_formats_to_drm_formats(
3030 context: *mut GstGLContext,
3031 src: *const gobject::GValue,
3032 flags: GstGLDrmFormatFlags,
3033 dst: *mut gobject::GValue,
3034 ) -> gboolean;
3035 pub unsafefn gst_gl_element_propagate_display_context(
3036 element: *mut gst::GstElement,
3037 display: *mut GstGLDisplay,
3038 );
3039 pub unsafefn gst_gl_ensure_element_data(
3040 element: *mut gst::GstElement,
3041 display_ptr: *mut *mut GstGLDisplay,
3042 other_context_ptr: *mut *mut GstGLContext,
3043 ) -> gboolean;
3044 #[cfg(feature = "v1_20")]
3045 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
3046 pub fn gst_gl_get_affine_transformation_meta_as_ndc(
3047 meta: *mut gst_video::GstVideoAffineTransformationMeta,
3048 matrix: *mut [c_float; 16],
3049 );
3050 pub unsafefn gst_gl_get_plane_data_size(
3051 info: *const gst_video::GstVideoInfo,
3052 align: *const gst_video::GstVideoAlignment,
3053 plane: c_uint,
3054 ) -> size_t;
3055 pub unsafefn gst_gl_get_plane_start(
3056 info: *const gst_video::GstVideoInfo,
3057 valign: *const gst_video::GstVideoAlignment,
3058 plane: c_uint,
3059 ) -> size_t;
3060 pub unsafefn gst_gl_handle_context_query(
3061 element: *mut gst::GstElement,
3062 query: *mut gst::GstQuery,
3063 display: *mut GstGLDisplay,
3064 context: *mut GstGLContext,
3065 other_context: *mut GstGLContext,
3066 ) -> gboolean;
3067 pub unsafefn gst_gl_handle_set_context(
3068 element: *mut gst::GstElement,
3069 context: *mut gst::GstContext,
3070 display: *mut *mut GstGLDisplay,
3071 other_context: *mut *mut GstGLContext,
3072 ) -> gboolean;
3073 pub unsafefn gst_gl_insert_debug_marker(context: *mut GstGLContext, format: *const c_char, ...);
3074 #[cfg(feature = "v1_20")]
3075 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
3076 pub fn gst_gl_multiply_matrix4(
3077 a: *const [c_float; 16],
3078 b: *const [c_float; 16],
3079 result: *mut [c_float; 16],
3080 );
3081 #[cfg(feature = "v1_20")]
3082 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
3083 pub fn gst_gl_set_affine_transformation_meta_from_ndc(
3084 meta: *mut gst_video::GstVideoAffineTransformationMeta,
3085 matrix: *const [c_float; 16],
3086 );
3087 pub unsafefn gst_gl_sized_gl_format_from_gl_format_type(
3088 context: *mut GstGLContext,
3089 format: c_uint,
3090 type_: c_uint,
3091 ) -> c_uint;
3092 pub unsafefn gst_gl_stereo_downmix_mode_get_type() -> GType;
3093 #[cfg(feature = "v1_24")]
3094 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
3095 pub fn gst_gl_swizzle_invert(swizzle: *mut [c_int; 4], inversion: *mut [c_int; 4]);
3096 pub unsafefn gst_gl_sync_meta_api_get_type() -> GType;
3097 pub unsafefn gst_gl_value_get_texture_target_mask(
3098 value: *const gobject::GValue,
3099 ) -> GstGLTextureTarget;
3100 pub unsafefn gst_gl_value_set_texture_target(
3101 value: *mut gobject::GValue,
3102 target: GstGLTextureTarget,
3103 ) -> gboolean;
3104 pub unsafefn gst_gl_value_set_texture_target_from_mask(
3105 value: *mut gobject::GValue,
3106 target_mask: GstGLTextureTarget,
3107 ) -> gboolean;
3108 pub unsafefn gst_gl_version_to_glsl_version(
3109 gl_api: GstGLAPI,
3110 maj: c_int,
3111 min: c_int,
3112 ) -> GstGLSLVersion;
3113 #[cfg(feature = "v1_24")]
3114 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
3115 pub fn gst_gl_video_format_swizzle(
3116 video_format: gst_video::GstVideoFormat,
3117 swizzle: *mut [c_int; 4],
3118 ) -> gboolean;
3119 pub unsafefn gst_glsl_string_get_version_profile(
3120 s: *const c_char,
3121 version: *mut GstGLSLVersion,
3122 profile: *mut GstGLSLProfile,
3123 ) -> gboolean;
3124 pub unsafefn gst_is_gl_base_memory(mem: *mut gst::GstMemory) -> gboolean;
3125 pub unsafefn gst_is_gl_buffer(mem: *mut gst::GstMemory) -> gboolean;
3126 pub unsafefn gst_is_gl_memory(mem: *mut gst::GstMemory) -> gboolean;
3127 pub unsafefn gst_is_gl_memory_pbo(mem: *mut gst::GstMemory) -> gboolean;
3128 pub unsafefn gst_is_gl_renderbuffer(mem: *mut gst::GstMemory) -> gboolean;
3129
3130}
3131