gst-libs/gst/gl/gstglmemorydma.c - mtk-gst-plugins-base - Git at Google

 /*
  * # Copyright 2020 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

 #include <gst/allocators/gstdmabuf.h>
 #include <gst/gl/gstglfuncs.h>

 #include "gstglmemorydma.h"

 GST_DEBUG_CATEGORY_STATIC (GST_CAT_GL_MEMORY_DMA);
 #define GST_CAT_DEFAULT GST_CAT_GL_MEMORY_DMA

 #define parent_class gst_gl_memory_dma_allocator_parent_class
 G_DEFINE_TYPE (GstGLMemoryDmaAllocator, gst_gl_memory_dma_allocator,
     GST_TYPE_GL_MEMORY_ALLOCATOR);

 static void gst_gl_memory_dma_allocator_finalize (GObject * object);
 static GstGLBaseMemory *  _gl_mem_dma_alloc
     (GstGLBaseMemoryAllocator * allocator, GstGLAllocationParams * params);
 static gboolean _gl_mem_dma_create (GstGLBaseMemory * glmem, GError ** error);
 static void _gl_mem_dma_destroy (GstGLBaseMemory * glmem);
 static GstMemory * _mem_alloc (GstAllocator * allocator, gsize size,
     GstAllocationParams * params);


 static void
 gst_gl_memory_dma_allocator_class_init (GstGLMemoryDmaAllocatorClass * klass)
 {
   GST_ALLOCATOR_CLASS (klass)->alloc = _mem_alloc;

   GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (klass)->alloc = _gl_mem_dma_alloc;
   GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (klass)->create = _gl_mem_dma_create;
   GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (klass)->destroy = _gl_mem_dma_destroy;

   G_OBJECT_CLASS (klass)->finalize = gst_gl_memory_dma_allocator_finalize;

   GST_DEBUG_CATEGORY_INIT (GST_CAT_GL_MEMORY_DMA, "glmemorydma", 0,
     "OpenGL DMA memory");
 }

 static void
 gst_gl_memory_dma_allocator_init (GstGLMemoryDmaAllocator * alloc)
 {
   GST_DEBUG_OBJECT (alloc, "init");
   GST_ALLOCATOR (alloc)->mem_type = GST_GL_MEMORY_DMA_ALLOCATOR_NAME;
   GST_OBJECT_FLAG_SET (GST_OBJECT (alloc), GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);

   /* ION allocator is in the "coral" plugin, load it. */
   alloc->plugin = gst_plugin_load_by_name ("coral");
   if (!alloc->plugin) {
     GST_ERROR_OBJECT (alloc, "coral plugin not found");
     return;
   }

   alloc->ion_allocator = gst_allocator_find ("ion");
   if (!alloc->ion_allocator) {
     GST_ERROR_OBJECT (alloc, "ION allocator not found");
     return;
   }

   GST_INFO_OBJECT (alloc, "ION allocator loaded");
 }

 static void
 gst_gl_memory_dma_allocator_finalize (GObject * object)
 {
   GstGLMemoryDmaAllocator *alloc = GST_GL_MEMORY_DMA_ALLOCATOR (object);

   GST_DEBUG_OBJECT (alloc, "finalize");

   if (alloc->ion_allocator) {
     gst_object_unref (alloc->ion_allocator);
     alloc->ion_allocator = NULL;
   }

   if (alloc->plugin) {
     gst_object_unref (alloc->plugin);
     alloc->plugin = NULL;
   }

   G_OBJECT_CLASS (parent_class)->finalize (object);
 }

 static GstGLBaseMemory *
  _gl_mem_dma_alloc (GstGLBaseMemoryAllocator * allocator,
     GstGLAllocationParams * alloc_params)
 {
   GstGLMemoryDmaAllocator *alloc;
   GstGLMemoryDMA *dmamem;
   GstGLVideoAllocationParams *params;
   gsize size;

   alloc = GST_GL_MEMORY_DMA_ALLOCATOR (allocator);
   params = (GstGLVideoAllocationParams *) alloc_params;

   g_return_val_if_fail (params->parent.alloc_flags &
       GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_VIDEO, NULL);

   dmamem = g_new0 (GstGLMemoryDMA, 1);
   dmamem->params = params->parent.alloc_params;

   /* GstVideoInfo defaults to 4 b stride align for RGB/BGR but we want to
    * pack the buffer as tightly as possible (i.e. stride == width * bpp).
    */
   switch (params->v_info->finfo->format) {
     case GST_VIDEO_FORMAT_RGB:
     case GST_VIDEO_FORMAT_BGR:
       params->v_info->stride[0] = params->v_info->width * 3;
       params->v_info->size = params->v_info->stride[0] * params->v_info->height;
       break;
     default:
       break;
   }

   size = gst_gl_get_plane_data_size (params->v_info, params->valign,
       params->plane);
   dmamem->dma = gst_allocator_alloc (alloc->ion_allocator, size,
       dmamem->params);

   if (!dmamem->dma) {
     GST_CAT_ERROR (GST_CAT_GL_MEMORY_DMA, "ION alloc of %zu b failed", size);
     g_free (dmamem);
     return NULL;
   }

   GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "ION alloc %zu b", size);

   gst_gl_memory_init (GST_GL_MEMORY_CAST (dmamem), GST_ALLOCATOR_CAST (alloc),
       NULL, params->parent.context, params->target, params->tex_format,
       params->parent.alloc_params, params->v_info, params->plane,
       params->valign, params->parent.user_data, params->parent.notify);

   return GST_GL_BASE_MEMORY_CAST (dmamem);
 }

 static gboolean
 _gl_mem_dma_create (GstGLBaseMemory * glmem, GError ** error)
 {
   GstGLMemoryDMA *dmamem;
   const GstGLFuncs *gl;
   gint fd;
   guint tex_id;

   g_return_val_if_fail (glmem, FALSE);
   g_return_val_if_fail (glmem->context, FALSE);
   gl = glmem->context->gl_vtable;

   if (!GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (parent_class)->create (glmem,
       error)) {
     return FALSE;
   }

   dmamem = GST_GL_MEMORY_DMA_CAST (glmem);
   fd = gst_dmabuf_memory_get_fd (dmamem->dma);
   tex_id = GST_GL_MEMORY_CAST (&glmem->mem)->tex_id;

   dmamem->image = gst_egl_image_from_dmabuf (glmem->context, fd,
       &GST_GL_MEMORY_CAST (glmem)->info, 0, 0);
   if (!dmamem->image) {
     GST_CAT_ERROR (GST_CAT_GL_MEMORY_DMA, "gst_egl_image_from_dmabuf failed");
     return FALSE;
   }

   gl->ActiveTexture (GL_TEXTURE0);
   gl->BindTexture (GL_TEXTURE_2D, tex_id);
   gl->EGLImageTargetTexture2D (GL_TEXTURE_2D, gst_egl_image_get_image (
       dmamem->image));

   GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "created dma mem %p fd %d tex_id %u",
       glmem, fd, tex_id);

   return TRUE;
 }

 static void
 _gl_mem_dma_destroy (GstGLBaseMemory * glmem)
 {
   GstGLMemoryDMA *dmamem;

   GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (parent_class)->destroy (glmem);

   dmamem = GST_GL_MEMORY_DMA_CAST (glmem);

   if (dmamem->image) {
     gst_egl_image_unref (dmamem->image);
     dmamem->image = NULL;
   }

   if (dmamem->dma) {
     gst_memory_unref (dmamem->dma);
     dmamem->dma = NULL;
   }

   /* Base class frees dmamem. */
   GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (parent_class)->destroy (glmem);
   GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "destroyed dma mem %p", dmamem);
 }

 static GstMemory *
 _mem_alloc (GstAllocator * allocator, gsize size,
     GstAllocationParams * params)
 {
   /* Only used as an init check, does not support actual GL alloc. */

   GstGLMemoryDmaAllocator *alloc;

   alloc = GST_GL_MEMORY_DMA_ALLOCATOR (allocator);

   g_return_val_if_fail (alloc->ion_allocator, NULL);

   return gst_allocator_alloc (alloc->ion_allocator, size, params);
 }

 static EGLDisplay
 _get_egl_display (GstGLContext * context)
 {
   EGLDisplay egl_display;
   GstGLDisplayEGL *display_egl;
   if (!context->display) {
     return EGL_NO_DISPLAY;
   }
   display_egl = gst_gl_display_egl_from_gl_display (context->display);
   egl_display =
       (EGLDisplay) gst_gl_display_get_handle (GST_GL_DISPLAY (display_egl));
   gst_object_unref (display_egl);
   return egl_display;
 }

 static EGLSyncKHR
 _eglCreateSyncKHR (GstGLContext * context)
 {
   GstClockTime ts;
   EGLSyncKHR sync;
   EGLSyncKHR (*gst_eglCreateSyncKHR) (EGLDisplay dpy, EGLenum type,
       const EGLAttrib * attrib_list);
   EGLDisplay dpy = _get_egl_display (context);
   g_assert (dpy != EGL_NO_DISPLAY);

   ts = gst_util_get_timestamp ();
   gst_eglCreateSyncKHR = gst_gl_context_get_proc_address (context,
         "eglCreateSyncKHR");
   sync = gst_eglCreateSyncKHR (dpy, EGL_SYNC_FENCE_KHR, NULL);
   GST_CAT_LOG (GST_CAT_GL_MEMORY_DMA, "created egl sync object %p", sync);
   ts = gst_util_get_timestamp () - ts;
   GST_CAT_LOG (GST_CAT_GL_MEMORY_DMA, "create %.2g ms",(double) ts / GST_MSECOND);
   return sync;
 }

 static EGLBoolean
 _eglClientWaitSyncKHR (GstGLContext * context, EGLSyncKHR sync)
 {
   EGLint (*gst_eglClientWaitSyncKHR) (EGLDisplay dpy, EGLSyncKHR sync,
         EGLint flags, EGLTimeKHR timeout);
   EGLDisplay dpy = _get_egl_display (context);
   g_assert (dpy != EGL_NO_DISPLAY);

   GST_CAT_LOG (GST_CAT_GL_MEMORY_DMA, "waiting on egl sync object %p", sync);
   gst_eglClientWaitSyncKHR = gst_gl_context_get_proc_address (context,
         "eglClientWaitSyncKHR");
   return gst_eglClientWaitSyncKHR (dpy, sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
       1000000000 /* 1s */ ) == EGL_CONDITION_SATISFIED_KHR;
 }

 static EGLBoolean
 _eglDestroySyncKHR (GstGLContext * context, EGLSyncKHR sync)
 {
   EGLBoolean (*gst_eglDestroySyncKHR) (EGLDisplay dpy, EGLSyncKHR sync);
   EGLDisplay dpy = _get_egl_display (context);
   if (dpy == EGL_NO_DISPLAY) {
     return EGL_FALSE;
   }

   gst_eglDestroySyncKHR = gst_gl_context_get_proc_address (context,
         "eglDestroySyncKHR");
   GST_CAT_LOG (GST_CAT_GL_MEMORY_DMA, "deleting egl sync object %p", sync);
   return gst_eglDestroySyncKHR (dpy, sync);
 }

 static void
 _create_sync_gl (GstGLContext * context, gpointer data)
 {
   EGLSyncKHR *sync = (EGLSyncKHR *) data;
   *sync = _eglCreateSyncKHR (context);
 }

 GstBuffer *
 gst_gl_memory_dma_sync_buffer (GstBuffer * glbuf)
 {
   GstBuffer *buf;
   GstVideoInfo *info;
   GstMemory *mem;
   GstGLBaseMemory *glmem;
   GstGLMemoryDMA *dmamem;
   GstGLSyncMeta *sync_meta;
   EGLSyncKHR sync;
   EGLBoolean res;
   GstClockTime ts;

   mem = gst_buffer_peek_memory (glbuf, 0);
   g_assert (gst_is_gl_memory_dma (mem));

   glmem = GST_GL_BASE_MEMORY_CAST (mem);
   dmamem = GST_GL_MEMORY_DMA_CAST (mem);
   sync_meta = gst_buffer_get_gl_sync_meta (glbuf);

   if (sync_meta) {
     ts = gst_util_get_timestamp ();
     gst_gl_sync_meta_wait_cpu (sync_meta, glmem->context);
     ts = gst_util_get_timestamp () - ts;
     GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "wait_cpu %.2g ms",
         (double) ts / GST_MSECOND);
   } else {
     ts = gst_util_get_timestamp ();
     gst_gl_context_thread_add (glmem->context, _create_sync_gl, &sync);
     g_assert (sync != EGL_NO_SYNC_KHR);

     do {
       res = _eglClientWaitSyncKHR (glmem->context, sync);
     } while (res == EGL_FALSE);
     ts = gst_util_get_timestamp () - ts;

     res = _eglDestroySyncKHR (glmem->context, sync);
     g_assert (res == EGL_TRUE);
     ts = gst_util_get_timestamp () - ts;
     GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "egl_sync %.2g ms",
         (double) ts / GST_MSECOND);
   }

   info = &dmamem->mem.info;
   buf = gst_buffer_new ();
   gst_buffer_add_parent_buffer_meta (buf, glbuf);
   gst_buffer_append_memory (buf, gst_memory_ref (dmamem->dma));
   gst_buffer_add_video_meta_full (buf, 0,
       GST_VIDEO_INFO_FORMAT (info), GST_VIDEO_INFO_WIDTH (info),
       GST_VIDEO_INFO_HEIGHT (info), 1, info->offset, info->stride);

   return buf;
 }

 gboolean
 gst_is_gl_memory_dma (GstMemory * mem)
 {
   return mem && mem->allocator && g_type_is_a (G_OBJECT_TYPE (mem->allocator),
       GST_TYPE_GL_MEMORY_DMA_ALLOCATOR);
 }

 void
 gst_gl_memory_dma_init_once (void)
 {
   static volatile gsize _init = 0;

   if (g_once_init_enter (&_init)) {
     GstAllocator *alloc = g_object_new (GST_TYPE_GL_MEMORY_DMA_ALLOCATOR, NULL);
     gst_object_ref_sink (alloc);
     gst_allocator_register (GST_GL_MEMORY_DMA_ALLOCATOR_NAME, alloc);
     g_once_init_leave (&_init, 1);
   }
 }
	/*
	* # Copyright 2020 Google LLC
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* https://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include <gst/allocators/gstdmabuf.h>
	#include <gst/gl/gstglfuncs.h>

	#include "gstglmemorydma.h"

	GST_DEBUG_CATEGORY_STATIC (GST_CAT_GL_MEMORY_DMA);
	#define GST_CAT_DEFAULT GST_CAT_GL_MEMORY_DMA

	#define parent_class gst_gl_memory_dma_allocator_parent_class
	G_DEFINE_TYPE (GstGLMemoryDmaAllocator, gst_gl_memory_dma_allocator,
	GST_TYPE_GL_MEMORY_ALLOCATOR);

	static void gst_gl_memory_dma_allocator_finalize (GObject * object);
	static GstGLBaseMemory * _gl_mem_dma_alloc
	(GstGLBaseMemoryAllocator * allocator, GstGLAllocationParams * params);
	static gboolean _gl_mem_dma_create (GstGLBaseMemory * glmem, GError ** error);
	static void _gl_mem_dma_destroy (GstGLBaseMemory * glmem);
	static GstMemory * _mem_alloc (GstAllocator * allocator, gsize size,
	GstAllocationParams * params);


	static void
	gst_gl_memory_dma_allocator_class_init (GstGLMemoryDmaAllocatorClass * klass)
	{
	GST_ALLOCATOR_CLASS (klass)->alloc = _mem_alloc;

	GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (klass)->alloc = _gl_mem_dma_alloc;
	GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (klass)->create = _gl_mem_dma_create;
	GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (klass)->destroy = _gl_mem_dma_destroy;

	G_OBJECT_CLASS (klass)->finalize = gst_gl_memory_dma_allocator_finalize;

	GST_DEBUG_CATEGORY_INIT (GST_CAT_GL_MEMORY_DMA, "glmemorydma", 0,
	"OpenGL DMA memory");
	}

	static void
	gst_gl_memory_dma_allocator_init (GstGLMemoryDmaAllocator * alloc)
	{
	GST_DEBUG_OBJECT (alloc, "init");
	GST_ALLOCATOR (alloc)->mem_type = GST_GL_MEMORY_DMA_ALLOCATOR_NAME;
	GST_OBJECT_FLAG_SET (GST_OBJECT (alloc), GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);

	/* ION allocator is in the "coral" plugin, load it. */
	alloc->plugin = gst_plugin_load_by_name ("coral");
	if (!alloc->plugin) {
	GST_ERROR_OBJECT (alloc, "coral plugin not found");
	return;
	}

	alloc->ion_allocator = gst_allocator_find ("ion");
	if (!alloc->ion_allocator) {
	GST_ERROR_OBJECT (alloc, "ION allocator not found");
	return;
	}

	GST_INFO_OBJECT (alloc, "ION allocator loaded");
	}

	static void
	gst_gl_memory_dma_allocator_finalize (GObject * object)
	{
	GstGLMemoryDmaAllocator *alloc = GST_GL_MEMORY_DMA_ALLOCATOR (object);

	GST_DEBUG_OBJECT (alloc, "finalize");

	if (alloc->ion_allocator) {
	gst_object_unref (alloc->ion_allocator);
	alloc->ion_allocator = NULL;
	}

	if (alloc->plugin) {
	gst_object_unref (alloc->plugin);
	alloc->plugin = NULL;
	}

	G_OBJECT_CLASS (parent_class)->finalize (object);
	}

	static GstGLBaseMemory *
	_gl_mem_dma_alloc (GstGLBaseMemoryAllocator * allocator,
	GstGLAllocationParams * alloc_params)
	{
	GstGLMemoryDmaAllocator *alloc;
	GstGLMemoryDMA *dmamem;
	GstGLVideoAllocationParams *params;
	gsize size;

	alloc = GST_GL_MEMORY_DMA_ALLOCATOR (allocator);
	params = (GstGLVideoAllocationParams *) alloc_params;

	g_return_val_if_fail (params->parent.alloc_flags &
	GST_GL_ALLOCATION_PARAMS_ALLOC_FLAG_VIDEO, NULL);

	dmamem = g_new0 (GstGLMemoryDMA, 1);
	dmamem->params = params->parent.alloc_params;

	/* GstVideoInfo defaults to 4 b stride align for RGB/BGR but we want to
	* pack the buffer as tightly as possible (i.e. stride == width * bpp).
	*/
	switch (params->v_info->finfo->format) {
	case GST_VIDEO_FORMAT_RGB:
	case GST_VIDEO_FORMAT_BGR:
	params->v_info->stride[0] = params->v_info->width * 3;
	params->v_info->size = params->v_info->stride[0] * params->v_info->height;
	break;
	default:
	break;
	}

	size = gst_gl_get_plane_data_size (params->v_info, params->valign,
	params->plane);
	dmamem->dma = gst_allocator_alloc (alloc->ion_allocator, size,
	dmamem->params);

	if (!dmamem->dma) {
	GST_CAT_ERROR (GST_CAT_GL_MEMORY_DMA, "ION alloc of %zu b failed", size);
	g_free (dmamem);
	return NULL;
	}

	GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "ION alloc %zu b", size);

	gst_gl_memory_init (GST_GL_MEMORY_CAST (dmamem), GST_ALLOCATOR_CAST (alloc),
	NULL, params->parent.context, params->target, params->tex_format,
	params->parent.alloc_params, params->v_info, params->plane,
	params->valign, params->parent.user_data, params->parent.notify);

	return GST_GL_BASE_MEMORY_CAST (dmamem);
	}

	static gboolean
	_gl_mem_dma_create (GstGLBaseMemory * glmem, GError ** error)
	{
	GstGLMemoryDMA *dmamem;
	const GstGLFuncs *gl;
	gint fd;
	guint tex_id;

	g_return_val_if_fail (glmem, FALSE);
	g_return_val_if_fail (glmem->context, FALSE);
	gl = glmem->context->gl_vtable;

	if (!GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (parent_class)->create (glmem,
	error)) {
	return FALSE;
	}

	dmamem = GST_GL_MEMORY_DMA_CAST (glmem);
	fd = gst_dmabuf_memory_get_fd (dmamem->dma);
	tex_id = GST_GL_MEMORY_CAST (&glmem->mem)->tex_id;

	dmamem->image = gst_egl_image_from_dmabuf (glmem->context, fd,
	&GST_GL_MEMORY_CAST (glmem)->info, 0, 0);
	if (!dmamem->image) {
	GST_CAT_ERROR (GST_CAT_GL_MEMORY_DMA, "gst_egl_image_from_dmabuf failed");
	return FALSE;
	}

	gl->ActiveTexture (GL_TEXTURE0);
	gl->BindTexture (GL_TEXTURE_2D, tex_id);
	gl->EGLImageTargetTexture2D (GL_TEXTURE_2D, gst_egl_image_get_image (
	dmamem->image));

	GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "created dma mem %p fd %d tex_id %u",
	glmem, fd, tex_id);

	return TRUE;
	}

	static void
	_gl_mem_dma_destroy (GstGLBaseMemory * glmem)
	{
	GstGLMemoryDMA *dmamem;

	GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (parent_class)->destroy (glmem);

	dmamem = GST_GL_MEMORY_DMA_CAST (glmem);

	if (dmamem->image) {
	gst_egl_image_unref (dmamem->image);
	dmamem->image = NULL;
	}

	if (dmamem->dma) {
	gst_memory_unref (dmamem->dma);
	dmamem->dma = NULL;
	}

	/* Base class frees dmamem. */
	GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (parent_class)->destroy (glmem);
	GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "destroyed dma mem %p", dmamem);
	}

	static GstMemory *
	_mem_alloc (GstAllocator * allocator, gsize size,
	GstAllocationParams * params)
	{
	/* Only used as an init check, does not support actual GL alloc. */

	GstGLMemoryDmaAllocator *alloc;

	alloc = GST_GL_MEMORY_DMA_ALLOCATOR (allocator);

	g_return_val_if_fail (alloc->ion_allocator, NULL);

	return gst_allocator_alloc (alloc->ion_allocator, size, params);
	}

	static EGLDisplay
	_get_egl_display (GstGLContext * context)
	{
	EGLDisplay egl_display;
	GstGLDisplayEGL *display_egl;
	if (!context->display) {
	return EGL_NO_DISPLAY;
	}
	display_egl = gst_gl_display_egl_from_gl_display (context->display);
	egl_display =
	(EGLDisplay) gst_gl_display_get_handle (GST_GL_DISPLAY (display_egl));
	gst_object_unref (display_egl);
	return egl_display;
	}

	static EGLSyncKHR
	_eglCreateSyncKHR (GstGLContext * context)
	{
	GstClockTime ts;
	EGLSyncKHR sync;
	EGLSyncKHR (*gst_eglCreateSyncKHR) (EGLDisplay dpy, EGLenum type,
	const EGLAttrib * attrib_list);
	EGLDisplay dpy = _get_egl_display (context);
	g_assert (dpy != EGL_NO_DISPLAY);

	ts = gst_util_get_timestamp ();
	gst_eglCreateSyncKHR = gst_gl_context_get_proc_address (context,
	"eglCreateSyncKHR");
	sync = gst_eglCreateSyncKHR (dpy, EGL_SYNC_FENCE_KHR, NULL);
	GST_CAT_LOG (GST_CAT_GL_MEMORY_DMA, "created egl sync object %p", sync);
	ts = gst_util_get_timestamp () - ts;
	GST_CAT_LOG (GST_CAT_GL_MEMORY_DMA, "create %.2g ms",(double) ts / GST_MSECOND);
	return sync;
	}

	static EGLBoolean
	_eglClientWaitSyncKHR (GstGLContext * context, EGLSyncKHR sync)
	{
	EGLint (*gst_eglClientWaitSyncKHR) (EGLDisplay dpy, EGLSyncKHR sync,
	EGLint flags, EGLTimeKHR timeout);
	EGLDisplay dpy = _get_egl_display (context);
	g_assert (dpy != EGL_NO_DISPLAY);

	GST_CAT_LOG (GST_CAT_GL_MEMORY_DMA, "waiting on egl sync object %p", sync);
	gst_eglClientWaitSyncKHR = gst_gl_context_get_proc_address (context,
	"eglClientWaitSyncKHR");
	return gst_eglClientWaitSyncKHR (dpy, sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
	1000000000 /* 1s */ ) == EGL_CONDITION_SATISFIED_KHR;
	}

	static EGLBoolean
	_eglDestroySyncKHR (GstGLContext * context, EGLSyncKHR sync)
	{
	EGLBoolean (*gst_eglDestroySyncKHR) (EGLDisplay dpy, EGLSyncKHR sync);
	EGLDisplay dpy = _get_egl_display (context);
	if (dpy == EGL_NO_DISPLAY) {
	return EGL_FALSE;
	}

	gst_eglDestroySyncKHR = gst_gl_context_get_proc_address (context,
	"eglDestroySyncKHR");
	GST_CAT_LOG (GST_CAT_GL_MEMORY_DMA, "deleting egl sync object %p", sync);
	return gst_eglDestroySyncKHR (dpy, sync);
	}

	static void
	_create_sync_gl (GstGLContext * context, gpointer data)
	{
	EGLSyncKHR sync = (EGLSyncKHR ) data;
	*sync = _eglCreateSyncKHR (context);
	}

	GstBuffer *
	gst_gl_memory_dma_sync_buffer (GstBuffer * glbuf)
	{
	GstBuffer *buf;
	GstVideoInfo *info;
	GstMemory *mem;
	GstGLBaseMemory *glmem;
	GstGLMemoryDMA *dmamem;
	GstGLSyncMeta *sync_meta;
	EGLSyncKHR sync;
	EGLBoolean res;
	GstClockTime ts;

	mem = gst_buffer_peek_memory (glbuf, 0);
	g_assert (gst_is_gl_memory_dma (mem));

	glmem = GST_GL_BASE_MEMORY_CAST (mem);
	dmamem = GST_GL_MEMORY_DMA_CAST (mem);
	sync_meta = gst_buffer_get_gl_sync_meta (glbuf);

	if (sync_meta) {
	ts = gst_util_get_timestamp ();
	gst_gl_sync_meta_wait_cpu (sync_meta, glmem->context);
	ts = gst_util_get_timestamp () - ts;
	GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "wait_cpu %.2g ms",
	(double) ts / GST_MSECOND);
	} else {
	ts = gst_util_get_timestamp ();
	gst_gl_context_thread_add (glmem->context, _create_sync_gl, &sync);
	g_assert (sync != EGL_NO_SYNC_KHR);

	do {
	res = _eglClientWaitSyncKHR (glmem->context, sync);
	} while (res == EGL_FALSE);
	ts = gst_util_get_timestamp () - ts;

	res = _eglDestroySyncKHR (glmem->context, sync);
	g_assert (res == EGL_TRUE);
	ts = gst_util_get_timestamp () - ts;
	GST_CAT_DEBUG (GST_CAT_GL_MEMORY_DMA, "egl_sync %.2g ms",
	(double) ts / GST_MSECOND);
	}

	info = &dmamem->mem.info;
	buf = gst_buffer_new ();
	gst_buffer_add_parent_buffer_meta (buf, glbuf);
	gst_buffer_append_memory (buf, gst_memory_ref (dmamem->dma));
	gst_buffer_add_video_meta_full (buf, 0,
	GST_VIDEO_INFO_FORMAT (info), GST_VIDEO_INFO_WIDTH (info),
	GST_VIDEO_INFO_HEIGHT (info), 1, info->offset, info->stride);

	return buf;
	}

	gboolean
	gst_is_gl_memory_dma (GstMemory * mem)
	{
	return mem && mem->allocator && g_type_is_a (G_OBJECT_TYPE (mem->allocator),
	GST_TYPE_GL_MEMORY_DMA_ALLOCATOR);
	}

	void
	gst_gl_memory_dma_init_once (void)
	{
	static volatile gsize _init = 0;

	if (g_once_init_enter (&_init)) {
	GstAllocator *alloc = g_object_new (GST_TYPE_GL_MEMORY_DMA_ALLOCATOR, NULL);
	gst_object_ref_sink (alloc);
	gst_allocator_register (GST_GL_MEMORY_DMA_ALLOCATOR_NAME, alloc);
	g_once_init_leave (&_init, 1);
	}
	}