From 825bf7301ed7689c37dce9e64921ba8f286944d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Mon, 5 Nov 2018 11:13:57 +0200 Subject: [PATCH] Update gir-files from gstreamer-rs-sys --- gir-files/GES-1.0.gir | 69 +- gir-files/GstAudio-1.0.gir | 4 +- gir-files/GstGL-1.0.gir | 8477 +++++++++++++++++++++++++++++++++++ gir-files/GstMpegts-1.0.gir | 64 +- gir-files/fix.sh | 59 + 5 files changed, 8592 insertions(+), 81 deletions(-) create mode 100644 gir-files/GstGL-1.0.gir create mode 100755 gir-files/fix.sh diff --git a/gir-files/GES-1.0.gir b/gir-files/GES-1.0.gir index a26735ff3..e2ded350a 100644 --- a/gir-files/GES-1.0.gir +++ b/gir-files/GES-1.0.gir @@ -11,7 +11,7 @@ and/or use gtk-doc annotations. --> - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - the value - + @@ -8582,7 +8519,7 @@ is much more convenient for C programming. the value - + diff --git a/gir-files/GstAudio-1.0.gir b/gir-files/GstAudio-1.0.gir index ea01c7de6..559258394 100644 --- a/gir-files/GstAudio-1.0.gir +++ b/gir-files/GstAudio-1.0.gir @@ -5714,7 +5714,7 @@ and will be packed into @data. a source array - + @@ -5755,7 +5755,7 @@ channels * size(unpack_format) bytes. pointer to the audio data - + diff --git a/gir-files/GstGL-1.0.gir b/gir-files/GstGL-1.0.gir new file mode 100644 index 000000000..ae1ebda32 --- /dev/null +++ b/gir-files/GstGL-1.0.gir @@ -0,0 +1,8477 @@ + + + + + + + + + + + An option that can be activated on bufferpools to request OpenGL +synchronization metadata on buffers from the pool. + + + + String used for %GST_GL_TEXTURE_TARGET_2D as a #GstBufferPool pool option + + + + String used for %GST_GL_TEXTURE_TARGET_EXTERNAL_OES as a #GstBufferPool pool option + + + + String used for %GST_GL_TEXTURE_TARGET_RECTANGLE as a #GstBufferPool pool option + + + + Name of the caps feature indicating the use of GL buffers + + + + Name of the caps feature for indicating the use of #GstGLMemory + + + + + no API + + + Desktop OpenGL up to and including 3.1. The + compatibility profile when the OpenGL version is >= 3.2 + + + Desktop OpenGL >= 3.2 core profile + + + OpenGL ES 1.x + + + OpenGL ES 2.x and 3.x + + + Any OpenGL API + + + + + the size of the struct (including and subclass data) + + + + a #GstGLAllocationParamsCopyFunc + + + + a #GstGLAllocationParamsFreeFunc + + + + allocation flags + + + + the allocation size + + + + the #GstAllocationParams + + + + a #GstGLContext + + + + a #GDestroyNotify + + + + argument to call @notify with + + + + the wrapped data pointer + + + + the wrapped OpenGL handle + + + + + + + + + + a copy of the #GstGLAllocationParams specified by + @src or %NULL on failure + + + + + the #GstGLAllocationParams to initialize + + + + + + Copies the dynamically allocated data from @src to @dest. Direct subclasses +should call this function in their own overriden copy function. + + + + + + the source #GstGLAllocationParams + + + + the destination #GstGLAllocationParams + + + + + + Frees the #GstGLAllocationParams and all associated data. + + + + + + the #GstGLAllocationParams to initialize + + + + + + Frees the dynamically allocated data in @params. Direct subclasses +should call this function in their own overriden free function. + + + + + + the source #GstGLAllocationParams + + + + + + @notify will be called once for each allocated memory using these @params +when freeing the memory. + + whether the paramaters could be initialized + + + + + the #GstGLAllocationParams to initialize + + + + the struct size of the implementation + + + + some alloc flags + + + + a copy function + + + + a free function + + + + a #GstGLContext + + + + the number of bytes to allocate. + + + + a #GstAllocationParams to apply + + + + a sysmem data pointer to initialize the allocation with + + + + a GL handle to initialize the allocation with + + + + user data to call @notify with + + + + a #GDestroyNotify + + + + + + + Copies the parameters from @src into @dest. The subclass must compose copy +functions from the superclass. + + + + + + the source #GstGLAllocationParams to copy from + + + + the source #GstGLAllocationParams to copy + + + + + + Free any dynamically allocated data. The subclass must call the superclass' +free. + + + + + + a #GstGLAllocationParams + + + + + + #GstGLAsyncDebug an opaque structure and should only be accessed through the +provided API. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Frees @ad + + + + + + a #GstGLAsyncDebug + + + + + + freeze the debug output. While frozen, any call to +gst_gl_async_debug_output_log_msg() will not output any messages but +subsequent calls to gst_gl_async_debug_store_log_msg() will overwrite previous +messages. + + + + + + a #GstGLAsyncDebug + + + + + + Initialize @ad. Intended for use with #GstGLAsyncDebug's that are embedded +in other structs. + + + + + + a #GstGLAsyncDebug + + + + + + Outputs a previously stored debug message. + + + + + + the #GstGLAsyncDebug to store the message in + + + + + + Stores a debug message for later output by gst_gl_async_debug_output_log_msg() + + + + + + the #GstGLAsyncDebug to store the message in + + + + the #GstDebugCategory to output the message in + + + + the #GstLevel + + + + the file where the debug message originates from + + + + the function where the debug message originates from + + + + the line in @file where the debug message originates from + + + + a #GObject to associate with the debug message + + + + a printf style format string + + + + the list of arguments for @format + + + + + + Stores a debug message for later output by gst_gl_async_debug_output_log_msg() + + + + + + the #GstGLAsyncDebug to store the message in + + + + the #GstDebugCategory to output the message in + + + + the #GstLevel + + + + the file where the debug message originates from + + + + the function where the debug message originates from + + + + the line in @file where the debug message originates from + + + + a #GObject to associate with the debug message + + + + a printf style format string + + + + the list of arguments for @format + + + + + + unfreeze the debug output. See gst_gl_async_debug_freeze() for what freezing means + + + + + + a #GstGLAsyncDebug + + + + + + Unset any dynamically allocated data. Intended for use with +#GstGLAsyncDebug's that are embedded in other structs. + + + + + + a #GstGLAsyncDebug + + + + + + Free with gst_gl_async_debug_free() + + a new #GstGLAsyncDebug + + + + + + + + + + + + + + + + #GstGLBaseFilter handles the nitty gritty details of retrieving an OpenGL +context. It also provided some wrappers around #GstBaseTransform's +start(), stop() and set_caps() virtual methods that ensure an OpenGL context +is available and current in the calling thread. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + parent #GstBaseTransform + + + + the currently configured #GstGLDisplay + + + + the currently configured #GstGLContext + + + + the currently configured input #GstCaps + + + + the currently configured output #GstCaps + + + + + + + + + + + + + + parent class + + + + the logical-OR of #GstGLAPI's supported by this element + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + GstGLBaseMemory is a #GstMemory subclass providing the basis of support +for the mapping of GL buffers. + +Data is uploaded or downloaded from the GPU as is necessary. + + the parent object + + + + the #GstGLContext to use for GL operations + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Note: only intended for subclass usage to allocate the sytem memory buffer +on demand. If there is already a non-NULL data pointer in @gl_mem->data, +then this function imply returns TRUE. + + whether the system memory could be allocated + + + + + a #GstGLBaseMemory + + + + + + Initializes @mem with the required parameters + + + + + + the #GstGLBaseMemory to initialize + + + + the #GstAllocator to initialize with + + + + the parent #GstMemory to initialize with + + + + the #GstGLContext to initialize with + + + + the @GstAllocationParams to initialize with + + + + the number of bytes to be allocated + + + + user data to call @notify with + + + + a #GDestroyNotify + + + + + + + whether the copy suceeded. + + + + + the source #GstGLBaseMemory + + + + the destination #GstGLBaseMemory + + + + the offset to start at + + + + the number of bytes to copy + + + + + + + a new #GstGLBaseMemory from @allocator with the requested @params. + + + + + a #GstGLBaseMemoryAllocator + + + + the #GstGLAllocationParams to allocate the memory with + + + + + + + + + + + Initializes the GL Base Memory allocator. It is safe to call this function +multiple times. This must be called before any other GstGLBaseMemory operation. + + + + + + + Opaque #GstGLBaseMemoryAllocator struct + + + a newly allocated #GstGLBaseMemory from @allocator and @params + + + + + a #GstGLBaseMemoryAllocator + + + + the #GstGLAllocationParams to allocate the memory with + + + + + + + + + + + + + + + + + + Note: not called with a GL context current + + a newly allocated #GstGLBaseMemory from @allocator and @params + + + + + a #GstGLBaseMemoryAllocator + + + + the #GstGLAllocationParams to allocate the memory with + + + + + + + the parent class + + + + a #GstGLBaseMemoryAllocatorAllocFunction + + + + a #GstGLBaseMemoryAllocatorCreateFunction + + + + a #GstGLBaseMemoryAllocatorMapFunction + + + + a #GstGLBaseMemoryAllocatorUnmapFunction + + + + a #GstGLBaseMemoryAllocatorCopyFunction + + + + a #GstGLBaseMemoryAllocatorDestroyFunction + + + + + + + + + + Also see gst_memory_copy(); + + the newly copied #GstGLMemory or %NULL + + + + + a #GstGLBaseMemory + + + + the offset to copy from + + + + the number of bytes to copy + + + + + + As this virtual method is called with an OpenGL context current, use this +function to allocate and OpenGL resources needed for your application + + whether the creation succeeded + + + + + a #GstGLBaseMemory + + + + + + Destroy any resources allocated throughout the lifetime of @mem + + + + + + a #GstGLBaseMemory + + + + + + Also see gst_memory_map(); + + the mapped pointer + + + + + a #GstGLBaseMemory + + + + a #GstMapInfo to map with + + + + the size to map + + + + + + Also see gst_memory_unmap(); + + + + + + a #GstGLBaseMemory + + + + a #GstMapInfo to map with + + + + + + + generic faliure + + + the implementation is too old and doesn't + implement enough features + + + a resource could not be found + + + + + the texture needs downloading + to the data pointer + + + the data pointer needs uploading + to the texture + + + + GstGLBuffer is a #GstMemory subclass providing support for the mapping of +GL buffers. + +Data is uploaded or downloaded from the GPU as is necessary. + + the parent object + + + + the buffer id for this memory + + + + the OpenGL target of this texture for binding purposes + + + + the OpenGL usage hints this buffer was created with + + + + Initializes the GL Buffer allocator. It is safe to call this function +multiple times. This must be called before any other #GstGLBuffer operation. + + + + + + + + parent object + + + + the OpenGL target to bind the buffer to + + + + the OpenGL usage hint to create the buffer with + + + + + + + + + + a new #GstGLBufferAllocationParams for allocating OpenGL buffer + objects + + + + + a #GstGLContext + + + + the size in bytes to allocate + + + + the #GstAllocationParams for @tex_id + + + + the OpenGL target to allocate + + + + the OpenGL usage hint to allocate with + + + + + + + Opaque #GstGLAllocator struct + + + + + + + + + + + The #GstGLBufferAllocatorClass only contains private data + + + + + + + + + + + a #GstGLBufferPool is an object that allocates buffers with #GstGLBaseMemory + +A #GstGLBufferPool is created with gst_gl_buffer_pool_new() + +#GstGLBufferPool implements the VideoMeta buffer pool option +%GST_BUFFER_POOL_OPTION_VIDEO_META, the VideoAligment buffer pool option +%GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT as well as the OpenGL specific +%GST_BUFFER_POOL_OPTION_GL_SYNC_META buffer pool option. + + + a #GstBufferPool that allocates buffers with #GstGLMemory + + + + + the #GstGLContext to use + + + + + + + + + + + + + + + + + + + + + The #GstGLBufferPoolClass structure contains only private data + + + + + + + + + + + + + #GstGLColorConvert is an object that converts between color spaces and/or +formats using OpenGL Shaders. + +A #GstGLColorConvert can be created with gst_gl_color_convert_new(), the +configuration negotiated with gst_gl_color_convert_transform_caps() and the +conversion performed with gst_gl_color_convert_perform(). + +The glcolorconvertelement provides a GStreamer element that uses +#GstGLColorConvert to convert between video formats and color spaces. + + + a new #GstGLColorConvert object + + + + + a #GstGLContext + + + + + + Provides an implementation of #GstBaseTransformClass::fixate_caps() + + the fixated #GstCaps + + + + + a #GstGLContext to use for transforming @caps + + + + a #GstPadDirection + + + + the #GstCaps of @direction + + + + the #GstCaps to fixate + + + + + + Provides an implementation of #GstBaseTransformClass::transform_caps() + + the converted #GstCaps + + + + + a #GstGLContext to use for transforming @caps + + + + a #GstPadDirection + + + + the #GstCaps to transform + + + + a set of filter #GstCaps + + + + + + Provides an implementation of #GstBaseTransfromClass::decide_allocation() + + whether the allocation parameters were successfully chosen + + + + + a #GstGLColorConvert + + + + a completed ALLOCATION #GstQuery + + + + + + Converts the data contained by @inbuf using the formats specified by the +#GstCaps passed to gst_gl_color_convert_set_caps() + + a converted #GstBuffer or %NULL + + + + + a #GstGLColorConvert + + + + the #GstGLMemory filled #GstBuffer to convert + + + + + + Initializes @convert with the information required for conversion. + + + + + + a #GstGLColorConvert + + + + input #GstCaps + + + + output #GstCaps + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The #GstGLColorConvertClass struct only contains private data + + + + + + + + + + + + + #GstGLContext wraps an OpenGL context object in a uniform API. As a result +of the limitation on OpenGL context, this object is not thread safe unless +specified and must only be activated in a single thread. + + Create a new #GstGLContext with the specified @display + + a new #GstGLContext + + + + + a #GstGLDisplay + + + + + + Wraps an existing OpenGL context into a #GstGLContext. + +Note: The caller is responsible for ensuring that the OpenGL context +represented by @handle stays alive while the returned #GstGLContext is +active. + + a #GstGLContext wrapping @handle + + + + + a #GstGLDisplay + + + + the OpenGL context to wrap + + + + a #GstGLPlatform specifying the type of context in @handle + + + + a #GstGLAPI containing the available OpenGL apis in @handle + + + + + + A default implementation of the various GetProcAddress functions that looks +for @name in the OpenGL shared libraries or in the current process. + +See also: gst_gl_context_get_proc_address() + + an address pointing to @name or %NULL + + + + + a #GstGLAPI + + + + then function to get the address of + + + + + + + + + + + See also gst_gl_context_activate(). + + the #GstGLContext active in the current thread or %NULL + + + + + If an error occurs, @major and @minor are not modified and %GST_GL_API_NONE is +returned. + + The version supported by the OpenGL context current in the calling + thread or %GST_GL_API_NONE + + + + + the #GstGLPlatform to retrieve the API for + + + + the major version + + + + the minor version + + + + + + + The OpenGL context handle current in the calling thread or %NULL + + + + + a #GstGLPlatform specifying the type of context to retrieve + + + + + + Attempts to use the @context_type specific GetProcAddress implementations +to retreive @name. + +See also gst_gl_context_get_proc_address(). + + a function pointer for @name, or %NULL + + + + + a #GstGLPlatform + + + + a #GstGLAPI + + + + the name of the function to retrieve + + + + + + (De)activate the OpenGL context represented by this @context. + +In OpenGL terms, calls eglMakeCurrent or similar with this context and the +currently set window. See gst_gl_context_set_window() for details. + + Whether the activation succeeded + + + + + a #GstGLContext + + + + %TRUE to activate, %FALSE to deactivate + + + + + + Check for an OpenGL @feature being supported. + +Note: Most features require that the context be created before it is +possible to determine their existence and so will fail if that is not the +case. + + Whether @feature is supported by @context + + + + + a #GstGLContext + + + + a platform specific feature + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Get the currently enabled OpenGL api. + +The currently available API may be limited by the #GstGLDisplay in use and/or +the #GstGLWindow chosen. + + the available OpenGL api + + + + + a #GstGLContext + + + + + + Gets the backing OpenGL context used by @context. + + The platform specific backing OpenGL context + + + + + a #GstGLContext: + + + + + + Gets the OpenGL platform that used by @context. + + The platform specific backing OpenGL context + + + + + a #GstGLContext: + + + + + + Get the version of the OpenGL platform (GLX, EGL, etc) used. Only valid +after a call to gst_gl_context_create_context(). + + + + + + a #GstGLContext + + + + return for the major version + + + + return for the minor version + + + + + + Swap the front and back buffers on the window attached to @context. +This will display the frame on the next refresh cycle. + + + + + + a #GstGLContext + + + + + + (De)activate the OpenGL context represented by this @context. + +In OpenGL terms, calls eglMakeCurrent or similar with this context and the +currently set window. See gst_gl_context_set_window() for details. + + Whether the activation succeeded + + + + + a #GstGLContext + + + + %TRUE to activate, %FALSE to deactivate + + + + + + Note: This will always fail for two wrapped #GstGLContext's + + whether @context and @other_context are able to share OpenGL + resources. + + + + + a #GstGLContext + + + + another #GstGLContext + + + + + + Check for an OpenGL @feature being supported. + +Note: Most features require that the context be created before it is +possible to determine their existence and so will fail if that is not the +case. + + Whether @feature is supported by @context + + + + + a #GstGLContext + + + + a platform specific feature + + + + + + + whether whether the current framebuffer is complete + + + + + a #GstGLContext + + + + the GL value of the framebuffer target, GL_FRAMEBUFFER, + GL_READ_FRAMEBUFFER, GL_DRAW_FRAMEBUFFER + + + + + + + whether OpenGL context implements the required api and specified +version. + + + + + a #GstGLContext + + + + api type required + + + + major version required + + + + minor version required + + + + + + Unbind the current framebuffer + + + + + + a #GstGLContext + + + + + + Clear's the currently set shader from the GL state machine. + +Note: must be called in the GL thread. + + + + + + a #GstGLContext + + + + + + Creates an OpenGL context with the specified @other_context as a context +to share shareable OpenGL objects with. See the OpenGL specification for +what is shared between OpenGL contexts. + +If an error occurs, and @error is not %NULL, then error will contain details +of the error and %FALSE will be returned. + +Should only be called once. + + whether the context could successfully be created + + + + + a #GstGLContext: + + + + a #GstGLContext to share OpenGL objects with + + + + + + Destroys an OpenGL context. + +Should only be called after gst_gl_context_create() has been successfully +called for this context. + + + + + + a #GstGLContext: + + + + + + Fills @context's info (version, extensions, vtable, etc) from the GL +context in the current thread. Typically used with wrapped contexts to +allow wrapped contexts to be used as regular #GstGLContext's. + + + + + + a #GstGLContext: + + + + + + + the #GstGLDisplay associated with this @context + + + + + a #GstGLContext: + + + + + + Get the currently enabled OpenGL api. + +The currently available API may be limited by the #GstGLDisplay in use and/or +the #GstGLWindow chosen. + + the available OpenGL api + + + + + a #GstGLContext + + + + + + Gets the backing OpenGL context used by @context. + + The platform specific backing OpenGL context + + + + + a #GstGLContext: + + + + + + Gets the OpenGL platform that used by @context. + + The platform specific backing OpenGL context + + + + + a #GstGLContext: + + + + + + Get the version of the OpenGL platform (GLX, EGL, etc) used. Only valid +after a call to gst_gl_context_create_context(). + + + + + + a #GstGLContext + + + + return for the major version + + + + return for the minor version + + + + + + Returns the OpenGL version implemented by @context. See +gst_gl_context_get_gl_api() for retreiving the OpenGL api implemented by +@context. + + + + + + a #GstGLContext + + + + resulting major version + + + + resulting minor version + + + + + + Get a function pointer to a specified opengl function, @name. If the the +specific function does not exist, NULL is returned instead. + +Platform specfic functions (names starting 'egl', 'glX', 'wgl', etc) can also +be retrieved using this method. + +Note: This function may return valid function pointers that may not be valid +to call in @context. The caller is responsible for ensuring that the +returned function is a valid function to call in @context by either checking +the OpenGL API and version or for an appropriate OpenGL extension. + +Note: On success, you need to cast the returned function pointer to the +correct type to be able to call it correctly. On 32-bit Windows, this will +include the %GSTGLAPI identifier to use the correct calling convention. +e.g. + +|[<!-- language="C" --> +void (GSTGLAPI *PFN_glGetIntegerv) (GLenum name, GLint * ret) +]| + + a function pointer or %NULL + + + + + a #GstGLContext + + + + an opengl function name + + + + + + + The #GThread, @context is current in or NULL + + + + + a #GstGLContext + + + + + + + the currently set window + + + + + a #GstGLContext + + + + + + + Whether the #GstGLContext has been shared with another #GstGLContext + + + + + a #GstGLContext + + + + + + Will internally set @context as shared with @share + + + + + + a wrapped #GstGLContext + + + + another #GstGLContext + + + + + + Set's the current window on @context to @window. The window can only be +changed before gst_gl_context_create() has been called and the @window is not +already running. + + Whether the window was successfully updated + + + + + a #GstGLContext + + + + a #GstGLWindow + + + + + + + Whether @context supports the combination of @version with @profile + + + + + a #GstGLContext + + + + a #GstGLSLVersion + + + + a #GstGLSLProfile + + + + + + Swap the front and back buffers on the window attached to @context. +This will display the frame on the next refresh cycle. + + + + + + a #GstGLContext + + + + + + Execute @func in the OpenGL thread of @context with @data + +MT-safe + + + + + + a #GstGLContext + + + + a #GstGLContextThreadFunc + + + + user data to call @func with + + + + + + + + + + + + + + + a list of OpenGL function pointers + + + + + + + + + + + + + + + + + + + + + + + + + + The platform specific backing OpenGL context + + + + + a #GstGLContext: + + + + + + + + + the available OpenGL api + + + + + a #GstGLContext + + + + + + + + + The platform specific backing OpenGL context + + + + + a #GstGLContext: + + + + + + + + + + + + + + + + + + + + + + + + Whether the activation succeeded + + + + + a #GstGLContext + + + + %TRUE to activate, %FALSE to deactivate + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + a #GstGLContext + + + + + + + + + Whether @feature is supported by @context + + + + + a #GstGLContext + + + + a platform specific feature + + + + + + + + + + + + + a #GstGLContext + + + + return for the major version + + + + return for the minor version + + + + + + + + + + + + + OpenGL context errors. + + Failed for an unspecified reason + + + The configuration requested is not correct + + + The OpenGL API requested is not correct + + + The OpenGL libraries are too old + + + glXCreateContext (or similar) failed + + + A resource is not available + + + + + + Represents a function to run in the GL thread with @context and @data + + + + + + a #GstGLContext + + + + user data + + + + + + #GstGLDisplay represents a connection to the underlying windowing system. +Elements are required to make use of #GstContext to share and propogate +a #GstGLDisplay. + +There are a number of environment variables that influence the choice of +platform and window system specific functionality. +- GST_GL_WINDOW influences the window system to use. Common values are + 'x11', 'wayland', 'win32' or 'cocoa'. +- GST_GL_PLATFORM influences the OpenGL platform to use. Common values are + 'egl', 'glx', 'wgl' or 'cgl'. +- GST_GL_API influences the OpenGL API requested by the OpenGL platform. + Common values are 'opengl', 'opengl3' and 'gles2'. + +> Certain window systems require a special function to be called to +> initialize threading support. As this GStreamer GL library does not preclude +> concurrent access to the windowing system, it is strongly advised that +> applications ensure that threading support has been initialized before any +> other toolkit/library functionality is accessed. Failure to do so could +> result in sudden application abortion during execution. The most notably +> example of such a function is X11's XInitThreads\(). + + + a new #GstGLDisplay + + + + + It requires the display's object lock to be held. + + a new #GstGLWindow for @display or %NULL. + + + + + a #GstGLDisplay + + + + + + + the native handle for the display + + + + + a #GstGLDisplay + + + + + + + whether @context was successfully added. %FALSE may be returned +if there already exists another context for @context's active thread. + +Must be called with the object lock held. + + + + + a #GstGLDisplay + + + + a #GstGLContext + + + + + + It requires the display's object lock to be held. + + whether a new context could be created. + + + + + a #GstGLDisplay + + + + other #GstGLContext to share resources with. + + + + resulting #GstGLContext + + + + + + It requires the display's object lock to be held. + + a new #GstGLWindow for @display or %NULL. + + + + + a #GstGLDisplay + + + + + + + limit the use of OpenGL to the requested @gl_api. This is intended to allow +application and elements to request a specific set of OpenGL API's based on +what they support. See gst_gl_context_get_gl_api() for the retreiving the +API supported by a #GstGLContext. + + + + + + a #GstGLDisplay + + + + a #GstGLAPI to filter with + + + + + + Execute @compare_func over the list of windows stored by @display. The +first argment to @compare_func is the #GstGLWindow being checked and the +second argument is @data. + + The first #GstGLWindow that causes a match + from @compare_func + + + + + a #GstGLDisplay + + + + some data to pass to @compare_func + + + + a comparison function to run + + + + + + see gst_gl_display_filter_gl_api() for what the returned value represents + + the #GstGLAPI configured for @display + + + + + a #GstGLDisplay + + + + + + + + + + + + + + + + + the #GstGLContext current on @thread or %NULL + +Must be called with the object lock held. + + + + + a #GstGLDisplay + + + + a #GThread + + + + + + + the native handle for the display + + + + + a #GstGLDisplay + + + + + + + the #GstGLDisplayType of @display + + + + + a #GstGLDisplay + + + + + + + if @window could be removed from @display + + + + + a #GstGLDisplay + + + + a #GstGLWindow to remove + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Overrides the @GstGLContext creation mechanism. +It can be called in any thread and it is emitted with +display's object lock held. + + the new context. + + + + + other context to share resources with. + + + + + + + + + + + + + the native handle for the display + + + + + a #GstGLDisplay + + + + + + + + + a new #GstGLWindow for @display or %NULL. + + + + + a #GstGLDisplay + + + + + + + + + + + + + the contents of a #GstGLDisplayEGL are private and should only be accessed +through the provided API + + Create a new #GstGLDisplayEGL using the default EGL_DEFAULT_DISPLAY. + + a new #GstGLDisplayEGL or %NULL + + + + + + + + + + + + + + + Attempts to create a new #EGLDisplay from @display. If @type is +%GST_GL_DISPLAY_TYPE_ANY, then @display must be 0. @type must not be +%GST_GL_DISPLAY_TYPE_NONE. + + A #EGLDisplay or %EGL_NO_DISPLAY + + + + + a #GstGLDisplayType + + + + pointer to a display (or 0) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + no display type + + + X11 display + + + Wayland display + + + Cocoa display + + + Win32 display + + + Dispmanx display + + + EGL display + + + Vivante Framebuffer display + + + Mesa3D GBM display + + + any display type + + + + + + + + #GstGLFilter helps to implement simple OpenGL filter elements taking a +single input and producing a single output with a #GstGLFramebuffer + + + + + + + + + + + + + + + + + + + + + + + + + + + + Calls filter_texture vfunc with correctly mapped #GstGLMemorys + + whether the transformation succeeded + + + + + a #GstGLFilter + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Render a fullscreen quad using the current GL state. The only GL state this +modifies is the necessary vertex/index buffers and, if necessary, a +Vertex Array Object for drawing a fullscreen quad. Framebuffer state, +any shaders, viewport state, etc must be setup by the caller. + + + + + + a #GstGLFilter + + + + + + Calls filter_texture vfunc with correctly mapped #GstGLMemorys + + whether the transformation succeeded + + + + + a #GstGLFilter + + + + an input buffer + + + + an output buffer + + + + + + Transforms @input into @output using @func on through FBO. + + the return value of @func + + + + + a #GstGLFilter + + + + the input texture + + + + the output texture + + + + the function to transform @input into @output. called with @data + + + + the data associated with @func + + + + + + Transforms @input into @output using @shader with a FBO. + +See also: gst_gl_filter_render_to_target() + + + + + + a #GstGLFilter + + + + the input texture + + + + the output texture + + + + the shader to use. + + + + + + parent #GstGLBaseFilter + + + + the video info for input buffers + + + + the video info for output buffers + + + + The texture target of the input buffers (usually 2D) + + + + The texture target of the output buffers (usually 2D) + + + + the output #GstCaps + + + + #GstGLFramebuffer object used for transformations + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + parent #GstGLBaseFilterClass + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + whether the transformation succeeded + + + + + a #GstGLFilter + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + whether the render succeeded + + + + + the #GstGLFIlter + + + + the input #GstGLMemory to render + + + + user data + + + + + + + Single component replicated across R, G, and B textures + components + + + Single component stored in the A texture component + + + Combination of #GST_GL_LUMINANCE and #GST_GL_ALPHA + + + Single component stored in the R texture component + + + Single 8-bit component stored in the R texture component + + + Two components stored in the R and G texture components + + + Two 8-bit components stored in the R and G texture components + + + Three components stored in the R, G, and B texture components + + + Three 8-bit components stored in the R, G, and B + texture components + + + Three components of bit depth 5, 6 and 5 stored in the R, G, + and B texture components respectively. + + + Four components stored in the R, G, B, and A texture + components respectively. + + + Four 8-bit components stored in the R, G, B, and A texture + components respectively. + + + A single 16-bit component for depth information. + + + A 24-bit component for depth information and + a 8-bit component for stencil informat. + + + + A #GstGLFramebuffer represents and holds an OpenGL framebuffer object with +it's associated attachments. + +A #GstGLFramebuffer can be created with gst_gl_framebuffer_new() or +gst_gl_framebuffer_new_with_default_depth() and bound with +gst_gl_framebuffer_bind(). Other resources can be bound with +gst_gl_framebuffer_attach() + +Note: OpenGL framebuffers are not shareable resources so cannot be used +between multiple OpenGL contexts. + + + a new #GstGLFramebuffer + + + + + a #GstGLContext + + + + + + + a new #GstGLFramebuffer with a depth buffer of @width and @height + + + + + a #GstGLContext + + + + width for the depth buffer + + + + for the depth buffer + + + + + + attach @mem to @attachment_point + + + + + + a #GstGLFramebuffer + + + + the OpenGL attachment point to bind @mem to + + + + the memory object to bind to @attachment_point + + + + + + Bind @fb into the current thread + + + + + + a #GstGLFramebuffer + + + + + + Perform the steps necessary to have the output of a glDraw* command in +@func update the contents of @mem. + + the result of executing @func + + + + + a #GstGLFramebuffer + + + + the #GstGLMemory to draw to + + + + the function to run + + + + data to pass to @func + + + + + + Retreive the effective dimensions from the current attachments attached to +@fb. + + + + + + a #GstGLFramebuffer + + + + output width + + + + output height + + + + + + + the OpenGL id for @fb + + + + + a #GstGLFramebuffer + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Opaque #GstGLFramebufferClass struct + + + + + + + + + + + callback definition for operating through a #GstGLFramebuffer object + + + + + + user data + + + + + + + + + GstGLMemory is a #GstGLBaseMemory subclass providing support for the mapping of +OpenGL textures. + +#GstGLMemory is created or wrapped through gst_gl_base_memory_alloc() +with #GstGLVideoAllocationParams. + +Data is uploaded or downloaded from the GPU as is necessary. + + the parent #GstGLBaseMemory object + + + + the GL texture id for this memory + + + + the GL texture target for this memory + + + + + + + the texture's #GstVideoInfo + + + + data alignment for system memory mapping + + + + data plane in @info + + + + GL shader scaling parameters for @valign and/or width/height + + + + + + + + + + + + + + + + + + + + Copies @gl_mem into the texture specfified by @tex_id. The format of @tex_id +is specified by @tex_format, @width and @height. + + Whether the copy suceeded + + + + + a #GstGLMemory + + + + OpenGL texture id + + + + the #GstGLTextureTarget + + + + the #GstGLFormat + + + + width of @tex_id + + + + height of @tex_id + + + + + + Copies the texture in #GstGLMemory into the texture specified by @tex_id, +@out_target, @out_tex_format, @out_width and @out_height. + + whether the copy succeeded. + + + + + the source #GstGLMemory + + + + the destination texture id + + + + the destination #GstGLTextureTarget + + + + the destination #GstGLFormat + + + + the destination width + + + + the destination height + + + + + + + the #GstGLFormat of @gl_mem + + + + + a #GstGLMemory + + + + + + + the texture height of @gl_mem + + + + + a #GstGLMemory + + + + + + + the OpenGL texture handle of @gl_mem + + + + + a #GstGLMemory + + + + + + + the #GstGLTextureTarget of @gl_mem + + + + + a #GstGLMemory + + + + + + + the texture width of @gl_mem + + + + + a #GstGLMemory + + + + + + Initializes @mem with the required parameters. @info is assumed to have +already have been modified with gst_video_info_align(). + + + + + + the #GstGLBaseMemory to initialize + + + + the #GstAllocator to initialize with + + + + the parent #GstMemory to initialize with + + + + the #GstGLContext to initialize with + + + + the #GstGLTextureTarget for this #GstGLMemory + + + + the #GstGLFormat for this #GstGLMemory + + + + the @GstAllocationParams to initialize with + + + + the #GstVideoInfo for this #GstGLMemory + + + + the plane number (starting from 0) for this #GstGLMemory + + + + optional #GstVideoAlignment parameters + + + + user data to call @notify with + + + + a #GDestroyNotify + + + + + + Reads the texture in #GstGLMemory into @read_pointer if no buffer is bound +to %GL_PIXEL_PACK_BUFFER. Otherwise @read_pointer is the byte offset into +the currently bound %GL_PIXEL_PACK_BUFFER buffer to store the result of +glReadPixels. See the OpenGL specification for glReadPixels for more +details. + + whether theread operation succeeded + + + + + a #GstGLMemory + + + + the data pointer to pass to glReadPixels + + + + + + See gst_gl_memory_read_pixels() for what @read_pointer signifies. + + + + + + a #GstGLMemory + + + + the data pointer to pass to glTexSubImage + + + + + + Initializes the GL Base Texture allocator. It is safe to call this function +multiple times. This must be called before any other GstGLMemory operation. + + + + + + + whether the buffer was correctly setup + + + + + the @GstGLMemoryAllocator to allocate from + + + + a #GstBuffer to setup + + + + the #GstGLVideoAllocationParams to allocate with + + + + + a list of #GstGLFormat's to allocate with. + + + + + + + a list of wrapped data pointers + + + + + + the number of elements in @tex_formats and @wrapped_data + + + + + + + Opaque #GstGLMemoryAllocator struct + + + the default #GstGLMemoryAllocator supported by + @context + + + + + a #GstGLContext + + + + + + + + + + + + + + + + + + + provide a custom map implementation + + + + provide a custom copy implementation + + + + provide a custom unmap implementation + + + + + + + + + + + + + #GstGLMemoryPBO is created or wrapped through gst_gl_base_memory_alloc() +with #GstGLVideoAllocationParams. + +Data is uploaded or downloaded from the GPU as is necessary. + + + + + + + + + + + + + Copies @gl_mem into the texture specfified by @tex_id. The format of @tex_id +is specified by @tex_format, @width and @height. + +If @respecify is %TRUE, then the copy is performed in terms of the texture +data. This is useful for splitting RGBA textures into RG or R textures or +vice versa. The requirement for this to succeed is that the backing texture +data must be the same size, i.e. say a RGBA8 texture is converted into a RG8 +texture, then the RG texture must have twice as many pixels available for +output as the RGBA texture. + +Otherwise, if @respecify is %FALSE, then the copy is performed per texel +using glCopyTexImage. See the OpenGL specification for details on the +mappings between texture formats. + + Whether the copy suceeded + + + + + a #GstGLMemoryPBO + + + + the destination texture id + + + + the destination #GstGLTextureTarget + + + + the destination #GstGLFormat + + + + width of @tex_id + + + + height of @tex_id + + + + stride of the backing texture data + + + + whether to copy the data or copy per texel + + + + + + Transfer the texture data from the texture into the PBO if necessary. + + + + + + a #GstGLMemoryPBO + + + + + + Transfer the texture data from the PBO into the texture if necessary. + + + + + + a #GstGLMemoryPBO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Opaque #GstGLOverlayCompositor object + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + no platform + + + the EGL platform used primarily with the X11, wayland + and android window systems as well as on embedded Linux + + + the GLX platform used primarily with the X11 window system + + + the WGL platform used primarily on Windows + + + the CGL platform used primarily on OS X + + + the EAGL platform used primarily on iOS + + + any OpenGL platform + + + + A #GstGLQuery represents and holds an OpenGL query object. Various types of +queries can be run or counters retrieved. + + + + + + + + + + + + + + + + + + + + + + + + + Record the result of a counter + + + + + + a #GstGLQuery + + + + + + End counting the query + + + + + + a #GstGLQuery + + + + + + Frees a #GstGLQuery + + + + + + a #GstGLQuery + + + + + + + + + + + a #GstGLQuery + + + + a #GstGLContext + + + + the #GstGLQueryType + + + + + + + the result of the query + + + + + a #GstGLQuery + + + + + + Start counting the query + + + + + + a #GstGLQuery + + + + + + Free any dynamically allocated resources + + + + + + a #GstGLQuery + + + + + + Performs a GST_QUERY_CONTEXT query of type "gst.gl.local_context" on all +#GstPads in @element of @direction for the local OpenGL context used by +GStreamer elements. + + whether @context_ptr contains a #GstGLContext + + + + + a #GstElement to query from + + + + the #GstPadDirection to query + + + + location containing the current and/or resulting + #GstGLContext + + + + + + Free with gst_gl_query_free() + + a new #GstGLQuery + + + + + a #GstGLContext + + + + the #GstGLQueryType to create + + + + + + + + no query + + + query the time elapsed + + + query the current time + + + + GstGLRenderbuffer is a #GstGLBaseMemory subclass providing support for +OpenGL renderbuffers. + +#GstGLRenderbuffer is created or wrapped through gst_gl_base_memory_alloc() +with #GstGLRenderbufferAllocationParams. + + the parent object + + + + the GL texture id for this memory + + + + + + + the width + + + + the height + + + + + + + + + + + + + the #GstGLFormat of @gl_mem + + + + + a #GstGLRenderbuffer + + + + + + + the configured height of @gl_mem + + + + + a #GstGLRenderbuffer + + + + + + + the OpenGL renderbuffer handle of @gl_mem + + + + + a #GstGLRenderbuffer + + + + + + + the configured width of @gl_mem + + + + + a #GstGLRenderbuffer + + + + + + Initializes the GL Base Texture allocator. It is safe to call this function +multiple times. This must be called before any other GstGLRenderbuffer operation. + + + + + + + + + + + + + + + + + + + + + + + + + + a new #GstGLRenderbufferAllocationParams for allocating #GstGLRenderbuffer's + + + + + a #GstGLContext + + + + the #GstAllocationParams for sysmem mappings of the texture + + + + the #GstGLFormat for the created textures + + + + the width of the renderbuffer + + + + the height of the renderbuffer + + + + + + + a new #GstGLRenderbufferAllocationParams for wrapping @gl_handle as a + renderbuffer + + + + + a #GstGLContext + + + + the #GstAllocationParams for @tex_id + + + + the #GstGLFormat for @tex_id + + + + the width of the renderbuffer + + + + the height of the renderbuffer + + + + the GL handle to wrap + + + + user data to call @notify with + + + + a #GDestroyNotify + + + + + + + Opaque #GstGLRenderbufferAllocator struct + + + + + + + + + + + The #GstGLRenderbufferAllocatorClass only contains private data + + + + + + + + + + + Compilation stage that caused an error + + Compilation error occured + + + Link error occured + + + General program error occured + + + + GLSL profiles + + no profile supported/available + + + OpenGL|ES profile + + + OpenGL core profile + + + OpenGL compatibility profile + + + any OpenGL/OpenGL|ES profile + + + + #GstGLSLStage holds and represents a single OpenGL shader stage. + + + a new #GstGLSLStage of the specified @type + + + + + a #GstGLContext + + + + the GL enum shader stage type + + + + + + + + + + + + + + + + + + + + + + + + + + + a new #GstGLSLStage of the specified @type + + + + + a #GstGLContext + + + + the GL enum shader stage type + + + + the #GstGLSLVersion + + + + the #GstGLSLProfile + + + + a shader string + + + + + + + a new #GstGLSLStage of the specified @type + + + + + a #GstGLContext + + + + the GL enum shader stage type + + + + the #GstGLSLVersion + + + + the #GstGLSLProfile + + + + the number of strings in @str + + + + + an array of strings concatted together to produce a shader + + + + + + + + + whether the compilation suceeded + + + + + a #GstGLSLStage + + + + + + + The GL handle for this shader stage + + + + + a #GstGLSLStage + + + + + + + The GLSL profile for the current shader stage + + + + + a #GstGLSLStage + + + + + + + The GL shader type for this shader stage + + + + + a #GstGLSLStage + + + + + + + The GLSL version for the current shader stage + + + + + a #GstGLSLStage + + + + + + Replaces the current shader string with @str. + + + + + + a #GstGLSLStage + + + + a #GstGLSLVersion + + + + a #GstGLSLProfile + + + + number of strings in @str + + + + a GLSL shader string + + + + + + + + + + + + + + + + + + + + + + + Opaque #GstGLSLStageClass struct + + + + + + + + + + + + + GLSL version list + + no version + + + version 100 (only valid for ES) + + + version 110 (only valid for compatibility desktop GL) + + + version 120 (only valid for compatibility desktop GL) + + + version 130 (only valid for compatibility desktop GL) + + + version 140 (only valid for compatibility desktop GL) + + + version 150 (valid for compatibility/core desktop GL) + + + version 300 (only valid for ES) + + + version 310 (only valid for ES) + + + version 320 (only valid for ES) + + + version 330 (valid for compatibility/core desktop GL) + + + version 400 (valid for compatibility/core desktop GL) + + + version 410 (valid for compatibility/core desktop GL) + + + version 420 (valid for compatibility/core desktop GL) + + + version 430 (valid for compatibility/core desktop GL) + + + version 440 (valid for compatibility/core desktop GL) + + + version 450 (valid for compatibility/core desktop GL) + + + + + Note: must be called in the GL thread + + a new empty @shader + + + + + a #GstGLContext + + + + + + Note: must be called in the GL thread + + a default @shader or %NULL on failure + + + + + a #GstGLContext + + + + + + Each stage will attempt to be compiled and attached to @shader. Then +the shader will be linked. On error, %NULL will be returned and @error will +contain the details of the error. + +Note: must be called in the GL thread + + a new @shader with the specified stages. + + + + + a #GstGLContext + + + + a #GError + + + + a NULL terminated list of #GstGLSLStage's + + + + + + Each stage will attempt to be compiled and attached to @shader. On error, +%NULL will be returned and @error will contain the details of the error. + +Note: must be called in the GL thread + + a new @shader with the specified stages. + + + + + a #GstGLContext + + + + a #GError + + + + a NULL terminated list of #GstGLSLStage's + + + + + + Attaches @stage to @shader. @stage must have been successfully compiled +with gst_glsl_stage_compile(). + +Note: must be called in the GL thread + + whether @stage could be attached to @shader + + + + + a #GstGLShader + + + + a #GstGLSLStage to attach + + + + + + Attaches @stage to @shader. @stage must have been successfully compiled +with gst_glsl_stage_compile(). + +Note: must be called in the GL thread + + whether @stage could be attached to @shader + + + + + a #GstGLShader + + + + a #GstGLSLStage to attach + + + + + + Bind attribute @name to the specified location @index using +glBindAttributeLocation(). + + + + + + a #GstGLShader + + + + attribute index to set + + + + name of the attribute + + + + + + Bind attribute @name to the specified location @index using +glBindFragDataLocation(). + + + + + + a #GstGLShader + + + + attribute index to set + + + + name of the attribute + + + + + + Compiles @stage and attaches it to @shader. + +Note: must be called in the GL thread + + whether @stage could be compiled and attached to @shader + + + + + a #GstGLShader + + + + a #GstGLSLStage to attach + + + + + + Detaches @stage from @shader. @stage must have been successfully attached +to @shader with gst_gl_shader_attach() or gst_gl_shader_attach_unlocked(). + +Note: must be called in the GL thread + + + + + + a #GstGLShader + + + + a #GstGLSLStage to attach + + + + + + Detaches @stage from @shader. @stage must have been successfully attached +to @shader with gst_gl_shader_attach() or gst_gl_shader_attach_unlocked(). + +Note: must be called in the GL thread + + + + + + a #GstGLShader + + + + a #GstGLSLStage to attach + + + + + + + the attribute index for @name in @shader or -1 on failure + + + + + a #GstGLShader + + + + name of the attribute + + + + + + + the GL program handle for this shader + + + + + a #GstGLShader + + + + + + Note: must be called in the GL thread + + whether @shader has been successfully linked + + + + + a #GstGLShader + + + + + + Links the current list of #GstGLSLStage's in @shader. + +Note: must be called in the GL thread + + whether @shader could be linked together. + + + + + a #GstGLShader + + + + + + Releases the shader and stages. + +Note: must be called in the GL thread + + + + + + a #GstGLShader + + + + + + Releases the shader and stages. + +Note: must be called in the GL thread + + + + + + a #GstGLShader + + + + + + Perform glUniform1f() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + value to set + + + + + + Perform glUniform1fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of values to set + + + + values to set + + + + + + + + Perform glUniform1i() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + value to set + + + + + + Perform glUniform1iv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of values to set + + + + values to set + + + + + + + + Perform glUniform2f() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + first value to set + + + + second value to set + + + + + + Perform glUniform2fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of values to set + + + + values to set + + + + + + + + Perform glUniform2i() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + first value to set + + + + second value to set + + + + + + Perform glUniform2iv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of values to set + + + + values to set + + + + + + + + Perform glUniform3f() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + first value to set + + + + second value to set + + + + third value to set + + + + + + Perform glUniform3fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of values to set + + + + values to set + + + + + + + + Perform glUniform3i() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + first value to set + + + + second value to set + + + + third value to set + + + + + + Perform glUniform3iv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of values to set + + + + values to set + + + + + + + + Perform glUniform4f() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + first value to set + + + + second value to set + + + + third value to set + + + + fourth value to set + + + + + + Perform glUniform4fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of values to set + + + + values to set + + + + + + + + Perform glUniform4i() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + first value to set + + + + second value to set + + + + third value to set + + + + fourth value to set + + + + + + Perform glUniform4iv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of values to set + + + + values to set + + + + + + + + Perform glUniformMatrix2fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 2x2 matrices to set + + + + transpose the matrix + + + + matrix to set + + + + + + Perform glUniformMatrix2x3fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 2x3 matrices to set + + + + transpose the matrix + + + + values to set + + + + + + Perform glUniformMatrix2x4fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 2x4 matrices to set + + + + transpose the matrix + + + + values to set + + + + + + Perform glUniformMatrix3fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 3x3 matrices to set + + + + transpose the matrix + + + + values to set + + + + + + Perform glUniformMatrix3x2fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 3x2 matrices to set + + + + transpose the matrix + + + + values to set + + + + + + Perform glUniformMatrix3x4fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 3x4 matrices to set + + + + transpose the matrix + + + + values to set + + + + + + Perform glUniformMatrix4fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 4x4 matrices to set + + + + transpose the matrix + + + + values to set + + + + + + Perform glUniformMatrix4x2fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 4x2 matrices to set + + + + transpose the matrix + + + + values to set + + + + + + Perform glUniformMatrix4x3fv() for @name on @shader + + + + + + a #GstGLShader + + + + name of the uniform + + + + number of 4x3 matrices to set + + + + transpose the matrix + + + + values to set + + + + + + Mark's @shader as being used for the next GL draw command. + +Note: must be called in the GL thread and @shader must have been linked. + + + + + + a #GstGLShader + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Output anaglyph type to generate when downmixing to mono + + + + + + + + + #GstGLSyncMeta provides the ability to synchronize the OpenGL command stream +with the CPU or with other OpenGL contexts. + + the parent #GstMeta + + + + the #GstGLContext used to allocate the meta + + + + a custom data pointer for the implementation + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Set a sync point to possibly wait on at a later time. + + + + + + a #GstGLSyncMeta + + + + a #GstGLContext + + + + + + Insert a wait into @context's command stream ensuring all previous OpenGL +commands before @sync_meta have completed. + + + + + + a #GstGLSyncMeta + + + + a #GstGLContext + + + + + + Perform a wait so that the sync point has passed from the CPU's perspective +What that means, is that all GL operations changing CPU-visible data before +the sync point are now visible. + + + + + + a #GstGLSyncMeta + + + + a #GstGLContext + + + + + + + + + + + + + no texture target + + + 2D texture target + + + rectangle texture target + + + external oes texture target + + + + #GstGLUpload is an object that uploads data from system memory into GL textures. + +A #GstGLUpload can be created with gst_gl_upload_new() + + + a new #GstGLUpload object + + + + + a #GstGLContext + + + + + + + + + + + + + + + + a #GstGLUpload + + + + the input #GstCaps + + + + the output #GstCaps + + + + + + Uploads @buffer using the transformation specified by +gst_gl_upload_set_caps() creating a new #GstBuffer in @outbuf_ptr. + + whether the upload was successful + + + + + a #GstGLUpload + + + + input #GstBuffer + + + + resulting #GstBuffer + + + + + + Adds the required allocation parameters to support uploading. + + + + + + a #GstGLUpload + + + + a #GstQuery from a decide allocation + + + + the proposed allocation query + + + + + + Initializes @upload with the information required for upload. + + whether @in_caps and @out_caps could be set on @upload + + + + + a #GstGLUpload + + + + input #GstCaps + + + + output #GstCaps + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The #GstGLUploadClass struct only contains private data + + + + + + + + + + + + + + No further processing required + + + An unspecified error occured + + + The configuration is unsupported. + + + This element requires a reconfiguration. + + + + + the parent #GstGLAllocationParams structure + + + + the #GstVideoInfo to allocate + + + + the video plane index to allocate + + + + the #GstVideoAlignment to align the system representation to (may be %NULL for the default) + + + + the #GstGLTextureTarget to allocate + + + + the #GstGLFormat to allocate + + + + + + + + + + a new #GstGLVideoAllocationParams for allocating #GstGLMemory's + + + + + a #GstGLContext + + + + the #GstAllocationParams for sysmem mappings of the texture + + + + the #GstVideoInfo for the texture + + + + the video plane of @v_info to allocate + + + + any #GstVideoAlignment applied to symem mappings of the texture + + + + the #GstGLTextureTarget for the created textures + + + + the #GstGLFormat for the created textures + + + + + + + a new #GstGLVideoAllocationParams for wrapping @wrapped_data + + + + + a #GstGLContext + + + + the #GstAllocationParams for @wrapped_data + + + + the #GstVideoInfo for @wrapped_data + + + + the video plane @wrapped_data represents + + + + any #GstVideoAlignment applied to symem mappings of @wrapped_data + + + + the #GstGLTextureTarget for @wrapped_data + + + + the #GstGLFormat for @wrapped_data + + + + the data pointer to wrap + + + + user data to call @notify with + + + + a #GDestroyNotify + + + + + + @gl_handle is defined by the specific OpenGL handle being wrapped +For #GstGLMemory and #GstGLMemoryPBO it is an OpenGL texture id. +Other memory types may define it to require a different type of parameter. + + a new #GstGLVideoAllocationParams for wrapping @gl_handle + + + + + a #GstGLContext + + + + the #GstAllocationParams for @tex_id + + + + the #GstVideoInfo for @tex_id + + + + the video plane @tex_id represents + + + + any #GstVideoAlignment applied to symem mappings of @tex_id + + + + the #GstGLTextureTarget for @tex_id + + + + the #GstGLFormat for @tex_id + + + + the GL handle to wrap + + + + user data to call @notify with + + + + a #GDestroyNotify + + + + + + + a new #GstGLVideoAllocationParams for wrapping @tex_id + + + + + a #GstGLContext + + + + the #GstAllocationParams for @tex_id + + + + the #GstVideoInfo for @tex_id + + + + the video plane @tex_id represents + + + + any #GstVideoAlignment applied to symem mappings of @tex_id + + + + the #GstGLTextureTarget for @tex_id + + + + the #GstGLFormat for @tex_id + + + + the GL texture to wrap + + + + user data to call @notify with + + + + a #GDestroyNotify + + + + + + Copy and set any dynamically allocated resources in @dest_vid. Intended +for subclass usage only to chain up at the end of a subclass copy function. + + + + + + source #GstGLVideoAllocationParams to copy from + + + + destination #GstGLVideoAllocationParams to copy into + + + + + + Unset and free any dynamically allocated resources. Intended for subclass +usage only to chain up at the end of a subclass free function. + + + + + + a #GstGLVideoAllocationParams + + + + + + Intended for subclass usage + + initializes @params with the parameters specified + + + + + a #GstGLVideoAllocationParams to initialize + + + + the size of the struct in @params + + + + some allocation flags + + + + a copy function + + + + a free function + + + + a #GstGLContext + + + + the #GstAllocationParams for @wrapped_data + + + + the #GstVideoInfo for @wrapped_data + + + + the video plane @wrapped_data represents + + + + any #GstVideoAlignment applied to symem mappings of @wrapped_data + + + + the #GstGLTextureTarget + + + + the #GstGLFormat + + + + the optional data pointer to wrap + + + + the optional OpenGL handle to wrap or 0 + + + + user data to call @notify with + + + + a #GDestroyNotify + + + + + + + Convert stereoscopic/multiview video using fragment shaders. + + + a new #GstGLViewConvert + + + + + Provides an implementation of #GstBaseTransformClass::fixate_caps() + + the fixated #GstCaps + + + + + a #GstGLViewConvert + + + + a #GstPadDirection + + + + the #GstCaps of @direction + + + + the #GstCaps to fixate + + + + + + Retrieve the processed output buffer placing the output in @outbuf_ptr. + + a #GstFlowReturn + + + + + a #GstGLViewConvert + + + + a #GstBuffer + + + + + + Converts the data contained by @inbuf using the formats specified by the +#GstCaps passed to gst_gl_view_convert_set_caps() + + a converted #GstBuffer or %NULL + + + + + a #GstGLViewConvert + + + + the #GstGLMemory filled #GstBuffer to convert + + + + + + Reset @viewconvert to the default state. Further operation will require +setting the caps with gst_gl_view_convert_set_caps(). + + + + + + a #GstGLViewConvert + + + + + + Initializes @viewconvert with the information required for conversion. + + + + + + a #GstGLViewConvert + + + + input #GstCaps + + + + output #GstCaps + + + + + + Set @context on @viewconvert + + + + + + a #GstGLViewConvert + + + + the #GstGLContext to set + + + + + + Submit @input to be processed by @viewconvert + + a #GstFlowReturn + + + + + a #GstGLViewConvert + + + + true if we have a discontinuity + + + + a #GstBuffer + + + + + + Provides an implementation of #GstBaseTransformClass::transform_caps() + + the converted #GstCaps + + + + + a #GstGLViewConvert + + + + a #GstPadDirection + + + + the #GstCaps to transform + + + + a set of filter #GstCaps + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Opaque #GstGLViewConvertClass struct + + + + + + + + + + + + + GstGLWindow represents a window that elements can render into. A window can +either be a user visible window (onscreen) or hidden (offscreen). + + + a new #GstGLWindow using @display's connection + + + + + a #GstGLDisplay + + + + + + + + + + + + + + + + + + + + + Redraw the window contents. Implementations should invoke the draw callback. + + + + + + a #GstGLWindow + + + + + + + the windowing system display handle for this @window + + + + + a #GstGLWindow + + + + + + + the window handle we are currently rendering into + + + + + a #GstGLWindow + + + + + + Tell a @window that it should handle events from the window system. These +events are forwarded upstream as navigation events. In some window systems +events are not propagated in the window hierarchy if a client is listening +for them. This method allows you to disable events handling completely +from the @window. + + + + + + a #GstGLWindow + + + + a #gboolean indicating if events should be handled or not. + + + + + + + + + + + + + + + + + + + + + + + + + + Quit the runloop's execution. + + + + + + a #GstGLWindow + + + + + + Start the execution of the runloop. + + + + + + a #GstGLWindow + + + + + + Invoke @callback with data on the window thread. @callback is guarenteed to +have executed when this function returns. + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + + + Invoke @callback with @data on the window thread. The callback may not +have been executed when this function returns. + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + called when @data is not needed anymore + + + + + + Set the preferred width and height of the window. Implementations are free +to ignore this information. + + + + + + a #GstGLWindow + + + + new preferred width + + + + new preferred height + + + + + + Tell a @window that it should render into a specific region of the window +according to the #GstVideoOverlay interface. + + whether the specified region could be set + + + + + a #GstGLWindow + + + + x position + + + + y position + + + + width + + + + height + + + + + + Sets the window that this @window should render into. Some implementations +require this to be called with a valid handle before drawing can commence. + + + + + + a #GstGLWindow + + + + handle to the window + + + + + + Present the window to the screen. + + + + + + a #GstGLWindow + + + + + + Redraw the window contents. Implementations should invoke the draw callback. + + + + + + a #GstGLWindow + + + + + + + the #GstGLContext associated with this @window + + + + + a #GstGLWindow + + + + + + + the windowing system display handle for this @window + + + + + a #GstGLWindow + + + + + + + + + + + a #GstGLWindow + + + + resulting surface width + + + + resulting surface height + + + + + + + the window handle we are currently rendering into + + + + + a #GstGLWindow + + + + + + Tell a @window that it should handle events from the window system. These +events are forwarded upstream as navigation events. In some window systems +events are not propagated in the window hierarchy if a client is listening +for them. This method allows you to disable events handling completely +from the @window. + + + + + + a #GstGLWindow + + + + a #gboolean indicating if events should be handled or not. + + + + + + + + + + + + + + + + Quit the runloop's execution. + + + + + + a #GstGLWindow + + + + + + + + + + + + + + + + + + + + + + Start the execution of the runloop. + + + + + + a #GstGLWindow + + + + + + + + + + + + + + + + + + + + + + Invoke @callback with data on the window thread. @callback is guarenteed to +have executed when this function returns. + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + + + Invoke @callback with @data on the window thread. The callback may not +have been executed when this function returns. + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + called when @data is not needed anymore + + + + + + + + + + + + + + + + + + + + + + + + + + + + Sets the callback called when the window is about to close. + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + called when @data is not needed any more + + + + + + Sets the draw callback called everytime gst_gl_window_draw() is called + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + called when @data is not needed any more + + + + + + Set the preferred width and height of the window. Implementations are free +to ignore this information. + + + + + + a #GstGLWindow + + + + new preferred width + + + + new preferred height + + + + + + Tell a @window that it should render into a specific region of the window +according to the #GstVideoOverlay interface. + + whether the specified region could be set + + + + + a #GstGLWindow + + + + x position + + + + y position + + + + width + + + + height + + + + + + Sets the resize callback called everytime a resize of the window occurs. + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + called when @data is not needed any more + + + + + + Sets the window that this @window should render into. Some implementations +require this to be called with a valid handle before drawing can commence. + + + + + + a #GstGLWindow + + + + handle to the window + + + + + + Present the window to the screen. + + + + + + a #GstGLWindow + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Will be emitted when a key event is received by the GstGLwindow. + + + + + + the name of the event + + + + the id of the key pressed + + + + + + Will be emitted when a mouse event is received by the GstGLwindow. + + + + + + the name of the event + + + + the id of the button + + + + the x coordinate of the mouse event + + + + the y coordinate of the mouse event + + + + + + + + + + + + + + + + + + Parent class + + + + + + the windowing system display handle for this @window + + + + + a #GstGLWindow + + + + + + + + + + + + + a #GstGLWindow + + + + handle to the window + + + + + + + + + the window handle we are currently rendering into + + + + + a #GstGLWindow + + + + + + + + + + + + + a #GstGLWindow + + + + + + + + + + + + + a #GstGLWindow + + + + + + + + + + + + + a #GstGLWindow + + + + + + + + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + + + + + + + + + + a #GstGLWindow + + + + function to invoke + + + + data to invoke @callback with + + + + called when @data is not needed anymore + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + a #GstGLWindow + + + + a #gboolean indicating if events should be handled or not. + + + + + + + + + + + + + a #GstGLWindow + + + + new preferred width + + + + new preferred height + + + + + + + + + + + + + a #GstGLWindow + + + + + + + + + whether the specified region could be set + + + + + a #GstGLWindow + + + + x position + + + + y position + + + + width + + + + height + + + + + + + + + + + + + + + + + + + + + + + + + + failed for a unspecified reason + + + the implementation is too old + + + no such resource was found + + + + + + + + + + + + + + + + + + + + + + GL Allocation flag indicating that the implementation should allocate the +necessary resources. + + + + GL allocation flag indicating the allocation of a GL buffer. + + + + Values >= than #GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_USER can be used for +user-defined purposes. + + + + GL allocation flag indicating the allocation of 2D video frames + + + + GL Allocation flag for using the provided GPU handle as storage. + + + + GL Allocation flag for using the provided system memory data as storage. + + + + The name for %GST_GL_API_GLES1 used in various places + + + + The name for %GST_GL_API_GLES2 used in various places + + + + The name for %GST_GL_API_OPENGL3 used in various places + + + + The name for %GST_GL_API_OPENGL used in various places + + + + The name of the GL buffer allocator + + + + The name of the GL buffer allocator + + + + The currently supported formats that can be converted + + + + The currently supported #GstCaps that can be converted + + + + + + + + + + + + + + + + + + + The name used in #GstContext queries for requesting a #GstGLDisplay + + + + + + + The name of the GL memory allocator + + + + The name of the GL Memory PBO allocator + + + + List of video formats that are supported by #GstGLMemory + + + + The name of the GL renderbuffer allocator + + + + String used for %GST_GL_TEXTURE_TARGET_2D in things like caps values + + + + String used for %GST_GL_TEXTURE_TARGET_EXTERNAL_OES in things like caps values + + + + String used for %GST_GL_TEXTURE_TARGET_RECTANGLE in things like caps values + + + + Flag indicating that we should map the GL object instead of to system memory. + +Combining #GST_MAP_GL with #GST_MAP_WRITE has the same semantics as though +you are writing to OpenGL. Conversely, combining #GST_MAP_GL with +#GST_MAP_READ has the same semantics as though you are reading from OpenGL. + + + + + the #GstGLSyncMeta added to #GstBuffer + + + + + a #GstGLContext + + + + a #GstBuffer + + + + + + + the #GstGLSyncMeta added to #GstBuffer + + + + + a #GstGLContext + + + + a #GstBuffer + + + + sync data to hold + + + + + + + the currently set #GstGLAllocationParams or %NULL + + + + + a buffer pool config + + + + + + Sets @params on @config + + + + + + a buffer pool config + + + + a #GstGLAllocationParams + + + + + + + Whether @display was in @context + + + + + a #GstContext + + + + resulting #GstGLDisplay + + + + + + Sets @display on @context + + + + + + a #GstContext + + + + resulting #GstGLDisplay + + + + + + + The #GstGLAPI represented by @api_s + + + + + a space seperated string of OpenGL apis + + + + + + + A space seperated string of the OpenGL api's enabled in @api + + + + + a #GstGLAPI to stringify + + + + + + Free with gst_gl_async_debug_free() + + a new #GstGLAsyncDebug + + + + + + a new #GstGLBaseMemory from @allocator with the requested @params. + + + + + a #GstGLBaseMemoryAllocator + + + + the #GstGLAllocationParams to allocate the memory with + + + + + + + + + + + Initializes the GL Base Memory allocator. It is safe to call this function +multiple times. This must be called before any other GstGLBaseMemory operation. + + + + + + Initializes the GL Buffer allocator. It is safe to call this function +multiple times. This must be called before any other #GstGLBuffer operation. + + + + + + + whether @name is in the space seperated list of @ext + + + + + the extension to search for + + + + the list of possible extensions + + + + + + + + + + + + + + + + + + + Perform the steps necessary for retrieving a #GstGLDisplay and (optionally) +an application provided #GstGLContext from the surrounding elements or from +the application using the #GstContext mechanism. + +If the contents of @display_ptr or @other_context_ptr are not %NULL, then no +#GstContext query is necessary for #GstGLDisplay or #GstGLContext retrieval +or is performed. + +This performs #GstContext queries (if necessary) for a winsys display +connection with %GST_GL_DISPLAY_CONTEXT_TYPE, "gst.x11.display.handle", and +"GstWaylandDisplayHandleContextType" stopping after the first successful +retrieval. + +This also performs a #GstContext query (if necessary) for an optional +application provided #GstGLContext using the name "gst.gl.app_context". +The returned #GstGLContext will be shared with a GStreamer created OpenGL context. + + whether a #GstGLDisplay exists in @display_ptr + + + + + the #GstElement running the query + + + + the resulting #GstGLDisplay + + + + the resulting #GstGLContext + + + + + + + the #GstGLFormat necessary for holding the data in @plane of @vinfo + + + + + a #GstGLContext + + + + a #GstVideoInfo + + + + the plane number in @vinfo + + + + + + + the number of bytes the specified @format, @type combination takes +per pixel + + + + + the OpenGL format, %GL_RGBA, %GL_LUMINANCE, etc + + + + the OpenGL type, %GL_UNSIGNED_BYTE, %GL_FLOAT, etc + + + + + + Retrieve the size in bytes of a video plane of data with a certain alignment + + + + + + a #GstVideoInfo + + + + a #GstVideoAlignment or %NULL + + + + plane number in @info to retrieve the data size of + + + + + + + difference between the supposed start of the plane from the @info + and where the data from the previous plane ends. + + + + + a #GstVideoInfo + + + + a #GstVideoAlignment or %NULL + + + + plane number in @info to retrieve the data size of + + + + + + + Whether the @query was successfully responded to from the passed + @display, @context, and @other_context. + + + + + a #GstElement + + + + a #GstQuery of type %GST_QUERY_CONTEXT + + + + a #GstGLDisplay + + + + a #GstGLContext + + + + application provided #GstGLContext + + + + + + Helper function for implementing GstElement::set_context() in OpenGL capable +elements. + +Retrieve's the #GstGLDisplay or #GstGLContext in @context and places the +result in @display or @other_context respectively. + + whether the @display or @other_context could be set successfully + + + + + a #GstElement + + + + a #GstContext + + + + location of a #GstGLDisplay + + + + location of a #GstGLContext + + + + + + Inserts a marker into a GL debug stream. Requires the 'gldebugmarker' +debug category to be at least %GST_LEVEL_FIXME. + + + + + + a #GstGLContext + + + + a printf-style format string + + + + arguments form @format + + + + + + Initializes the GL Base Texture allocator. It is safe to call this function +multiple times. This must be called before any other GstGLMemory operation. + + + + + + + + + + + + The #GstGLPlatform represented by @platform_s + + + + + a space seperated string of OpenGL platformss + + + + + + + A space seperated string of the OpenGL platforms enabled in @platform + + + + + a #GstGLPlatform to stringify + + + + + + Performs a GST_QUERY_CONTEXT query of type "gst.gl.local_context" on all +#GstPads in @element of @direction for the local OpenGL context used by +GStreamer elements. + + whether @context_ptr contains a #GstGLContext + + + + + a #GstElement to query from + + + + the #GstPadDirection to query + + + + location containing the current and/or resulting + #GstGLContext + + + + + + Free with gst_gl_query_free() + + a new #GstGLQuery + + + + + a #GstGLContext + + + + the #GstGLQueryType to create + + + + + + Initializes the GL Base Texture allocator. It is safe to call this function +multiple times. This must be called before any other GstGLRenderbuffer operation. + + + + + + + the sized internal format specified by @format and @type that can + be used in @context + + + + + a #GstGLContext + + + + an OpenGL format, %GL_RGBA, %GL_LUMINANCE, etc + + + + an OpenGL type, %GL_UNSIGNED_BYTE, %GL_FLOAT, etc + + + + + + + + + + + + + + + + + the #GstGLTextureTarget that's equiavalant to @target or + %GST_GL_TEXTURE_TARGET_NONE + + + + + an OpenGL texture binding target + + + + + + + the #GstGLTextureTarget represented by @str or + %GST_GL_TEXTURE_TARGET_NONE + + + + + a string equivalant to one of the GST_GL_TEXTURE_TARGET_*_STR values + + + + + + + a string representing the @GstBufferPoolOption specified by @target + + + + + a #GstGLTextureTarget + + + + + + + the OpenGL value for binding the @target with glBindTexture() and + similar functions or 0 + + + + + a #GstGLTextureTarget + + + + + + + the stringified version of @target or %NULL + + + + + a #GstGLTextureTarget + + + + + + See gst_gl_value_set_texture_target_from_mask() for what entails a mask + + the mask of #GstGLTextureTarget's in @value + + + + + an initialized #GValue of type G_TYPE_STRING + + + + + + + whether the @target could be set on @value + + + + + an initialized #GValue of type G_TYPE_STRING + + + + a #GstGLTextureTarget's + + + + + + A mask is a bitwise OR of (1 << target) where target is a valid +#GstGLTextureTarget + + whether the @target_mask could be set on @value + + + + + an uninitialized #GValue + + + + a bitwise mask of #GstGLTextureTarget's + + + + + + + The minimum supported #GstGLSLVersion available for @gl_api, @maj and @min + + + + + the #GstGLAPI + + + + the major GL version + + + + the minor GL version + + + + + + + + + + + + the #GstGLSLProfile of @string or %GST_GLSL_PROFILE_NONE on error + + + + + a GLSL version string + + + + + + + the name for @profile or %NULL on error + + + + + a #GstGLSLProfile + + + + + + Note: this function first searches the first 1 kilobytes for a #version +preprocessor directive and then executes gst_glsl_version_profile_from_string(). + + TRUE if a valid #version string was found, FALSE otherwise + + + + + string to search for a valid #version string + + + + resulting #GstGLSLVersion + + + + resulting #GstGLSLProfile + + + + + + + the #GstGLSLVersion of @string or %GST_GLSL_VERSION_NONE on error + + + + + a GLSL version string + + + + + + Note: this function expects either a #version GLSL preprocesser directive +or a valid GLSL version and/or profile. + + TRUE if a valid #version string was found, FALSE otherwise + + + + + a valid GLSL #version string + + + + resulting #GstGLSLVersion + + + + resulting #GstGLSLVersion + + + + + + + the combined GLSL #version string for @version and @profile + + + + + a #GstGLSLVersion + + + + a #GstGLSLVersion + + + + + + + the name of @version or %NULL on error + + + + + a #GstGLSLVersion + + + + + + + whether the memory at @mem is a #GstGLBaseMemory + + + + + a #GstMemory + + + + + + + whether the memory at @mem is a #GstGLBuffer + + + + + a #GstMemory + + + + + + + whether the memory at @mem is a #GstGLMemory + + + + + a #GstMemory + + + + + + + whether the memory at @mem is a #GstGLMemoryPBO + + + + + a #GstMemory + + + + + + + whether the memory at @mem is a #GstGLRenderbuffer + + + + + a #GstMemory + + + + + + diff --git a/gir-files/GstMpegts-1.0.gir b/gir-files/GstMpegts-1.0.gir index e5309565c..0677e14ae 100644 --- a/gir-files/GstMpegts-1.0.gir +++ b/gir-files/GstMpegts-1.0.gir @@ -414,7 +414,7 @@ Consult the relevant specifications for more details. - descriptors + an array of #GstMpegtsDescriptor @@ -455,7 +455,10 @@ Consult the relevant specifications for more details. + c:type="GstMpegtsCableDeliverySystemDescriptor" + glib:type-name="GstMpegtsCableDeliverySystemDescriptor" + glib:get-type="gst_mpegts_dvb_cable_delivery_system_descriptor_get_type" + c:symbol-prefix="dvb_cable_delivery_system_descriptor"> Cable Delivery System Descriptor (EN 300 468 v.1.13.1) the frequency in Hz (Hertz) @@ -478,6 +481,18 @@ Consult the relevant specifications for more details. inner FEC scheme used + + + + + + + + + + @@ -1500,7 +1515,9 @@ two bytes are the @tag and @length. optional="1" allow-none="1"> The private data - + + + caller-allocates="0" transfer-ownership="full"> the selector bytes, if present - + + + #GstMpegtsDescriptor - + the component tag @@ -1935,7 +1957,9 @@ registered by http://www.dvbservices.com/ optional="1" allow-none="1"> additional data or NULL - + + + descriptor data (after tag and length field) - + + + length of @data @@ -2459,7 +2485,9 @@ ISO 639-1 language code from the returned ISO 639-2 one. descriptor data (after tag and length field) - + + + length of @data @@ -2569,7 +2597,9 @@ a single language nullable="1" allow-none="1"> pointer to optional additional info - + + + length of the optional @additional_info @@ -3687,7 +3717,9 @@ else %NULL a pointer to the beginning of the section (i.e. the first byte should contain the table_id field). - + + + size of the @data argument. @@ -4929,7 +4961,9 @@ profiles defined in Annex A for service-compatible stereoscopic 3D services descriptor data (after tag and length field) - + + + length of @data @@ -4956,7 +4990,9 @@ profiles defined in Annex A for service-compatible stereoscopic 3D services descriptor data (after tag and length field) - + + + length of @data @@ -5071,7 +5107,9 @@ a single language nullable="1" allow-none="1"> pointer to optional additional info - + + + length of the optional @additional_info diff --git a/gir-files/fix.sh b/gir-files/fix.sh new file mode 100755 index 000000000..d87481540 --- /dev/null +++ b/gir-files/fix.sh @@ -0,0 +1,59 @@ +#!/bin/bash +set -x -e + +# Remove GLFuncs record +# commit 5765641 +xmlstarlet ed --pf --inplace --delete '//_:record[@name="GLFuncs"]' GstGL-1.0.gir + +# Add a disguised GFuncs record (two steps) +xmlstarlet ed --pf --inplace \ + --subnode '//_:namespace' --type elem -n 'recordTMP' --value ' ' \ + GstGL-1.0.gir + +xmlstarlet ed --pf --inplace \ + --insert '//_:recordTMP' -t attr -n 'name' --value 'GLFuncs' \ + --insert '//_:recordTMP' -t attr -n 'c:type' --value 'GstGLFuncs' \ + --insert '//_:recordTMP' -t attr -n 'disguised' --value '1' \ + --rename '//_:recordTMP' --value 'record' \ + GstGL-1.0.gir + +# incorrect GIR due bug #797144 +xmlstarlet ed --pf --inplace \ + --update '//*[@c:identifier="Dubois optimised Green-Magenta anaglyph"]/@c:identifier' \ + --value GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS \ + --update '//*[@c:identifier="Dubois optimised Red-Cyan anaglyph"]/@c:identifier' \ + --value GST_GL_STEREO_DOWNMIX_ANAGLYPH_RED_CYAN_DUBOIS \ + --update '//*[@c:identifier="Dubois optimised Amber-Blue anaglyph"]/@c:identifier' \ + --value GST_GL_STEREO_DOWNMIX_ANAGLYPH_AMBER_BLUE_DUBOIS \ + GstGL-1.0.gir + +# Remove GstDisplayWayland +xmlstarlet ed --pf --inplace \ + --delete '//_:class[@name="GLDisplayWayland"]' \ + --delete '//_:record[@name="GLDisplayWaylandClass"]' \ + GstGL-1.0.gir + +# Remove GstDisplayX11 +xmlstarlet ed --pf --inplace \ + --delete '//_:class[@name="GLDisplayX11"]' \ + --delete '//_:record[@name="GLDisplayX11Class"]' \ + GstGL-1.0.gir + +# Remove GstMemoryEGL +xmlstarlet ed --pf --inplace \ + --delete '//_:record[@name="GLMemoryEGL"]' \ + --delete '//_:record[@name="GLMemoryEGLAllocator"]' \ + --delete '//_:record[@name="GLMemoryEGLAllocatorClass"]' \ + GstGL-1.0.gir + +xmlstarlet ed --pf --inplace \ + --delete '//_:method[@c:identifier="gst_gl_display_egl_from_gl_display"]' \ + GstGL-1.0.gir + +# Remove all libcheck related API +xmlstarlet ed --pf --inplace \ + --delete '//_:function[starts-with(@name, "check_")]' \ + --delete '//_:function[starts-with(@name, "buffer_straw_")]' \ + --delete '//_:callback[starts-with(@name, "Check")]' \ + --delete '//_:record[starts-with(@name, "Check")]' \ + GstCheck-1.0.gir