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