mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-10 03:19:40 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst-libs/gst/gl/gstglsyncmeta.c

331 lines
8.6 KiB
C
Raw Normal View History

gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
/*
* GStreamer
* Copyright (C) 2014 Matthew Waters <matthew@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gl.h"
#include "gstglsyncmeta.h"
#define GST_CAT_DEFAULT gst_gl_sync_meta_debug
GST_DEBUG_CATEGORY (GST_CAT_DEFAULT);
glsyncmeta: also supported with gles3
2015-02-23 14:20:23 +00:00
#ifndef GL_SYNC_GPU_COMMANDS_COMPLETE
#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
#endif
#ifndef GL_SYNC_FLUSH_COMMANDS_BIT
#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
#endif
glsyncmeta: add compat definition for gles2
2015-02-24 09:34:35 +00:00
#ifndef GL_TIMEOUT_EXPIRED
#define GL_TIMEOUT_EXPIRED 0x911B
#endif
glsyncmeta: add compatibility definition for GL_TIMEOUT_IGNORED
2016-02-09 02:08:21 +00:00
#ifndef GL_TIMEOUT_IGNORED
#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull
#endif
glsyncmeta: also supported with gles3
2015-02-23 14:20:23 +00:00
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
static void
_default_set_sync_gl (GstGLSyncMeta * sync_meta, GstGLContext * context)
{
const GstGLFuncs *gl = context->gl_vtable;
if (gl->FenceSync) {
if (sync_meta->data) {
GST_LOG ("deleting sync object %p", sync_meta->data);
gl->DeleteSync ((GLsync) sync_meta->data);
}
sync_meta->data =
(gpointer) gl->FenceSync (GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
glsyncmeta: only flush with a shared context The wait code will flush for us for single context pipelines.
2016-01-07 03:08:39 +00:00
if (gst_gl_context_is_shared (context))
/* if we only have a single context, the wait will flush for us */
gl->Flush ();
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
GST_LOG ("setting sync object %p", sync_meta->data);
} else {
glsyncmeta: separate out gpu/cpu waits. CPU waits are more expensive and are only required if the CPU is ever going to access the data. GPU waits perform inter-context synchronisation and are cheaper as they don't require CPU intervention.
2016-02-09 01:14:04 +00:00
/* XXX: this a little over the top if the CPU is never going to
* access the data, however this is the legacy path, so... */
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
gl->Finish ();
}
}
static void
_default_wait_gl (GstGLSyncMeta * sync_meta, GstGLContext * context)
glsyncmeta: separate out gpu/cpu waits. CPU waits are more expensive and are only required if the CPU is ever going to access the data. GPU waits perform inter-context synchronisation and are cheaper as they don't require CPU intervention.
2016-02-09 01:14:04 +00:00
{
const GstGLFuncs *gl = context->gl_vtable;
if (sync_meta->data && gl->WaitSync) {
GST_LOG ("waiting on sync object %p", sync_meta->data);
gl->WaitSync ((GLsync) sync_meta->data, 0, GL_TIMEOUT_IGNORED);
}
}
static void
_default_wait_cpu_gl (GstGLSyncMeta * sync_meta, GstGLContext * context)
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
{
const GstGLFuncs *gl = context->gl_vtable;
GLenum res;
if (sync_meta->data && gl->ClientWaitSync) {
do {
GST_LOG ("waiting on sync object %p", sync_meta->data);
res =
gl->ClientWaitSync ((GLsync) sync_meta->data,
GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000 /* 1s */ );
} while (res == GL_TIMEOUT_EXPIRED);
}
}
static void
_default_copy (GstGLSyncMeta * src, GstBuffer * sbuffer, GstGLSyncMeta * dest,
GstBuffer * dbuffer)
{
GST_LOG ("copy sync object %p from meta %p to %p", src->data, src, dest);
/* Setting a sync point here relies on GstBuffer copying
* metas after data */
gst_gl_sync_meta_set_sync_point (src, src->context);
}
static void
_default_free_gl (GstGLSyncMeta * sync_meta, GstGLContext * context)
{
const GstGLFuncs *gl = context->gl_vtable;
if (sync_meta->data) {
GST_LOG ("deleting sync object %p", sync_meta->data);
gl->DeleteSync ((GLsync) sync_meta->data);
sync_meta->data = NULL;
}
}
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
GstGLSyncMeta *
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
gst_buffer_add_gl_sync_meta_full (GstGLContext * context, GstBuffer * buffer,
gpointer data)
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
{
glsyncmeta: make context to wait and set sync explicit otherwise we may wait on a sync object in same context by accident
2015-03-14 16:25:29 +00:00
GstGLSyncMeta *meta;
gl: be consistent in gobject boilerpate GST_GL_IS_* vs GST_IS_GL_* git grep -l 'GST_GL_IS_' | xargs sed -i 's/GST_GL_IS_/GST_IS_GL_/g'
2015-10-19 04:15:30 +00:00
g_return_val_if_fail (GST_IS_GL_CONTEXT (context), NULL);
glsyncmeta: make context to wait and set sync explicit otherwise we may wait on a sync object in same context by accident
2015-03-14 16:25:29 +00:00
meta =
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
(GstGLSyncMeta *) gst_buffer_add_meta ((buffer), GST_GL_SYNC_META_INFO,
NULL);
if (!meta)
return NULL;
meta->context = gst_object_ref (context);
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
meta->data = data;
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
return meta;
}
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
GstGLSyncMeta *
gst_buffer_add_gl_sync_meta (GstGLContext * context, GstBuffer * buffer)
{
GstGLSyncMeta *ret = gst_buffer_add_gl_sync_meta_full (context, buffer, NULL);
if (!ret)
return NULL;
ret->set_sync_gl = _default_set_sync_gl;
ret->wait_gl = _default_wait_gl;
glsyncmeta: separate out gpu/cpu waits. CPU waits are more expensive and are only required if the CPU is ever going to access the data. GPU waits perform inter-context synchronisation and are cheaper as they don't require CPU intervention.
2016-02-09 01:14:04 +00:00
ret->wait_cpu_gl = _default_wait_cpu_gl;
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
ret->copy = _default_copy;
ret->free_gl = _default_free_gl;
glsyncmeta: Actually return the newly created meta from gst_buffer_add_gl_sync_meta() gstglsyncmeta.c -fPIC -DPIC -o .libs/libgstgl_1.0_la-gstglsyncmeta.o gstglsyncmeta.c: In function 'gst_buffer_add_gl_sync_meta': gstglsyncmeta.c:131:1: error: control reaches end of non-void function [-Werror=return-type] } ^
2015-11-17 15:08:14 +00:00
return ret;
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
}
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
static void
_set_sync_point (GstGLContext * context, GstGLSyncMeta * sync_meta)
{
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
g_assert (sync_meta->set_sync_gl != NULL);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
GST_LOG ("setting sync point %p", sync_meta);
sync_meta->set_sync_gl (sync_meta, context);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
}
void
gst_gl_sync_meta_set_sync_point (GstGLSyncMeta * sync_meta,
GstGLContext * context)
{
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
if (sync_meta->set_sync)
sync_meta->set_sync (sync_meta, context);
else
gst_gl_context_thread_add (context,
(GstGLContextThreadFunc) _set_sync_point, sync_meta);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
}
static void
_wait (GstGLContext * context, GstGLSyncMeta * sync_meta)
{
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
g_assert (sync_meta->wait_gl != NULL);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
GST_LOG ("waiting %p", sync_meta);
sync_meta->wait_gl (sync_meta, context);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
}
void
glsyncmeta: make context to wait and set sync explicit otherwise we may wait on a sync object in same context by accident
2015-03-14 16:25:29 +00:00
gst_gl_sync_meta_wait (GstGLSyncMeta * sync_meta, GstGLContext * context)
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
{
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
if (sync_meta->wait)
sync_meta->wait (sync_meta, context);
else
glsyncmeta: make context to wait and set sync explicit otherwise we may wait on a sync object in same context by accident
2015-03-14 16:25:29 +00:00
gst_gl_context_thread_add (context,
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
(GstGLContextThreadFunc) _wait, sync_meta);
}
glsyncmeta: separate out gpu/cpu waits. CPU waits are more expensive and are only required if the CPU is ever going to access the data. GPU waits perform inter-context synchronisation and are cheaper as they don't require CPU intervention.
2016-02-09 01:14:04 +00:00
static void
_wait_cpu (GstGLContext * context, GstGLSyncMeta * sync_meta)
{
g_assert (sync_meta->wait_cpu_gl != NULL);
GST_LOG ("waiting %p", sync_meta);
sync_meta->wait_cpu_gl (sync_meta, context);
}
void
gst_gl_sync_meta_wait_cpu (GstGLSyncMeta * sync_meta, GstGLContext * context)
{
if (sync_meta->wait_cpu)
sync_meta->wait_cpu (sync_meta, context);
else
gst_gl_context_thread_add (context,
(GstGLContextThreadFunc) _wait_cpu, sync_meta);
}
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
static gboolean
_gst_gl_sync_meta_transform (GstBuffer * dest, GstMeta * meta,
GstBuffer * buffer, GQuark type, gpointer data)
{
GstGLSyncMeta *dmeta, *smeta;
smeta = (GstGLSyncMeta *) meta;
if (GST_META_TRANSFORM_IS_COPY (type)) {
GstMetaTransformCopy *copy = data;
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
g_assert (smeta->copy != NULL);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
if (!copy->region) {
/* only copy if the complete data is copied as well */
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
dmeta = gst_buffer_add_gl_sync_meta_full (smeta->context, dest, NULL);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
if (!dmeta)
return FALSE;
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
dmeta->set_sync = smeta->set_sync;
dmeta->set_sync_gl = smeta->set_sync_gl;
dmeta->wait = smeta->wait;
dmeta->wait_gl = smeta->wait_gl;
glsyncmeta: separate out gpu/cpu waits. CPU waits are more expensive and are only required if the CPU is ever going to access the data. GPU waits perform inter-context synchronisation and are cheaper as they don't require CPU intervention.
2016-02-09 01:14:04 +00:00
dmeta->wait_cpu = smeta->wait_cpu;
dmeta->wait_cpu_gl = smeta->wait_cpu_gl;
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
dmeta->copy = smeta->copy;
dmeta->free = smeta->free;
dmeta->free_gl = smeta->free_gl;
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
GST_LOG ("copying sync meta %p into %p", smeta, dmeta);
smeta->copy (smeta, buffer, dmeta, dest);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
}
glsyncmeta: transform func: return FALSE if not supported or failed https://bugzilla.gnome.org/show_bug.cgi?id=751778
2015-07-07 01:57:26 +00:00
} else {
/* return FALSE, if transform type is not supported */
return FALSE;
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
}
glsyncmeta: transform func: return FALSE if not supported or failed https://bugzilla.gnome.org/show_bug.cgi?id=751778
2015-07-07 01:57:26 +00:00
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
return TRUE;
}
static void
_free_gl_sync_meta (GstGLContext * context, GstGLSyncMeta * sync_meta)
{
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
g_assert (sync_meta->free_gl != NULL);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
GST_LOG ("free sync meta %p", sync_meta);
sync_meta->free_gl (sync_meta, context);
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
}
static void
_gst_gl_sync_meta_free (GstGLSyncMeta * sync_meta, GstBuffer * buffer)
{
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
if (sync_meta->free)
sync_meta->free (sync_meta, sync_meta->context);
else
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
gst_gl_context_thread_add (sync_meta->context,
(GstGLContextThreadFunc) _free_gl_sync_meta, sync_meta);
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
gst_object_unref (sync_meta->context);
}
static gboolean
_gst_gl_sync_meta_init (GstGLSyncMeta * sync_meta, gpointer params,
GstBuffer * buffer)
{
static volatile gsize _init;
if (g_once_init_enter (&_init)) {
GST_DEBUG_CATEGORY_INIT (gst_gl_sync_meta_debug, "glsyncmeta", 0,
"glsyncmeta");
g_once_init_leave (&_init, 1);
}
sync_meta->context = NULL;
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
sync_meta->data = NULL;
sync_meta->set_sync = NULL;
sync_meta->set_sync_gl = NULL;
sync_meta->wait = NULL;
sync_meta->wait_gl = NULL;
glsyncmeta: separate out gpu/cpu waits. CPU waits are more expensive and are only required if the CPU is ever going to access the data. GPU waits perform inter-context synchronisation and are cheaper as they don't require CPU intervention.
2016-02-09 01:14:04 +00:00
sync_meta->wait_cpu = NULL;
sync_meta->wait_cpu_gl = NULL;
glsyncmeta: add vfuncs for all operations there could be other ways/requirements for synchronising two GPU command streams (whether GL or platform specific). e.g. glfencesync/eglwaitnative/cond/etc
2015-11-02 06:57:29 +00:00
sync_meta->copy = NULL;
sync_meta->free = NULL;
sync_meta->free_gl = NULL;
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
return TRUE;
}
GType
gst_gl_sync_meta_api_get_type (void)
{
static volatile GType type = 0;
static const gchar *tags[] = { NULL };
if (g_once_init_enter (&type)) {
GType _type = gst_meta_api_type_register ("GstGLSyncMetaAPI", tags);
g_once_init_leave (&type, _type);
}
return type;
}
const GstMetaInfo *
gst_gl_sync_meta_get_info (void)
{
static const GstMetaInfo *meta_info = NULL;
if (g_once_init_enter (&meta_info)) {
const GstMetaInfo *meta =
gst_meta_register (GST_GL_SYNC_META_API_TYPE, "GstGLSyncMeta",
glsyncmeta: fixup size declaration
2015-05-05 04:44:25 +00:00
sizeof (GstGLSyncMeta), (GstMetaInitFunction) _gst_gl_sync_meta_init,
gl: add a sync meta for synchronizing across GL contexts A context can create a GLsync object that can be waited on in order to ensure that GL resources created in one context are able to be used in another shared context without any chance of reading invalid data. This meta would be placed on buffers that are known to cross from one context to another. The receiving element would then wait on the sync object to ensure that the data to be used is complete.
2014-10-17 13:22:24 +00:00
(GstMetaFreeFunction) _gst_gl_sync_meta_free,
_gst_gl_sync_meta_transform);
g_once_init_leave (&meta_info, meta);
}
return meta_info;
}
Reference in a new issue Copy permalink