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
2204 pub fn gst_gl_buffer_allocator_get_type() -> GType;
2208
2209 pub fn gst_gl_buffer_pool_get_type() -> GType;
2213 pub fn gst_gl_buffer_pool_new(context: *mut GstGLContext) -> *mut gst::GstBufferPool;
2214 #[cfg(feature = "v1_20")]
2215 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2216 pub fn gst_gl_buffer_pool_get_gl_allocation_params(
2217 pool: *mut GstGLBufferPool,
2218 ) -> *mut GstGLAllocationParams;
2219
2220 pub fn gst_gl_color_convert_get_type() -> GType;
2224 pub fn gst_gl_color_convert_new(context: *mut GstGLContext) -> *mut GstGLColorConvert;
2225 pub fn gst_gl_color_convert_fixate_caps(
2226 context: *mut GstGLContext,
2227 direction: gst::GstPadDirection,
2228 caps: *mut gst::GstCaps,
2229 other: *mut gst::GstCaps,
2230 ) -> *mut gst::GstCaps;
2231 #[cfg(feature = "v1_24")]
2232 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2233 pub fn gst_gl_color_convert_swizzle_shader_string(context: *mut GstGLContext) -> *mut c_char;
2234 pub fn gst_gl_color_convert_transform_caps(
2235 context: *mut GstGLContext,
2236 direction: gst::GstPadDirection,
2237 caps: *mut gst::GstCaps,
2238 filter: *mut gst::GstCaps,
2239 ) -> *mut gst::GstCaps;
2240 #[cfg(feature = "v1_24")]
2241 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2242 pub fn gst_gl_color_convert_yuv_to_rgb_shader_string(context: *mut GstGLContext)
2243 -> *mut c_char;
2244 pub fn gst_gl_color_convert_decide_allocation(
2245 convert: *mut GstGLColorConvert,
2246 query: *mut gst::GstQuery,
2247 ) -> gboolean;
2248 pub fn gst_gl_color_convert_perform(
2249 convert: *mut GstGLColorConvert,
2250 inbuf: *mut gst::GstBuffer,
2251 ) -> *mut gst::GstBuffer;
2252 pub fn gst_gl_color_convert_set_caps(
2253 convert: *mut GstGLColorConvert,
2254 in_caps: *mut gst::GstCaps,
2255 out_caps: *mut gst::GstCaps,
2256 ) -> gboolean;
2257
2258 pub fn gst_gl_context_get_type() -> GType;
2262 pub fn gst_gl_context_new(display: *mut GstGLDisplay) -> *mut GstGLContext;
2263 pub fn gst_gl_context_new_wrapped(
2264 display: *mut GstGLDisplay,
2265 handle: uintptr_t,
2266 context_type: GstGLPlatform,
2267 available_apis: GstGLAPI,
2268 ) -> *mut GstGLContext;
2269 pub fn gst_gl_context_default_get_proc_address(
2270 gl_api: GstGLAPI,
2271 name: *const c_char,
2272 ) -> gpointer;
2273 pub fn gst_gl_context_get_current() -> *mut GstGLContext;
2274 pub fn gst_gl_context_get_current_gl_api(
2275 platform: GstGLPlatform,
2276 major: *mut c_uint,
2277 minor: *mut c_uint,
2278 ) -> GstGLAPI;
2279 pub fn gst_gl_context_get_current_gl_context(context_type: GstGLPlatform) -> uintptr_t;
2280 pub fn gst_gl_context_get_proc_address_with_platform(
2281 context_type: GstGLPlatform,
2282 gl_api: GstGLAPI,
2283 name: *const c_char,
2284 ) -> gpointer;
2285 pub fn gst_gl_context_activate(context: *mut GstGLContext, activate: gboolean) -> gboolean;
2286 pub fn gst_gl_context_can_share(
2287 context: *mut GstGLContext,
2288 other_context: *mut GstGLContext,
2289 ) -> gboolean;
2290 pub fn gst_gl_context_check_feature(
2291 context: *mut GstGLContext,
2292 feature: *const c_char,
2293 ) -> gboolean;
2294 pub fn gst_gl_context_check_framebuffer_status(
2295 context: *mut GstGLContext,
2296 fbo_target: c_uint,
2297 ) -> gboolean;
2298 pub fn gst_gl_context_check_gl_version(
2299 context: *mut GstGLContext,
2300 api: GstGLAPI,
2301 maj: c_int,
2302 min: c_int,
2303 ) -> gboolean;
2304 pub fn gst_gl_context_clear_framebuffer(context: *mut GstGLContext);
2305 pub fn gst_gl_context_clear_shader(context: *mut GstGLContext);
2306 pub fn gst_gl_context_create(
2307 context: *mut GstGLContext,
2308 other_context: *mut GstGLContext,
2309 error: *mut *mut glib::GError,
2310 ) -> gboolean;
2311 pub fn gst_gl_context_destroy(context: *mut GstGLContext);
2312 pub fn gst_gl_context_fill_info(
2313 context: *mut GstGLContext,
2314 error: *mut *mut glib::GError,
2315 ) -> gboolean;
2316 #[cfg(feature = "v1_20")]
2317 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2318 pub fn gst_gl_context_get_config(context: *mut GstGLContext) -> *mut gst::GstStructure;
2319 pub fn gst_gl_context_get_display(context: *mut GstGLContext) -> *mut GstGLDisplay;
2320 pub fn gst_gl_context_get_gl_api(context: *mut GstGLContext) -> GstGLAPI;
2321 pub fn gst_gl_context_get_gl_context(context: *mut GstGLContext) -> uintptr_t;
2322 pub fn gst_gl_context_get_gl_platform(context: *mut GstGLContext) -> GstGLPlatform;
2323 pub fn gst_gl_context_get_gl_platform_version(
2324 context: *mut GstGLContext,
2325 major: *mut c_int,
2326 minor: *mut c_int,
2327 );
2328 pub fn gst_gl_context_get_gl_version(
2329 context: *mut GstGLContext,
2330 maj: *mut c_int,
2331 min: *mut c_int,
2332 );
2333 pub fn gst_gl_context_get_proc_address(
2334 context: *mut GstGLContext,
2335 name: *const c_char,
2336 ) -> gpointer;
2337 pub fn gst_gl_context_get_thread(context: *mut GstGLContext) -> *mut glib::GThread;
2338 pub fn gst_gl_context_get_window(context: *mut GstGLContext) -> *mut GstGLWindow;
2339 pub fn gst_gl_context_is_shared(context: *mut GstGLContext) -> gboolean;
2340 #[cfg(feature = "v1_20")]
2341 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2342 pub fn gst_gl_context_request_config(
2343 context: *mut GstGLContext,
2344 gl_config: *mut gst::GstStructure,
2345 ) -> gboolean;
2346 pub fn gst_gl_context_set_shared_with(context: *mut GstGLContext, share: *mut GstGLContext);
2347 pub fn gst_gl_context_set_window(
2348 context: *mut GstGLContext,
2349 window: *mut GstGLWindow,
2350 ) -> gboolean;
2351 pub fn gst_gl_context_supports_glsl_profile_version(
2352 context: *mut GstGLContext,
2353 version: GstGLSLVersion,
2354 profile: GstGLSLProfile,
2355 ) -> gboolean;
2356 #[cfg(feature = "v1_16")]
2357 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2358 pub fn gst_gl_context_supports_precision(
2359 context: *mut GstGLContext,
2360 version: GstGLSLVersion,
2361 profile: GstGLSLProfile,
2362 ) -> gboolean;
2363 #[cfg(feature = "v1_16")]
2364 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2365 pub fn gst_gl_context_supports_precision_highp(
2366 context: *mut GstGLContext,
2367 version: GstGLSLVersion,
2368 profile: GstGLSLProfile,
2369 ) -> gboolean;
2370 pub fn gst_gl_context_swap_buffers(context: *mut GstGLContext);
2371 pub fn gst_gl_context_thread_add(
2372 context: *mut GstGLContext,
2373 func: GstGLContextThreadFunc,
2374 data: gpointer,
2375 );
2376
2377 pub fn gst_gl_display_get_type() -> GType;
2381 pub fn gst_gl_display_new() -> *mut GstGLDisplay;
2382 #[cfg(feature = "v1_20")]
2383 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2384 pub fn gst_gl_display_new_with_type(type_: GstGLDisplayType) -> *mut GstGLDisplay;
2385 pub fn gst_gl_display_add_context(
2386 display: *mut GstGLDisplay,
2387 context: *mut GstGLContext,
2388 ) -> gboolean;
2389 pub fn gst_gl_display_create_context(
2390 display: *mut GstGLDisplay,
2391 other_context: *mut GstGLContext,
2392 p_context: *mut *mut GstGLContext,
2393 error: *mut *mut glib::GError,
2394 ) -> gboolean;
2395 pub fn gst_gl_display_create_window(display: *mut GstGLDisplay) -> *mut GstGLWindow;
2396 #[cfg(feature = "v1_24")]
2397 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2398 pub fn gst_gl_display_ensure_context(
2399 display: *mut GstGLDisplay,
2400 other_context: *mut GstGLContext,
2401 context: *mut *mut GstGLContext,
2402 error: *mut *mut glib::GError,
2403 ) -> gboolean;
2404 pub fn gst_gl_display_filter_gl_api(display: *mut GstGLDisplay, gl_api: GstGLAPI);
2405 pub fn gst_gl_display_find_window(
2406 display: *mut GstGLDisplay,
2407 data: gpointer,
2408 compare_func: glib::GCompareFunc,
2409 ) -> *mut GstGLWindow;
2410 pub fn gst_gl_display_get_gl_api(display: *mut GstGLDisplay) -> GstGLAPI;
2411 pub fn gst_gl_display_get_gl_api_unlocked(display: *mut GstGLDisplay) -> GstGLAPI;
2412 pub fn gst_gl_display_get_gl_context_for_thread(
2413 display: *mut GstGLDisplay,
2414 thread: *mut glib::GThread,
2415 ) -> *mut GstGLContext;
2416 pub fn gst_gl_display_get_handle(display: *mut GstGLDisplay) -> uintptr_t;
2417 pub fn gst_gl_display_get_handle_type(display: *mut GstGLDisplay) -> GstGLDisplayType;
2418 #[cfg(feature = "v1_18")]
2419 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2420 pub fn gst_gl_display_remove_context(display: *mut GstGLDisplay, context: *mut GstGLContext);
2421 pub fn gst_gl_display_remove_window(
2422 display: *mut GstGLDisplay,
2423 window: *mut GstGLWindow,
2424 ) -> gboolean;
2425 #[cfg(feature = "v1_18")]
2426 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2427 pub fn gst_gl_display_retrieve_window(
2428 display: *mut GstGLDisplay,
2429 data: gpointer,
2430 compare_func: glib::GCompareFunc,
2431 ) -> *mut GstGLWindow;
2432
2433 pub fn gst_gl_filter_get_type() -> GType;
2437 pub fn gst_gl_filter_add_rgba_pad_templates(klass: *mut GstGLFilterClass);
2438 pub fn gst_gl_filter_draw_fullscreen_quad(filter: *mut GstGLFilter);
2439 pub fn gst_gl_filter_filter_texture(
2440 filter: *mut GstGLFilter,
2441 input: *mut gst::GstBuffer,
2442 output: *mut gst::GstBuffer,
2443 ) -> gboolean;
2444 pub fn gst_gl_filter_render_to_target(
2445 filter: *mut GstGLFilter,
2446 input: *mut GstGLMemory,
2447 output: *mut GstGLMemory,
2448 func: GstGLFilterRenderFunc,
2449 data: gpointer,
2450 ) -> gboolean;
2451 pub fn gst_gl_filter_render_to_target_with_shader(
2452 filter: *mut GstGLFilter,
2453 input: *mut GstGLMemory,
2454 output: *mut GstGLMemory,
2455 shader: *mut GstGLShader,
2456 );
2457
2458 pub fn gst_gl_framebuffer_get_type() -> GType;
2462 pub fn gst_gl_framebuffer_new(context: *mut GstGLContext) -> *mut GstGLFramebuffer;
2463 pub fn gst_gl_framebuffer_new_with_default_depth(
2464 context: *mut GstGLContext,
2465 width: c_uint,
2466 height: c_uint,
2467 ) -> *mut GstGLFramebuffer;
2468 pub fn gst_gl_framebuffer_attach(
2469 fb: *mut GstGLFramebuffer,
2470 attachment_point: c_uint,
2471 mem: *mut GstGLBaseMemory,
2472 );
2473 pub fn gst_gl_framebuffer_bind(fb: *mut GstGLFramebuffer);
2474 pub fn gst_gl_framebuffer_draw_to_texture(
2475 fb: *mut GstGLFramebuffer,
2476 mem: *mut GstGLMemory,
2477 func: GstGLFramebufferFunc,
2478 user_data: gpointer,
2479 ) -> gboolean;
2480 pub fn gst_gl_framebuffer_get_effective_dimensions(
2481 fb: *mut GstGLFramebuffer,
2482 width: *mut c_uint,
2483 height: *mut c_uint,
2484 );
2485 pub fn gst_gl_framebuffer_get_id(fb: *mut GstGLFramebuffer) -> c_uint;
2486
2487 pub fn gst_gl_memory_allocator_get_type() -> GType;
2491 pub fn gst_gl_memory_allocator_get_default(
2492 context: *mut GstGLContext,
2493 ) -> *mut GstGLMemoryAllocator;
2494
2495 pub fn gst_gl_memory_pbo_allocator_get_type() -> GType;
2499
2500 #[cfg(feature = "v1_24")]
2504 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2505 pub fn gst_gl_mixer_get_type() -> GType;
2506 #[cfg(feature = "v1_24")]
2507 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2508 pub fn gst_gl_mixer_get_framebuffer(mix: *mut GstGLMixer) -> *mut GstGLFramebuffer;
2509 #[cfg(feature = "v1_24")]
2510 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2511 pub fn gst_gl_mixer_process_textures(
2512 mix: *mut GstGLMixer,
2513 outbuf: *mut gst::GstBuffer,
2514 ) -> gboolean;
2515
2516 #[cfg(feature = "v1_24")]
2520 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2521 pub fn gst_gl_mixer_pad_get_type() -> GType;
2522
2523 pub fn gst_gl_overlay_compositor_get_type() -> GType;
2527 pub fn gst_gl_overlay_compositor_new(context: *mut GstGLContext)
2528 -> *mut GstGLOverlayCompositor;
2529 pub fn gst_gl_overlay_compositor_add_caps(caps: *mut gst::GstCaps) -> *mut gst::GstCaps;
2530 pub fn gst_gl_overlay_compositor_draw_overlays(compositor: *mut GstGLOverlayCompositor);
2531 pub fn gst_gl_overlay_compositor_free_overlays(compositor: *mut GstGLOverlayCompositor);
2532 pub fn gst_gl_overlay_compositor_upload_overlays(
2533 compositor: *mut GstGLOverlayCompositor,
2534 buf: *mut gst::GstBuffer,
2535 );
2536
2537 pub fn gst_gl_renderbuffer_allocator_get_type() -> GType;
2541
2542 pub fn gst_glsl_stage_get_type() -> GType;
2546 pub fn gst_glsl_stage_new(context: *mut GstGLContext, type_: c_uint) -> *mut GstGLSLStage;
2547 pub fn gst_glsl_stage_new_default_fragment(context: *mut GstGLContext) -> *mut GstGLSLStage;
2548 pub fn gst_glsl_stage_new_default_vertex(context: *mut GstGLContext) -> *mut GstGLSLStage;
2549 pub fn gst_glsl_stage_new_with_string(
2550 context: *mut GstGLContext,
2551 type_: c_uint,
2552 version: GstGLSLVersion,
2553 profile: GstGLSLProfile,
2554 str: *const c_char,
2555 ) -> *mut GstGLSLStage;
2556 pub fn gst_glsl_stage_new_with_strings(
2557 context: *mut GstGLContext,
2558 type_: c_uint,
2559 version: GstGLSLVersion,
2560 profile: GstGLSLProfile,
2561 n_strings: c_int,
2562 str: *mut *const c_char,
2563 ) -> *mut GstGLSLStage;
2564 pub fn gst_glsl_stage_compile(
2565 stage: *mut GstGLSLStage,
2566 error: *mut *mut glib::GError,
2567 ) -> gboolean;
2568 pub fn gst_glsl_stage_get_handle(stage: *mut GstGLSLStage) -> c_uint;
2569 pub fn gst_glsl_stage_get_profile(stage: *mut GstGLSLStage) -> GstGLSLProfile;
2570 pub fn gst_glsl_stage_get_shader_type(stage: *mut GstGLSLStage) -> c_uint;
2571 pub fn gst_glsl_stage_get_version(stage: *mut GstGLSLStage) -> GstGLSLVersion;
2572 pub fn gst_glsl_stage_set_strings(
2573 stage: *mut GstGLSLStage,
2574 version: GstGLSLVersion,
2575 profile: GstGLSLProfile,
2576 n_strings: c_int,
2577 str: *mut *const c_char,
2578 ) -> gboolean;
2579
2580 pub fn gst_gl_shader_get_type() -> GType;
2584 pub fn gst_gl_shader_new(context: *mut GstGLContext) -> *mut GstGLShader;
2585 pub fn gst_gl_shader_new_default(
2586 context: *mut GstGLContext,
2587 error: *mut *mut glib::GError,
2588 ) -> *mut GstGLShader;
2589 pub fn gst_gl_shader_new_link_with_stages(
2590 context: *mut GstGLContext,
2591 error: *mut *mut glib::GError,
2592 ...
2593 ) -> *mut GstGLShader;
2594 pub fn gst_gl_shader_new_with_stages(
2595 context: *mut GstGLContext,
2596 error: *mut *mut glib::GError,
2597 ...
2598 ) -> *mut GstGLShader;
2599 #[cfg(feature = "v1_16")]
2600 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2601 pub fn gst_gl_shader_string_fragment_external_oes_get_default(
2602 context: *mut GstGLContext,
2603 version: GstGLSLVersion,
2604 profile: GstGLSLProfile,
2605 ) -> *mut c_char;
2606 #[cfg(feature = "v1_16")]
2607 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2608 pub fn gst_gl_shader_string_fragment_get_default(
2609 context: *mut GstGLContext,
2610 version: GstGLSLVersion,
2611 profile: GstGLSLProfile,
2612 ) -> *mut c_char;
2613 #[cfg(feature = "v1_16")]
2614 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2615 pub fn gst_gl_shader_string_get_highest_precision(
2616 context: *mut GstGLContext,
2617 version: GstGLSLVersion,
2618 profile: GstGLSLProfile,
2619 ) -> *const c_char;
2620 pub fn gst_gl_shader_attach(shader: *mut GstGLShader, stage: *mut GstGLSLStage) -> gboolean;
2621 pub fn gst_gl_shader_attach_unlocked(
2622 shader: *mut GstGLShader,
2623 stage: *mut GstGLSLStage,
2624 ) -> gboolean;
2625 pub fn gst_gl_shader_bind_attribute_location(
2626 shader: *mut GstGLShader,
2627 index: c_uint,
2628 name: *const c_char,
2629 );
2630 pub fn gst_gl_shader_bind_frag_data_location(
2631 shader: *mut GstGLShader,
2632 index: c_uint,
2633 name: *const c_char,
2634 );
2635 pub fn gst_gl_shader_compile_attach_stage(
2636 shader: *mut GstGLShader,
2637 stage: *mut GstGLSLStage,
2638 error: *mut *mut glib::GError,
2639 ) -> gboolean;
2640 pub fn gst_gl_shader_detach(shader: *mut GstGLShader, stage: *mut GstGLSLStage);
2641 pub fn gst_gl_shader_detach_unlocked(shader: *mut GstGLShader, stage: *mut GstGLSLStage);
2642 pub fn gst_gl_shader_get_attribute_location(
2643 shader: *mut GstGLShader,
2644 name: *const c_char,
2645 ) -> c_int;
2646 pub fn gst_gl_shader_get_program_handle(shader: *mut GstGLShader) -> c_int;
2647 pub fn gst_gl_shader_is_linked(shader: *mut GstGLShader) -> gboolean;
2648 pub fn gst_gl_shader_link(shader: *mut GstGLShader, error: *mut *mut glib::GError) -> gboolean;
2649 pub fn gst_gl_shader_release(shader: *mut GstGLShader);
2650 pub fn gst_gl_shader_release_unlocked(shader: *mut GstGLShader);
2651 pub fn gst_gl_shader_set_uniform_1f(
2652 shader: *mut GstGLShader,
2653 name: *const c_char,
2654 value: c_float,
2655 );
2656 pub fn gst_gl_shader_set_uniform_1fv(
2657 shader: *mut GstGLShader,
2658 name: *const c_char,
2659 count: c_uint,
2660 value: *const c_float,
2661 );
2662 pub fn gst_gl_shader_set_uniform_1i(
2663 shader: *mut GstGLShader,
2664 name: *const c_char,
2665 value: c_int,
2666 );
2667 pub fn gst_gl_shader_set_uniform_1iv(
2668 shader: *mut GstGLShader,
2669 name: *const c_char,
2670 count: c_uint,
2671 value: *const c_int,
2672 );
2673 pub fn gst_gl_shader_set_uniform_2f(
2674 shader: *mut GstGLShader,
2675 name: *const c_char,
2676 v0: c_float,
2677 v1: c_float,
2678 );
2679 pub fn gst_gl_shader_set_uniform_2fv(
2680 shader: *mut GstGLShader,
2681 name: *const c_char,
2682 count: c_uint,
2683 value: *const c_float,
2684 );
2685 pub fn gst_gl_shader_set_uniform_2i(
2686 shader: *mut GstGLShader,
2687 name: *const c_char,
2688 v0: c_int,
2689 v1: c_int,
2690 );
2691 pub fn gst_gl_shader_set_uniform_2iv(
2692 shader: *mut GstGLShader,
2693 name: *const c_char,
2694 count: c_uint,
2695 value: *const c_int,
2696 );
2697 pub fn gst_gl_shader_set_uniform_3f(
2698 shader: *mut GstGLShader,
2699 name: *const c_char,
2700 v0: c_float,
2701 v1: c_float,
2702 v2: c_float,
2703 );
2704 pub fn gst_gl_shader_set_uniform_3fv(
2705 shader: *mut GstGLShader,
2706 name: *const c_char,
2707 count: c_uint,
2708 value: *const c_float,
2709 );
2710 pub fn gst_gl_shader_set_uniform_3i(
2711 shader: *mut GstGLShader,
2712 name: *const c_char,
2713 v0: c_int,
2714 v1: c_int,
2715 v2: c_int,
2716 );
2717 pub fn gst_gl_shader_set_uniform_3iv(
2718 shader: *mut GstGLShader,
2719 name: *const c_char,
2720 count: c_uint,
2721 value: *const c_int,
2722 );
2723 pub fn gst_gl_shader_set_uniform_4f(
2724 shader: *mut GstGLShader,
2725 name: *const c_char,
2726 v0: c_float,
2727 v1: c_float,
2728 v2: c_float,
2729 v3: c_float,
2730 );
2731 pub fn gst_gl_shader_set_uniform_4fv(
2732 shader: *mut GstGLShader,
2733 name: *const c_char,
2734 count: c_uint,
2735 value: *const c_float,
2736 );
2737 pub fn gst_gl_shader_set_uniform_4i(
2738 shader: *mut GstGLShader,
2739 name: *const c_char,
2740 v0: c_int,
2741 v1: c_int,
2742 v2: c_int,
2743 v3: c_int,
2744 );
2745 pub fn gst_gl_shader_set_uniform_4iv(
2746 shader: *mut GstGLShader,
2747 name: *const c_char,
2748 count: c_uint,
2749 value: *const c_int,
2750 );
2751 pub fn gst_gl_shader_set_uniform_matrix_2fv(
2752 shader: *mut GstGLShader,
2753 name: *const c_char,
2754 count: c_int,
2755 transpose: gboolean,
2756 value: *const c_float,
2757 );
2758 pub fn gst_gl_shader_set_uniform_matrix_2x3fv(
2759 shader: *mut GstGLShader,
2760 name: *const c_char,
2761 count: c_int,
2762 transpose: gboolean,
2763 value: *const c_float,
2764 );
2765 pub fn gst_gl_shader_set_uniform_matrix_2x4fv(
2766 shader: *mut GstGLShader,
2767 name: *const c_char,
2768 count: c_int,
2769 transpose: gboolean,
2770 value: *const c_float,
2771 );
2772 pub fn gst_gl_shader_set_uniform_matrix_3fv(
2773 shader: *mut GstGLShader,
2774 name: *const c_char,
2775 count: c_int,
2776 transpose: gboolean,
2777 value: *const c_float,
2778 );
2779 pub fn gst_gl_shader_set_uniform_matrix_3x2fv(
2780 shader: *mut GstGLShader,
2781 name: *const c_char,
2782 count: c_int,
2783 transpose: gboolean,
2784 value: *const c_float,
2785 );
2786 pub fn gst_gl_shader_set_uniform_matrix_3x4fv(
2787 shader: *mut GstGLShader,
2788 name: *const c_char,
2789 count: c_int,
2790 transpose: gboolean,
2791 value: *const c_float,
2792 );
2793 pub fn gst_gl_shader_set_uniform_matrix_4fv(
2794 shader: *mut GstGLShader,
2795 name: *const c_char,
2796 count: c_int,
2797 transpose: gboolean,
2798 value: *const c_float,
2799 );
2800 pub fn gst_gl_shader_set_uniform_matrix_4x2fv(
2801 shader: *mut GstGLShader,
2802 name: *const c_char,
2803 count: c_int,
2804 transpose: gboolean,
2805 value: *const c_float,
2806 );
2807 pub fn gst_gl_shader_set_uniform_matrix_4x3fv(
2808 shader: *mut GstGLShader,
2809 name: *const c_char,
2810 count: c_int,
2811 transpose: gboolean,
2812 value: *const c_float,
2813 );
2814 pub fn gst_gl_shader_use(shader: *mut GstGLShader);
2815
2816 pub fn gst_gl_upload_get_type() -> GType;
2820 pub fn gst_gl_upload_new(context: *mut GstGLContext) -> *mut GstGLUpload;
2821 pub fn gst_gl_upload_get_input_template_caps() -> *mut gst::GstCaps;
2822 #[cfg(feature = "v1_24")]
2823 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2824 pub fn gst_gl_upload_fixate_caps(
2825 upload: *mut GstGLUpload,
2826 direction: gst::GstPadDirection,
2827 caps: *mut gst::GstCaps,
2828 othercaps: *mut gst::GstCaps,
2829 ) -> *mut gst::GstCaps;
2830 pub fn gst_gl_upload_get_caps(
2831 upload: *mut GstGLUpload,
2832 in_caps: *mut *mut gst::GstCaps,
2833 out_caps: *mut *mut gst::GstCaps,
2834 );
2835 pub fn gst_gl_upload_perform_with_buffer(
2836 upload: *mut GstGLUpload,
2837 buffer: *mut gst::GstBuffer,
2838 outbuf_ptr: *mut *mut gst::GstBuffer,
2839 ) -> GstGLUploadReturn;
2840 pub fn gst_gl_upload_propose_allocation(
2841 upload: *mut GstGLUpload,
2842 decide_query: *mut gst::GstQuery,
2843 query: *mut gst::GstQuery,
2844 );
2845 pub fn gst_gl_upload_set_caps(
2846 upload: *mut GstGLUpload,
2847 in_caps: *mut gst::GstCaps,
2848 out_caps: *mut gst::GstCaps,
2849 ) -> gboolean;
2850 pub fn gst_gl_upload_set_context(upload: *mut GstGLUpload, context: *mut GstGLContext);
2851 pub fn gst_gl_upload_transform_caps(
2852 upload: *mut GstGLUpload,
2853 context: *mut GstGLContext,
2854 direction: gst::GstPadDirection,
2855 caps: *mut gst::GstCaps,
2856 filter: *mut gst::GstCaps,
2857 ) -> *mut gst::GstCaps;
2858
2859 pub fn gst_gl_view_convert_get_type() -> GType;
2863 pub fn gst_gl_view_convert_new() -> *mut GstGLViewConvert;
2864 pub fn gst_gl_view_convert_fixate_caps(
2865 viewconvert: *mut GstGLViewConvert,
2866 direction: gst::GstPadDirection,
2867 caps: *mut gst::GstCaps,
2868 othercaps: *mut gst::GstCaps,
2869 ) -> *mut gst::GstCaps;
2870 pub fn gst_gl_view_convert_get_output(
2871 viewconvert: *mut GstGLViewConvert,
2872 outbuf_ptr: *mut *mut gst::GstBuffer,
2873 ) -> gst::GstFlowReturn;
2874 pub fn gst_gl_view_convert_perform(
2875 viewconvert: *mut GstGLViewConvert,
2876 inbuf: *mut gst::GstBuffer,
2877 ) -> *mut gst::GstBuffer;
2878 pub fn gst_gl_view_convert_reset(viewconvert: *mut GstGLViewConvert);
2879 pub fn gst_gl_view_convert_set_caps(
2880 viewconvert: *mut GstGLViewConvert,
2881 in_caps: *mut gst::GstCaps,
2882 out_caps: *mut gst::GstCaps,
2883 ) -> gboolean;
2884 pub fn gst_gl_view_convert_set_context(
2885 viewconvert: *mut GstGLViewConvert,
2886 context: *mut GstGLContext,
2887 );
2888 pub fn gst_gl_view_convert_submit_input_buffer(
2889 viewconvert: *mut GstGLViewConvert,
2890 is_discont: gboolean,
2891 input: *mut gst::GstBuffer,
2892 ) -> gst::GstFlowReturn;
2893 pub fn gst_gl_view_convert_transform_caps(
2894 viewconvert: *mut GstGLViewConvert,
2895 direction: gst::GstPadDirection,
2896 caps: *mut gst::GstCaps,
2897 filter: *mut gst::GstCaps,
2898 ) -> *mut gst::GstCaps;
2899
2900 pub fn gst_gl_window_get_type() -> GType;
2904 pub fn gst_gl_window_new(display: *mut GstGLDisplay) -> *mut GstGLWindow;
2905 #[cfg(feature = "v1_16")]
2906 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2907 pub fn gst_gl_window_controls_viewport(window: *mut GstGLWindow) -> gboolean;
2908 pub fn gst_gl_window_draw(window: *mut GstGLWindow);
2909 pub fn gst_gl_window_get_context(window: *mut GstGLWindow) -> *mut GstGLContext;
2910 pub fn gst_gl_window_get_display(window: *mut GstGLWindow) -> uintptr_t;
2911 #[cfg(feature = "v1_28")]
2912 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
2913 pub fn gst_gl_window_get_request_output_surface(window: *mut GstGLWindow) -> gboolean;
2914 pub fn gst_gl_window_get_surface_dimensions(
2915 window: *mut GstGLWindow,
2916 width: *mut c_uint,
2917 height: *mut c_uint,
2918 );
2919 pub fn gst_gl_window_get_window_handle(window: *mut GstGLWindow) -> uintptr_t;
2920 pub fn gst_gl_window_handle_events(window: *mut GstGLWindow, handle_events: gboolean);
2921 #[cfg(feature = "v1_18")]
2922 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2923 pub fn gst_gl_window_has_output_surface(window: *mut GstGLWindow) -> gboolean;
2924 pub fn gst_gl_window_queue_resize(window: *mut GstGLWindow);
2925 pub fn gst_gl_window_quit(window: *mut GstGLWindow);
2926 pub fn gst_gl_window_resize(window: *mut GstGLWindow, width: c_uint, height: c_uint);
2927 pub fn gst_gl_window_run(window: *mut GstGLWindow);
2928 pub fn gst_gl_window_send_key_event(
2929 window: *mut GstGLWindow,
2930 event_type: *const c_char,
2931 key_str: *const c_char,
2932 );
2933 pub fn gst_gl_window_send_message(
2934 window: *mut GstGLWindow,
2935 callback: GstGLWindowCB,
2936 data: gpointer,
2937 );
2938 pub fn gst_gl_window_send_message_async(
2939 window: *mut GstGLWindow,
2940 callback: GstGLWindowCB,
2941 data: gpointer,
2942 destroy: glib::GDestroyNotify,
2943 );
2944 pub fn gst_gl_window_send_mouse_event(
2945 window: *mut GstGLWindow,
2946 event_type: *const c_char,
2947 button: c_int,
2948 posx: c_double,
2949 posy: c_double,
2950 );
2951 #[cfg(feature = "v1_18")]
2952 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2953 pub fn gst_gl_window_send_scroll_event(
2954 window: *mut GstGLWindow,
2955 posx: c_double,
2956 posy: c_double,
2957 delta_x: c_double,
2958 delta_y: c_double,
2959 );
2960 pub fn gst_gl_window_set_close_callback(
2961 window: *mut GstGLWindow,
2962 callback: GstGLWindowCB,
2963 data: gpointer,
2964 destroy_notify: glib::GDestroyNotify,
2965 );
2966 pub fn gst_gl_window_set_draw_callback(
2967 window: *mut GstGLWindow,
2968 callback: GstGLWindowCB,
2969 data: gpointer,
2970 destroy_notify: glib::GDestroyNotify,
2971 );
2972 pub fn gst_gl_window_set_preferred_size(window: *mut GstGLWindow, width: c_int, height: c_int);
2973 pub fn gst_gl_window_set_render_rectangle(
2974 window: *mut GstGLWindow,
2975 x: c_int,
2976 y: c_int,
2977 width: c_int,
2978 height: c_int,
2979 ) -> gboolean;
2980 #[cfg(feature = "v1_28")]
2981 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
2982 pub fn gst_gl_window_set_request_output_surface(
2983 window: *mut GstGLWindow,
2984 output_surface: gboolean,
2985 );
2986 pub fn gst_gl_window_set_resize_callback(
2987 window: *mut GstGLWindow,
2988 callback: GstGLWindowResizeCB,
2989 data: gpointer,
2990 destroy_notify: glib::GDestroyNotify,
2991 );
2992 pub fn gst_gl_window_set_window_handle(window: *mut GstGLWindow, handle: uintptr_t);
2993 pub fn gst_gl_window_show(window: *mut GstGLWindow);
2994
2995 pub fn gst_buffer_add_gl_sync_meta(
2999 context: *mut GstGLContext,
3000 buffer: *mut gst::GstBuffer,
3001 ) -> *mut GstGLSyncMeta;
3002 pub fn gst_buffer_add_gl_sync_meta_full(
3003 context: *mut GstGLContext,
3004 buffer: *mut gst::GstBuffer,
3005 data: gpointer,
3006 ) -> *mut GstGLSyncMeta;
3007 pub fn gst_buffer_pool_config_get_gl_allocation_params(
3008 config: *mut gst::GstStructure,
3009 ) -> *mut GstGLAllocationParams;
3010 #[cfg(feature = "v1_24")]
3011 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
3012 pub fn gst_buffer_pool_config_get_gl_min_free_queue_size(
3013 config: *mut gst::GstStructure,
3014 ) -> c_uint;
3015 pub fn gst_buffer_pool_config_set_gl_allocation_params(
3016 config: *mut gst::GstStructure,
3017 params: *const GstGLAllocationParams,
3018 );
3019 #[cfg(feature = "v1_24")]
3020 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
3021 pub fn gst_buffer_pool_config_set_gl_min_free_queue_size(
3022 config: *mut gst::GstStructure,
3023 queue_size: c_uint,
3024 );
3025 pub fn gst_context_get_gl_display(
3026 context: *mut gst::GstContext,
3027 display: *mut *mut GstGLDisplay,
3028 ) -> gboolean;
3029 pub fn gst_context_set_gl_display(context: *mut gst::GstContext, display: *mut GstGLDisplay);
3030 pub fn gst_gl_check_extension(name: *const c_char, ext: *const c_char) -> gboolean;
3031 #[cfg(feature = "v1_26")]
3032 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
3033 pub fn gst_gl_dma_buf_transform_drm_formats_to_gst_formats(
3034 context: *mut GstGLContext,
3035 src: *const gobject::GValue,
3036 flags: GstGLDrmFormatFlags,
3037 dst: *mut gobject::GValue,
3038 ) -> gboolean;
3039 #[cfg(feature = "v1_26")]
3040 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
3041 pub fn gst_gl_dma_buf_transform_gst_formats_to_drm_formats(
3042 context: *mut GstGLContext,
3043 src: *const gobject::GValue,
3044 flags: GstGLDrmFormatFlags,
3045 dst: *mut gobject::GValue,
3046 ) -> gboolean;
3047 pub fn gst_gl_element_propagate_display_context(
3048 element: *mut gst::GstElement,
3049 display: *mut GstGLDisplay,
3050 );
3051 pub fn gst_gl_ensure_element_data(
3052 element: *mut gst::GstElement,
3053 display_ptr: *mut *mut GstGLDisplay,
3054 other_context_ptr: *mut *mut GstGLContext,
3055 ) -> gboolean;
3056 #[cfg(feature = "v1_20")]
3057 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
3058 pub fn gst_gl_get_affine_transformation_meta_as_ndc(
3059 meta: *mut gst_video::GstVideoAffineTransformationMeta,
3060 matrix: *mut [c_float; 16],
3061 );
3062 pub fn gst_gl_get_plane_data_size(
3063 info: *const gst_video::GstVideoInfo,
3064 align: *const gst_video::GstVideoAlignment,
3065 plane: c_uint,
3066 ) -> size_t;
3067 pub fn gst_gl_get_plane_start(
3068 info: *const gst_video::GstVideoInfo,
3069 valign: *const gst_video::GstVideoAlignment,
3070 plane: c_uint,
3071 ) -> size_t;
3072 pub fn gst_gl_handle_context_query(
3073 element: *mut gst::GstElement,
3074 query: *mut gst::GstQuery,
3075 display: *mut GstGLDisplay,
3076 context: *mut GstGLContext,
3077 other_context: *mut GstGLContext,
3078 ) -> gboolean;
3079 pub fn gst_gl_handle_set_context(
3080 element: *mut gst::GstElement,
3081 context: *mut gst::GstContext,
3082 display: *mut *mut GstGLDisplay,
3083 other_context: *mut *mut GstGLContext,
3084 ) -> gboolean;
3085 pub fn gst_gl_insert_debug_marker(context: *mut GstGLContext, format: *const c_char, ...);
3086 #[cfg(feature = "v1_20")]
3087 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
3088 pub fn gst_gl_multiply_matrix4(
3089 a: *const [c_float; 16],
3090 b: *const [c_float; 16],
3091 result: *mut [c_float; 16],
3092 );
3093 #[cfg(feature = "v1_20")]
3094 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
3095 pub fn gst_gl_set_affine_transformation_meta_from_ndc(
3096 meta: *mut gst_video::GstVideoAffineTransformationMeta,
3097 matrix: *const [c_float; 16],
3098 );
3099 pub fn gst_gl_sized_gl_format_from_gl_format_type(
3100 context: *mut GstGLContext,
3101 format: c_uint,
3102 type_: c_uint,
3103 ) -> c_uint;
3104 pub fn gst_gl_stereo_downmix_mode_get_type() -> GType;
3105 #[cfg(feature = "v1_24")]
3106 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
3107 pub fn gst_gl_swizzle_invert(swizzle: *mut [c_int; 4], inversion: *mut [c_int; 4]);
3108 pub fn gst_gl_sync_meta_api_get_type() -> GType;
3109 pub fn gst_gl_value_get_texture_target_mask(
3110 value: *const gobject::GValue,
3111 ) -> GstGLTextureTarget;
3112 pub fn gst_gl_value_set_texture_target(
3113 value: *mut gobject::GValue,
3114 target: GstGLTextureTarget,
3115 ) -> gboolean;
3116 pub fn gst_gl_value_set_texture_target_from_mask(
3117 value: *mut gobject::GValue,
3118 target_mask: GstGLTextureTarget,
3119 ) -> gboolean;
3120 pub fn gst_gl_version_to_glsl_version(
3121 gl_api: GstGLAPI,
3122 maj: c_int,
3123 min: c_int,
3124 ) -> GstGLSLVersion;
3125 #[cfg(feature = "v1_24")]
3126 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
3127 pub fn gst_gl_video_format_swizzle(
3128 video_format: gst_video::GstVideoFormat,
3129 swizzle: *mut [c_int; 4],
3130 ) -> gboolean;
3131 pub fn gst_glsl_string_get_version_profile(
3132 s: *const c_char,
3133 version: *mut GstGLSLVersion,
3134 profile: *mut GstGLSLProfile,
3135 ) -> gboolean;
3136 pub fn gst_is_gl_base_memory(mem: *mut gst::GstMemory) -> gboolean;
3137 pub fn gst_is_gl_buffer(mem: *mut gst::GstMemory) -> gboolean;
3138 pub fn gst_is_gl_memory(mem: *mut gst::GstMemory) -> gboolean;
3139 pub fn gst_is_gl_memory_pbo(mem: *mut gst::GstMemory) -> gboolean;
3140 pub fn gst_is_gl_renderbuffer(mem: *mut gst::GstMemory) -> gboolean;
3141
3142}