bsdrm/src/egl.c - chromiumos/platform/drm-tests - Git at Google

 /*
  * Copyright 2016 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "bs_drm.h"

 static const char *get_egl_error();
 static const char *get_gl_framebuffer_error();

 struct bs_egl {
 	bool setup;
 	EGLDisplay display;
 	EGLContext ctx;
 	bool use_image_flush_external;
 	bool use_dma_buf_import_modifiers;

 	// Names are the original gl/egl function names with the prefix chopped off.
 	PFNEGLCREATEIMAGEKHRPROC CreateImageKHR;
 	PFNEGLDESTROYIMAGEKHRPROC DestroyImageKHR;
 	PFNEGLIMAGEFLUSHEXTERNALEXTPROC ImageFlushExternal;
 	PFNGLEGLIMAGETARGETTEXTURE2DOESPROC EGLImageTargetTexture2DOES;
 };

 struct bs_egl_fb {
 	GLuint tex;
 	GLuint fb;
 };

 struct bs_egl *bs_egl_new()
 {
 	struct bs_egl *self = calloc(1, sizeof(struct bs_egl));
 	assert(self);
 	self->display = EGL_NO_DISPLAY;
 	self->ctx = EGL_NO_CONTEXT;
 	return self;
 }

 void bs_egl_destroy(struct bs_egl **egl)
 {
 	assert(egl);
 	struct bs_egl *self = *egl;
 	assert(self);

 	if (self->ctx != EGL_NO_CONTEXT) {
 		assert(self->display != EGL_NO_DISPLAY);
 		eglMakeCurrent(self->display, NULL, NULL, NULL);
 		eglDestroyContext(self->display, self->ctx);
 	}

 	if (self->display != EGL_NO_DISPLAY)
 		eglTerminate(self->display);

 	free(self);
 	*egl = NULL;
 }

 bool bs_egl_setup(struct bs_egl *self)
 {
 	assert(self);
 	assert(!self->setup);

 	self->CreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)eglGetProcAddress("eglCreateImageKHR");
 	self->DestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)eglGetProcAddress("eglDestroyImageKHR");
 	self->ImageFlushExternal =
 	    (PFNEGLIMAGEFLUSHEXTERNALEXTPROC)eglGetProcAddress("eglImageFlushExternalEXT");
 	self->EGLImageTargetTexture2DOES =
 	    (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)eglGetProcAddress("glEGLImageTargetTexture2DOES");
 	if (!self->CreateImageKHR || !self->DestroyImageKHR || !self->EGLImageTargetTexture2DOES) {
 		bs_debug_error(
 		    "eglGetProcAddress returned NULL for a required extension entry point.");
 		return false;
 	}

 	self->display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 	if (self->display == EGL_NO_DISPLAY) {
 		bs_debug_error("failed to get egl display");
 		return false;
 	}

 	if (!eglInitialize(self->display, NULL /* ignore version */, NULL /* ignore version */)) {
 		bs_debug_error("failed to initialize egl: %s\n", get_egl_error());
 		return false;
 	}

 	// Get any EGLConfig. We need one to create a context, but it isn't used to create any
 	// surfaces.
 	const EGLint config_attribs[] = { EGL_SURFACE_TYPE, EGL_DONT_CARE, EGL_NONE };
 	EGLConfig egl_config;
 	EGLint num_configs;
 	if (!eglChooseConfig(self->display, config_attribs, &egl_config, 1,
 			     &num_configs /* unused but can't be null */)) {
 		bs_debug_error("eglChooseConfig() failed with error: %s", get_egl_error());
 		goto terminate_display;
 	}

 	if (!eglBindAPI(EGL_OPENGL_ES_API)) {
 		bs_debug_error("failed to bind OpenGL ES: %s", get_egl_error());
 		goto terminate_display;
 	}

 	const EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };

 	self->ctx = eglCreateContext(self->display, egl_config,
 				     EGL_NO_CONTEXT /* no shared context */, context_attribs);
 	if (self->ctx == EGL_NO_CONTEXT) {
 		bs_debug_error("failed to create OpenGL ES Context: %s", get_egl_error());
 		goto terminate_display;
 	}

 	if (!eglMakeCurrent(self->display, EGL_NO_SURFACE /* no default draw surface */,
 			    EGL_NO_SURFACE /* no default draw read */, self->ctx)) {
 		bs_debug_error("failed to make the OpenGL ES Context current: %s", get_egl_error());
 		goto destroy_context;
 	}

 	const char *egl_extensions = eglQueryString(self->display, EGL_EXTENSIONS);
 	if (!bs_egl_has_extension("EGL_KHR_image_base", egl_extensions)) {
 		bs_debug_error("EGL_KHR_image_base extension not supported");
 		goto destroy_context;
 	}
 	if (!bs_egl_has_extension("EGL_EXT_image_dma_buf_import", egl_extensions)) {
 		bs_debug_error("EGL_EXT_image_dma_buf_import extension not supported");
 		goto destroy_context;
 	}
 	if (bs_egl_has_extension("EGL_EXT_image_flush_external", egl_extensions)) {
 		if (!self->ImageFlushExternal) {
 			bs_debug_print("WARNING", __func__, __FILE__, __LINE__,
 				       "EGL_EXT_image_flush_external extension is supported, but "
 				       "eglGetProcAddress returned NULL.");
 		} else {
 			self->use_image_flush_external = true;
 		}
 	}
 	if (bs_egl_has_extension("EGL_EXT_image_dma_buf_import_modifiers", egl_extensions))
 		self->use_dma_buf_import_modifiers = true;

 	const char *gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
 	if (!bs_egl_has_extension("GL_OES_EGL_image", gl_extensions)) {
 		bs_debug_error("GL_OES_EGL_image extension not supported");
 		goto destroy_context;
 	}

 	self->setup = true;

 	return true;

 destroy_context:
 	eglDestroyContext(self->display, self->ctx);
 terminate_display:
 	eglTerminate(self->display);
 	self->display = EGL_NO_DISPLAY;
 	return false;
 }

 bool bs_egl_make_current(struct bs_egl *self)
 {
 	assert(self);
 	assert(self->display != EGL_NO_DISPLAY);
 	assert(self->ctx != EGL_NO_CONTEXT);
 	return eglMakeCurrent(self->display, EGL_NO_SURFACE /* No default draw surface */,
 			      EGL_NO_SURFACE /* No default draw read */, self->ctx);
 }

 static EGLImageKHR _bs_egl_image_create(struct bs_egl *self, int prime_fd, int width, int height,
 					uint32_t format, int pitch, int offset,
 					uint64_t *format_modifier)
 {
 	assert(self);
 	assert(self->CreateImageKHR);
 	assert(self->display != EGL_NO_DISPLAY);
 	EGLint khr_image_attrs[17] = { EGL_DMA_BUF_PLANE0_FD_EXT,
 				       prime_fd,
 				       EGL_WIDTH,
 				       width,
 				       EGL_HEIGHT,
 				       height,
 				       EGL_LINUX_DRM_FOURCC_EXT,
 				       (int)format,
 				       EGL_DMA_BUF_PLANE0_PITCH_EXT,
 				       pitch,
 				       EGL_DMA_BUF_PLANE0_OFFSET_EXT,
 				       offset,
 				       EGL_NONE };

 	if (self->use_dma_buf_import_modifiers) {
 		assert(format_modifier);
 		uint64_t modifier = format_modifier ? *format_modifier : 0;
 		khr_image_attrs[12] = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT;
 		khr_image_attrs[13] = modifier & 0xfffffffful;
 		khr_image_attrs[14] = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT;
 		khr_image_attrs[15] = modifier >> 32;
 		khr_image_attrs[16] = EGL_NONE;
 	}

 	EGLImageKHR image =
 	    self->CreateImageKHR(self->display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT,
 				 NULL /* no client buffer */, khr_image_attrs);

 	if (image == EGL_NO_IMAGE_KHR) {
 		bs_debug_error("failed to make image from target buffer: %s", get_egl_error());
 		return EGL_NO_IMAGE_KHR;
 	}

 	return image;
 }

 EGLImageKHR bs_egl_image_create(struct bs_egl *self, int prime_fd, int width, int height,
 				uint32_t format, int pitch, int offset)
 {
 	return _bs_egl_image_create(self, prime_fd, width, height, format, pitch, offset, NULL);
 }

 EGLImageKHR bs_egl_image_create_with_modifier(struct bs_egl *self, int prime_fd, int width,
 					      int height, uint32_t format, int pitch, int offset,
 					      uint64_t format_modifier)
 {
 	return _bs_egl_image_create(self, prime_fd, width, height, format, pitch, offset,
 				    &format_modifier);
 }

 EGLImageKHR bs_egl_image_create_gbm(struct bs_egl *self, struct gbm_bo *bo)
 {
 	assert(bo);
 	int fd = gbm_bo_get_fd(bo);
 	if (fd < 0) {
 		bs_debug_error("failed to get fb for bo: %d", fd);
 		return EGL_NO_IMAGE_KHR;
 	}
 	uint64_t modifier = self->use_dma_buf_import_modifiers ? gbm_bo_get_format_modifier(bo) : 0;
 	return bs_egl_image_create_with_modifier(
 	    self, fd, gbm_bo_get_width(bo), gbm_bo_get_height(bo), gbm_bo_get_format(bo),
 	    gbm_bo_get_stride(bo), 0 /* no offset */, modifier);
 }

 void bs_egl_image_destroy(struct bs_egl *self, EGLImageKHR *image)
 {
 	assert(self);
 	assert(image);
 	assert(*image != EGL_NO_IMAGE_KHR);
 	assert(self->DestroyImageKHR);
 	self->DestroyImageKHR(self->display, *image);
 	*image = EGL_NO_IMAGE_KHR;
 }

 bool bs_egl_image_flush_external(struct bs_egl *self, EGLImageKHR image)
 {
 	assert(self);
 	assert(image != EGL_NO_IMAGE_KHR);
 	if (!self->use_image_flush_external)
 		return true;
 	const EGLAttrib attrs[] = { EGL_NONE };
 	return self->ImageFlushExternal(self->display, image, attrs);
 }

 struct bs_egl_fb *bs_egl_fb_new(struct bs_egl *self, EGLImageKHR image)
 {
 	assert(self);
 	assert(self->EGLImageTargetTexture2DOES);

 	struct bs_egl_fb *fb = calloc(1, sizeof(struct bs_egl_fb));
 	assert(fb);

 	glGenTextures(1, &fb->tex);
 	glBindTexture(GL_TEXTURE_2D, fb->tex);
 	self->EGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
 	glBindTexture(GL_TEXTURE_2D, 0);

 	glGenFramebuffers(1, &fb->fb);
 	glBindFramebuffer(GL_FRAMEBUFFER, fb->fb);
 	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fb->tex, 0);

 	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
 		bs_debug_error("failed framebuffer check for created target buffer: %s",
 			       get_gl_framebuffer_error());
 		glDeleteFramebuffers(1, &fb->fb);
 		glDeleteTextures(1, &fb->tex);
 		free(fb);
 		return NULL;
 	}

 	return fb;
 }

 void bs_egl_fb_destroy(struct bs_egl_fb **fb)
 {
 	assert(fb);
 	struct bs_egl_fb *self = *fb;
 	assert(self);

 	glDeleteFramebuffers(1, &self->fb);
 	glDeleteTextures(1, &self->tex);

 	free(self);
 	*fb = NULL;
 }

 GLuint bs_egl_fb_name(struct bs_egl_fb *self)
 {
 	assert(self);
 	return self->fb;
 }

 bool bs_egl_target_texture2D(struct bs_egl *self, EGLImageKHR image)
 {
 	assert(self);
 	assert(self->EGLImageTargetTexture2DOES);
 	self->EGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
 	GLint error = glGetError();
 	return (error == GL_NO_ERROR);
 }

 bool bs_egl_has_extension(const char *extension, const char *extensions)
 {
 	const char *start, *where, *terminator;
 	start = extensions;
 	for (;;) {
 		where = (char *)strstr((const char *)start, extension);
 		if (!where)
 			break;
 		terminator = where + strlen(extension);
 		if (where == start || *(where - 1) == ' ')
 			if (*terminator == ' ' || *terminator == '\0')
 				return true;
 		start = terminator;
 	}
 	return false;
 }

 static const char *get_egl_error()
 {
 	switch (eglGetError()) {
 		case EGL_SUCCESS:
 			return "EGL_SUCCESS";
 		case EGL_NOT_INITIALIZED:
 			return "EGL_NOT_INITIALIZED";
 		case EGL_BAD_ACCESS:
 			return "EGL_BAD_ACCESS";
 		case EGL_BAD_ALLOC:
 			return "EGL_BAD_ALLOC";
 		case EGL_BAD_ATTRIBUTE:
 			return "EGL_BAD_ATTRIBUTE";
 		case EGL_BAD_CONTEXT:
 			return "EGL_BAD_CONTEXT";
 		case EGL_BAD_CONFIG:
 			return "EGL_BAD_CONFIG";
 		case EGL_BAD_CURRENT_SURFACE:
 			return "EGL_BAD_CURRENT_SURFACE";
 		case EGL_BAD_DISPLAY:
 			return "EGL_BAD_DISPLAY";
 		case EGL_BAD_SURFACE:
 			return "EGL_BAD_SURFACE";
 		case EGL_BAD_MATCH:
 			return "EGL_BAD_MATCH";
 		case EGL_BAD_PARAMETER:
 			return "EGL_BAD_PARAMETER";
 		case EGL_BAD_NATIVE_PIXMAP:
 			return "EGL_BAD_NATIVE_PIXMAP";
 		case EGL_BAD_NATIVE_WINDOW:
 			return "EGL_BAD_NATIVE_WINDOW";
 		case EGL_CONTEXT_LOST:
 			return "EGL_CONTEXT_LOST";
 		default:
 			return "EGL_???";
 	}
 }

 static const char *get_gl_framebuffer_error()
 {
 	switch (glCheckFramebufferStatus(GL_FRAMEBUFFER)) {
 		case GL_FRAMEBUFFER_COMPLETE:
 			return "GL_FRAMEBUFFER_COMPLETE";
 		case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
 			return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
 		case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
 			return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
 		case GL_FRAMEBUFFER_UNSUPPORTED:
 			return "GL_FRAMEBUFFER_UNSUPPORTED";
 		case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
 			return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
 		default:
 			return "GL_FRAMEBUFFER_???";
 	}
 }
	/*
	* Copyright 2016 The Chromium OS Authors. All rights reserved.
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "bs_drm.h"

	static const char *get_egl_error();
	static const char *get_gl_framebuffer_error();

	struct bs_egl {
	bool setup;
	EGLDisplay display;
	EGLContext ctx;
	bool use_image_flush_external;
	bool use_dma_buf_import_modifiers;

	// Names are the original gl/egl function names with the prefix chopped off.
	PFNEGLCREATEIMAGEKHRPROC CreateImageKHR;
	PFNEGLDESTROYIMAGEKHRPROC DestroyImageKHR;
	PFNEGLIMAGEFLUSHEXTERNALEXTPROC ImageFlushExternal;
	PFNGLEGLIMAGETARGETTEXTURE2DOESPROC EGLImageTargetTexture2DOES;
	};

	struct bs_egl_fb {
	GLuint tex;
	GLuint fb;
	};

	struct bs_egl *bs_egl_new()
	{
	struct bs_egl *self = calloc(1, sizeof(struct bs_egl));
	assert(self);
	self->display = EGL_NO_DISPLAY;
	self->ctx = EGL_NO_CONTEXT;
	return self;
	}

	void bs_egl_destroy(struct bs_egl **egl)
	{
	assert(egl);
	struct bs_egl self = egl;
	assert(self);

	if (self->ctx != EGL_NO_CONTEXT) {
	assert(self->display != EGL_NO_DISPLAY);
	eglMakeCurrent(self->display, NULL, NULL, NULL);
	eglDestroyContext(self->display, self->ctx);
	}

	if (self->display != EGL_NO_DISPLAY)
	eglTerminate(self->display);

	free(self);
	*egl = NULL;
	}

	bool bs_egl_setup(struct bs_egl *self)
	{
	assert(self);
	assert(!self->setup);

	self->CreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)eglGetProcAddress("eglCreateImageKHR");
	self->DestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)eglGetProcAddress("eglDestroyImageKHR");
	self->ImageFlushExternal =
	(PFNEGLIMAGEFLUSHEXTERNALEXTPROC)eglGetProcAddress("eglImageFlushExternalEXT");
	self->EGLImageTargetTexture2DOES =
	(PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)eglGetProcAddress("glEGLImageTargetTexture2DOES");
	if (!self->CreateImageKHR \|\| !self->DestroyImageKHR \|\| !self->EGLImageTargetTexture2DOES) {
	bs_debug_error(
	"eglGetProcAddress returned NULL for a required extension entry point.");
	return false;
	}

	self->display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	if (self->display == EGL_NO_DISPLAY) {
	bs_debug_error("failed to get egl display");
	return false;
	}

	if (!eglInitialize(self->display, NULL /* ignore version /, NULL / ignore version */)) {
	bs_debug_error("failed to initialize egl: %s\n", get_egl_error());
	return false;
	}

	// Get any EGLConfig. We need one to create a context, but it isn't used to create any
	// surfaces.
	const EGLint config_attribs[] = { EGL_SURFACE_TYPE, EGL_DONT_CARE, EGL_NONE };
	EGLConfig egl_config;
	EGLint num_configs;
	if (!eglChooseConfig(self->display, config_attribs, &egl_config, 1,
	&num_configs /* unused but can't be null */)) {
	bs_debug_error("eglChooseConfig() failed with error: %s", get_egl_error());
	goto terminate_display;
	}

	if (!eglBindAPI(EGL_OPENGL_ES_API)) {
	bs_debug_error("failed to bind OpenGL ES: %s", get_egl_error());
	goto terminate_display;
	}

	const EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };

	self->ctx = eglCreateContext(self->display, egl_config,
	EGL_NO_CONTEXT /* no shared context */, context_attribs);
	if (self->ctx == EGL_NO_CONTEXT) {
	bs_debug_error("failed to create OpenGL ES Context: %s", get_egl_error());
	goto terminate_display;
	}

	if (!eglMakeCurrent(self->display, EGL_NO_SURFACE /* no default draw surface */,
	EGL_NO_SURFACE /* no default draw read */, self->ctx)) {
	bs_debug_error("failed to make the OpenGL ES Context current: %s", get_egl_error());
	goto destroy_context;
	}

	const char *egl_extensions = eglQueryString(self->display, EGL_EXTENSIONS);
	if (!bs_egl_has_extension("EGL_KHR_image_base", egl_extensions)) {
	bs_debug_error("EGL_KHR_image_base extension not supported");
	goto destroy_context;
	}
	if (!bs_egl_has_extension("EGL_EXT_image_dma_buf_import", egl_extensions)) {
	bs_debug_error("EGL_EXT_image_dma_buf_import extension not supported");
	goto destroy_context;
	}
	if (bs_egl_has_extension("EGL_EXT_image_flush_external", egl_extensions)) {
	if (!self->ImageFlushExternal) {
	bs_debug_print("WARNING", __func__, __FILE__, __LINE__,
	"EGL_EXT_image_flush_external extension is supported, but "
	"eglGetProcAddress returned NULL.");
	} else {
	self->use_image_flush_external = true;
	}
	}
	if (bs_egl_has_extension("EGL_EXT_image_dma_buf_import_modifiers", egl_extensions))
	self->use_dma_buf_import_modifiers = true;

	const char gl_extensions = (const char )glGetString(GL_EXTENSIONS);
	if (!bs_egl_has_extension("GL_OES_EGL_image", gl_extensions)) {
	bs_debug_error("GL_OES_EGL_image extension not supported");
	goto destroy_context;
	}

	self->setup = true;

	return true;

	destroy_context:
	eglDestroyContext(self->display, self->ctx);
	terminate_display:
	eglTerminate(self->display);
	self->display = EGL_NO_DISPLAY;
	return false;
	}

	bool bs_egl_make_current(struct bs_egl *self)
	{
	assert(self);
	assert(self->display != EGL_NO_DISPLAY);
	assert(self->ctx != EGL_NO_CONTEXT);
	return eglMakeCurrent(self->display, EGL_NO_SURFACE /* No default draw surface */,
	EGL_NO_SURFACE /* No default draw read */, self->ctx);
	}

	static EGLImageKHR _bs_egl_image_create(struct bs_egl *self, int prime_fd, int width, int height,
	uint32_t format, int pitch, int offset,
	uint64_t *format_modifier)
	{
	assert(self);
	assert(self->CreateImageKHR);
	assert(self->display != EGL_NO_DISPLAY);
	EGLint khr_image_attrs[17] = { EGL_DMA_BUF_PLANE0_FD_EXT,
	prime_fd,
	EGL_WIDTH,
	width,
	EGL_HEIGHT,
	height,
	EGL_LINUX_DRM_FOURCC_EXT,
	(int)format,
	EGL_DMA_BUF_PLANE0_PITCH_EXT,
	pitch,
	EGL_DMA_BUF_PLANE0_OFFSET_EXT,
	offset,
	EGL_NONE };

	if (self->use_dma_buf_import_modifiers) {
	assert(format_modifier);
	uint64_t modifier = format_modifier ? *format_modifier : 0;
	khr_image_attrs[12] = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT;
	khr_image_attrs[13] = modifier & 0xfffffffful;
	khr_image_attrs[14] = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT;
	khr_image_attrs[15] = modifier >> 32;
	khr_image_attrs[16] = EGL_NONE;
	}

	EGLImageKHR image =
	self->CreateImageKHR(self->display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT,
	NULL /* no client buffer */, khr_image_attrs);

	if (image == EGL_NO_IMAGE_KHR) {
	bs_debug_error("failed to make image from target buffer: %s", get_egl_error());
	return EGL_NO_IMAGE_KHR;
	}

	return image;
	}

	EGLImageKHR bs_egl_image_create(struct bs_egl *self, int prime_fd, int width, int height,
	uint32_t format, int pitch, int offset)
	{
	return _bs_egl_image_create(self, prime_fd, width, height, format, pitch, offset, NULL);
	}

	EGLImageKHR bs_egl_image_create_with_modifier(struct bs_egl *self, int prime_fd, int width,
	int height, uint32_t format, int pitch, int offset,
	uint64_t format_modifier)
	{
	return _bs_egl_image_create(self, prime_fd, width, height, format, pitch, offset,
	&format_modifier);
	}

	EGLImageKHR bs_egl_image_create_gbm(struct bs_egl self, struct gbm_bo bo)
	{
	assert(bo);
	int fd = gbm_bo_get_fd(bo);
	if (fd < 0) {
	bs_debug_error("failed to get fb for bo: %d", fd);
	return EGL_NO_IMAGE_KHR;
	}
	uint64_t modifier = self->use_dma_buf_import_modifiers ? gbm_bo_get_format_modifier(bo) : 0;
	return bs_egl_image_create_with_modifier(
	self, fd, gbm_bo_get_width(bo), gbm_bo_get_height(bo), gbm_bo_get_format(bo),
	gbm_bo_get_stride(bo), 0 /* no offset */, modifier);
	}

	void bs_egl_image_destroy(struct bs_egl self, EGLImageKHR image)
	{
	assert(self);
	assert(image);
	assert(*image != EGL_NO_IMAGE_KHR);
	assert(self->DestroyImageKHR);
	self->DestroyImageKHR(self->display, *image);
	*image = EGL_NO_IMAGE_KHR;
	}

	bool bs_egl_image_flush_external(struct bs_egl *self, EGLImageKHR image)
	{
	assert(self);
	assert(image != EGL_NO_IMAGE_KHR);
	if (!self->use_image_flush_external)
	return true;
	const EGLAttrib attrs[] = { EGL_NONE };
	return self->ImageFlushExternal(self->display, image, attrs);
	}

	struct bs_egl_fb bs_egl_fb_new(struct bs_egl self, EGLImageKHR image)
	{
	assert(self);
	assert(self->EGLImageTargetTexture2DOES);

	struct bs_egl_fb *fb = calloc(1, sizeof(struct bs_egl_fb));
	assert(fb);

	glGenTextures(1, &fb->tex);
	glBindTexture(GL_TEXTURE_2D, fb->tex);
	self->EGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
	glBindTexture(GL_TEXTURE_2D, 0);

	glGenFramebuffers(1, &fb->fb);
	glBindFramebuffer(GL_FRAMEBUFFER, fb->fb);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fb->tex, 0);

	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
	bs_debug_error("failed framebuffer check for created target buffer: %s",
	get_gl_framebuffer_error());
	glDeleteFramebuffers(1, &fb->fb);
	glDeleteTextures(1, &fb->tex);
	free(fb);
	return NULL;
	}

	return fb;
	}

	void bs_egl_fb_destroy(struct bs_egl_fb **fb)
	{
	assert(fb);
	struct bs_egl_fb self = fb;
	assert(self);

	glDeleteFramebuffers(1, &self->fb);
	glDeleteTextures(1, &self->tex);

	free(self);
	*fb = NULL;
	}

	GLuint bs_egl_fb_name(struct bs_egl_fb *self)
	{
	assert(self);
	return self->fb;
	}

	bool bs_egl_target_texture2D(struct bs_egl *self, EGLImageKHR image)
	{
	assert(self);
	assert(self->EGLImageTargetTexture2DOES);
	self->EGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
	GLint error = glGetError();
	return (error == GL_NO_ERROR);
	}

	bool bs_egl_has_extension(const char extension, const char extensions)
	{
	const char start, where, *terminator;
	start = extensions;
	for (;;) {
	where = (char )strstr((const char )start, extension);
	if (!where)
	break;
	terminator = where + strlen(extension);
	if (where == start \|\| *(where - 1) == ' ')
	if (terminator == ' ' \|\| terminator == '\0')
	return true;
	start = terminator;
	}
	return false;
	}

	static const char *get_egl_error()
	{
	switch (eglGetError()) {
	case EGL_SUCCESS:
	return "EGL_SUCCESS";
	case EGL_NOT_INITIALIZED:
	return "EGL_NOT_INITIALIZED";
	case EGL_BAD_ACCESS:
	return "EGL_BAD_ACCESS";
	case EGL_BAD_ALLOC:
	return "EGL_BAD_ALLOC";
	case EGL_BAD_ATTRIBUTE:
	return "EGL_BAD_ATTRIBUTE";
	case EGL_BAD_CONTEXT:
	return "EGL_BAD_CONTEXT";
	case EGL_BAD_CONFIG:
	return "EGL_BAD_CONFIG";
	case EGL_BAD_CURRENT_SURFACE:
	return "EGL_BAD_CURRENT_SURFACE";
	case EGL_BAD_DISPLAY:
	return "EGL_BAD_DISPLAY";
	case EGL_BAD_SURFACE:
	return "EGL_BAD_SURFACE";
	case EGL_BAD_MATCH:
	return "EGL_BAD_MATCH";
	case EGL_BAD_PARAMETER:
	return "EGL_BAD_PARAMETER";
	case EGL_BAD_NATIVE_PIXMAP:
	return "EGL_BAD_NATIVE_PIXMAP";
	case EGL_BAD_NATIVE_WINDOW:
	return "EGL_BAD_NATIVE_WINDOW";
	case EGL_CONTEXT_LOST:
	return "EGL_CONTEXT_LOST";
	default:
	return "EGL_???";
	}
	}

	static const char *get_gl_framebuffer_error()
	{
	switch (glCheckFramebufferStatus(GL_FRAMEBUFFER)) {
	case GL_FRAMEBUFFER_COMPLETE:
	return "GL_FRAMEBUFFER_COMPLETE";
	case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
	return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
	case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
	return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
	case GL_FRAMEBUFFER_UNSUPPORTED:
	return "GL_FRAMEBUFFER_UNSUPPORTED";
	case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
	return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
	default:
	return "GL_FRAMEBUFFER_???";
	}
	}