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