forked from enlightenment/efl
539 lines
13 KiB
C
539 lines
13 KiB
C
#include "evas_engine.h"
|
|
#include <dlfcn.h>
|
|
|
|
#ifdef HAVE_DRM_HW_ACCEL
|
|
# define EGL_EGLEXT_PROTOTYPES
|
|
# define GL_GLEXT_PROTOTYPES
|
|
|
|
# include <GLES2/gl2.h>
|
|
# include <GLES2/gl2ext.h>
|
|
# include <EGL/egl.h>
|
|
# include <EGL/eglext.h>
|
|
#endif
|
|
|
|
/* NB: This union is the same in GBM and TBM so we can use it
|
|
* to return 'handles' */
|
|
union _ebi_bo_handle
|
|
{
|
|
void *ptr;
|
|
int32_t s32;
|
|
uint32_t u32;
|
|
int64_t s64;
|
|
uint64_t u64;
|
|
};
|
|
|
|
enum _ebi_bo_format
|
|
{
|
|
EBI_BO_FORMAT_XRGB8888,
|
|
EBI_BO_FORMAT_ARGB8888
|
|
};
|
|
|
|
enum _ebi_bo_gbm_flags
|
|
{
|
|
EBI_BO_GBM_SCANOUT = (1 << 0),
|
|
EBI_BO_GBM_CURSOR = (1 << 1),
|
|
EBI_BO_GBM_RENDER = (1 << 2),
|
|
EBI_BO_GBM_WRITE = (1 << 3),
|
|
};
|
|
|
|
enum _ebi_bo_tbm_flags
|
|
{
|
|
EBI_BO_TBM_DEFAULT = 0,
|
|
EBI_BO_TBM_SCANOUT = (1 << 0),
|
|
EBI_BO_TBM_NONCACHE = (1 << 1),
|
|
EBI_BO_TBM_WC = (1 << 2),
|
|
EBI_BO_TBM_VENDOR = (0xffff0000),
|
|
};
|
|
|
|
typedef struct _Evas_Bufmgr_Interface Evas_Bufmgr_Interface;
|
|
struct _Evas_Bufmgr_Interface
|
|
{
|
|
int fd;
|
|
|
|
/* actual library we linked to */
|
|
void *lib;
|
|
|
|
/* actual buffer manager returned from library init */
|
|
void *mgr;
|
|
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
void *(*init)(int fd);
|
|
void (*shutdown)(void *mgr);
|
|
void *(*surface_create)(void *mgr, unsigned int width, unsigned int height, unsigned int format, unsigned int flags);
|
|
void (*surface_destroy)(void *surface);
|
|
void *(*buffer_create)(void *mgr, unsigned int width, unsigned int height, unsigned int format, unsigned int flags);
|
|
void (*buffer_destroy)(void *buffer);
|
|
union _ebi_bo_handle (*buffer_handle_get)(void *buffer);
|
|
unsigned int (*buffer_stride_get)(void *buffer);
|
|
} gbm;
|
|
struct
|
|
{
|
|
void *(*init)(int fd);
|
|
void (*shutdown)(void *mgr);
|
|
} tbm;
|
|
} funcs;
|
|
|
|
#ifdef HAVE_DRM_HW_ACCEL
|
|
struct
|
|
{
|
|
EGLDisplay disp;
|
|
EGLContext ctx;
|
|
EGLConfig cfg;
|
|
|
|
PFNEGLCREATEIMAGEKHRPROC image_create;
|
|
PFNEGLDESTROYIMAGEKHRPROC image_destroy;
|
|
PFNGLEGLIMAGETARGETTEXTURE2DOESPROC image_texture;
|
|
} egl;
|
|
#endif
|
|
};
|
|
|
|
/* buffer manager interface */
|
|
static Evas_Bufmgr_Interface *_ebi;
|
|
|
|
static Eina_Bool
|
|
_evas_bufmgr_egl_init(void)
|
|
{
|
|
#ifdef HAVE_DRM_HW_ACCEL
|
|
/* const char *ext; */
|
|
EGLint maj, min, n;
|
|
EGLint atts[] =
|
|
{
|
|
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
|
|
EGL_RED_SIZE, 1, EGL_GREEN_SIZE, 1, EGL_BLUE_SIZE, 1,
|
|
EGL_ALPHA_SIZE, 1, EGL_DEPTH_SIZE, 1,
|
|
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE
|
|
};
|
|
|
|
/* try to get the egl display from the manager */
|
|
_ebi->egl.disp = eglGetDisplay(_ebi->mgr);
|
|
if (_ebi->egl.disp == EGL_NO_DISPLAY)
|
|
{
|
|
ERR("Could not get EGLDisplay: %m");
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
/* try to init egl library */
|
|
if (!eglInitialize(_ebi->egl.disp, &maj, &min))
|
|
{
|
|
ERR("Could not init EGL library: %m");
|
|
goto init_err;
|
|
}
|
|
|
|
/* check egl extensions for what we need */
|
|
/* ext = eglQueryString(_ebi->egl.disp, EGL_EXTENSIONS); */
|
|
/* if (!strstr(ext, "EGL_KHR_surfaceless_opengl")) */
|
|
/* { */
|
|
/* ERR("EGL_KHR_surfaceless_opengl Not Supported"); */
|
|
/* goto init_err; */
|
|
/* } */
|
|
|
|
eglBindAPI(EGL_OPENGL_ES_API);
|
|
|
|
/* try to find matching egl config */
|
|
if (!eglChooseConfig(_ebi->egl.disp, atts, &_ebi->egl.cfg, 1, &n) ||
|
|
(n != 1))
|
|
{
|
|
ERR("Could not find EGLConfig: %m");
|
|
goto init_err;
|
|
}
|
|
|
|
/* try to create a context */
|
|
if (!(_ebi->egl.ctx =
|
|
eglCreateContext(_ebi->egl.disp, _ebi->egl.cfg, EGL_NO_CONTEXT, NULL)))
|
|
{
|
|
ERR("Could not create EGL Context: %m");
|
|
goto init_err;
|
|
}
|
|
|
|
/* try to make this context current */
|
|
if (!eglMakeCurrent(_ebi->egl.disp, EGL_NO_SURFACE, EGL_NO_SURFACE,
|
|
_ebi->egl.ctx))
|
|
{
|
|
ERR("Could not make EGL Context current: %m");
|
|
goto curr_err;
|
|
}
|
|
|
|
/* TODO: setup shaders ?? */
|
|
|
|
/* link to egl functions */
|
|
_ebi->egl.image_create = (PFNEGLCREATEIMAGEKHRPROC)
|
|
eglGetProcAddress("eglCreateImageKHR");
|
|
_ebi->egl.image_destroy = (PFNEGLDESTROYIMAGEKHRPROC)
|
|
eglGetProcAddress("eglDestroyImageKHR");
|
|
_ebi->egl.image_texture = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)
|
|
eglGetProcAddress("glEGLImageTargetTexture2DOES");
|
|
|
|
return EINA_TRUE;
|
|
|
|
curr_err:
|
|
/* destroy the egl context */
|
|
eglDestroyContext(_ebi->egl.disp, _ebi->egl.ctx);
|
|
|
|
init_err:
|
|
/* close egl display */
|
|
eglTerminate(_ebi->egl.disp);
|
|
eglReleaseThread();
|
|
#endif
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
static void
|
|
_evas_bufmgr_egl_shutdown(void)
|
|
{
|
|
#ifdef HAVE_DRM_HW_ACCEL
|
|
if (_ebi->egl.disp)
|
|
{
|
|
eglMakeCurrent(_ebi->egl.disp,
|
|
EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
|
|
eglTerminate(_ebi->egl.disp);
|
|
eglReleaseThread();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static Eina_Bool
|
|
_evas_bufmgr_gbm_init(void)
|
|
{
|
|
int flags = 0;
|
|
|
|
/* set dlopen flags */
|
|
flags = (RTLD_LAZY | RTLD_GLOBAL);
|
|
|
|
/* try to find gbm library */
|
|
_ebi->lib = dlopen("libgbm.so", flags);
|
|
if (!_ebi->lib) _ebi->lib = dlopen("libgbm.so.1", flags);
|
|
if (!_ebi->lib) _ebi->lib = dlopen("libgbm.so.1.0.0", flags);
|
|
|
|
/* fail if we did not find the library */
|
|
if (!_ebi->lib) return EINA_FALSE;
|
|
|
|
/* with the library found, lets symlink the functions we need */
|
|
_ebi->funcs.gbm.init = dlsym(_ebi->lib, "gbm_create_device");
|
|
_ebi->funcs.gbm.shutdown = dlsym(_ebi->lib, "gbm_device_destroy");
|
|
_ebi->funcs.gbm.surface_create = dlsym(_ebi->lib, "gbm_surface_create");
|
|
_ebi->funcs.gbm.surface_destroy = dlsym(_ebi->lib, "gbm_surface_destroy");
|
|
_ebi->funcs.gbm.buffer_create = dlsym(_ebi->lib, "gbm_bo_create");
|
|
_ebi->funcs.gbm.buffer_destroy = dlsym(_ebi->lib, "gbm_bo_destroy");
|
|
_ebi->funcs.gbm.buffer_handle_get = dlsym(_ebi->lib, "gbm_bo_get_handle");
|
|
_ebi->funcs.gbm.buffer_stride_get = dlsym(_ebi->lib, "gbm_bo_get_stride");
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
static Eina_Bool
|
|
_evas_bufmgr_tbm_init(void)
|
|
{
|
|
int flags = 0;
|
|
|
|
/* set dlopen flags */
|
|
flags = (RTLD_LAZY | RTLD_GLOBAL);
|
|
|
|
/* try to find gbm library */
|
|
_ebi->lib = dlopen("libtbm.so", flags);
|
|
if (!_ebi->lib) _ebi->lib = dlopen("libtbm.so.1", flags);
|
|
if (!_ebi->lib) _ebi->lib = dlopen("libtbm.so.1.0.0", flags);
|
|
|
|
/* fail if we did not find the library */
|
|
if (!_ebi->lib) return EINA_FALSE;
|
|
|
|
/* with the library found, lets symlink the functions we need */
|
|
/* TODO */
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
Eina_Bool
|
|
evas_bufmgr_init(int fd)
|
|
{
|
|
/* if we already have an interface, then we have been here before */
|
|
if (_ebi) return EINA_TRUE;
|
|
|
|
/* try to allocate space for interface */
|
|
if (!(_ebi = calloc(1, sizeof(Evas_Bufmgr_Interface)))) return EINA_FALSE;
|
|
|
|
/* save drm card fd for later use */
|
|
_ebi->fd = fd;
|
|
|
|
/* try to find and link gbm library first */
|
|
if (!_evas_bufmgr_gbm_init())
|
|
{
|
|
/* try to find and link tbm library */
|
|
if (!_evas_bufmgr_tbm_init())
|
|
{
|
|
ERR("Could not init buffer library");
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
/* with the library open and functions linked, lets try to init */
|
|
if (_ebi->funcs.gbm.init)
|
|
_ebi->mgr = _ebi->funcs.gbm.init(fd);
|
|
else if (_ebi->funcs.tbm.init)
|
|
_ebi->mgr = _ebi->funcs.tbm.init(fd);
|
|
|
|
if (!_ebi->mgr)
|
|
{
|
|
ERR("Could not init buffer manager");
|
|
goto init_err;
|
|
}
|
|
|
|
/* with the manager initialized, we need to init egl */
|
|
if (!_evas_bufmgr_egl_init())
|
|
WRN("Could not init egl");
|
|
|
|
return EINA_TRUE;
|
|
|
|
/* egl_err: */
|
|
/* if (_ebi->mgr) */
|
|
/* { */
|
|
/* if (_ebi->funcs.gbm.shutdown) _ebi->funcs.gbm.shutdown(_ebi->mgr); */
|
|
/* else if (_ebi->funcs.tbm.shutdown) _ebi->funcs.tbm.shutdown(_ebi->mgr); */
|
|
/* _ebi->mgr = NULL; */
|
|
/* } */
|
|
|
|
init_err:
|
|
/* close library */
|
|
if (_ebi->lib) dlclose(_ebi->lib);
|
|
_ebi->lib = NULL;
|
|
err:
|
|
/* free allocated space */
|
|
free(_ebi);
|
|
_ebi = NULL;
|
|
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
void
|
|
evas_bufmgr_shutdown(void)
|
|
{
|
|
/* check for valid interface */
|
|
if (!_ebi) return;
|
|
|
|
/* shutdown egl */
|
|
_evas_bufmgr_egl_shutdown();
|
|
|
|
/* shutdown manager */
|
|
if (_ebi->mgr)
|
|
{
|
|
if (_ebi->funcs.gbm.shutdown) _ebi->funcs.gbm.shutdown(_ebi->mgr);
|
|
else if (_ebi->funcs.tbm.shutdown) _ebi->funcs.tbm.shutdown(_ebi->mgr);
|
|
_ebi->mgr = NULL;
|
|
}
|
|
|
|
/* close library */
|
|
if (_ebi->lib) dlclose(_ebi->lib);
|
|
_ebi->lib = NULL;
|
|
|
|
/* free allocated space */
|
|
free(_ebi);
|
|
_ebi = NULL;
|
|
}
|
|
|
|
#ifdef HAVE_DRM_HW_ACCEL
|
|
void *
|
|
evas_bufmgr_window_create(void *surface)
|
|
{
|
|
void *win;
|
|
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (_ebi->egl.disp == EGL_NO_DISPLAY)) return NULL;
|
|
|
|
/* try to create the egl window surface */
|
|
win = eglCreateWindowSurface(_ebi->egl.disp, _ebi->egl.cfg,
|
|
(EGLNativeWindowType)surface, NULL);
|
|
if (win == EGL_NO_SURFACE)
|
|
{
|
|
ERR("Failed to create egl window surface: %m");
|
|
return NULL;
|
|
}
|
|
|
|
/* try to make this window surface current */
|
|
if (!eglMakeCurrent(_ebi->egl.disp, win, win, _ebi->egl.ctx))
|
|
ERR("Could not make window surface current: %m");
|
|
|
|
return win;
|
|
}
|
|
|
|
void
|
|
evas_bufmgr_window_destroy(void *win)
|
|
{
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (_ebi->egl.disp == EGL_NO_DISPLAY)) return;
|
|
|
|
/* destroy the egl window */
|
|
if (win) eglDestroySurface(_ebi->egl.disp, win);
|
|
}
|
|
|
|
void *
|
|
evas_bufmgr_surface_create(int w, int h, Eina_Bool alpha)
|
|
{
|
|
unsigned int format, flags;
|
|
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (!_ebi->mgr)) return NULL;
|
|
|
|
format = EBI_BO_FORMAT_XRGB8888;
|
|
if (alpha) format = EBI_BO_FORMAT_ARGB8888;
|
|
|
|
/* call function to create surface */
|
|
if (_ebi->funcs.gbm.surface_create)
|
|
{
|
|
flags = (EBI_BO_GBM_SCANOUT | EBI_BO_GBM_RENDER);
|
|
return _ebi->funcs.gbm.surface_create(_ebi->mgr, w, h, format, flags);
|
|
}
|
|
|
|
/* else if (_ebi->funcs.tbm.surface_create) */
|
|
/* surface = _ebi->funcs.tbm.surface_create(); */
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
evas_bufmgr_surface_destroy(void *surface)
|
|
{
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (!_ebi->mgr)) return;
|
|
|
|
/* check for valid surface */
|
|
if (!surface) return;
|
|
|
|
/* call destroy surface */
|
|
if (_ebi->funcs.gbm.surface_destroy)
|
|
_ebi->funcs.gbm.surface_destroy(surface);
|
|
|
|
/* else if (_ebi->funcs.tbm.surface_destroy) */
|
|
/* _ebi->funcs.tbm.surface_destroy(surface); */
|
|
}
|
|
|
|
void *
|
|
evas_bufmgr_buffer_create(int w, int h, Eina_Bool alpha)
|
|
{
|
|
unsigned int format, flags;
|
|
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (!_ebi->mgr)) return NULL;
|
|
|
|
format = EBI_BO_FORMAT_XRGB8888;
|
|
if (alpha) format = EBI_BO_FORMAT_ARGB8888;
|
|
|
|
/* call function to create surface */
|
|
if (_ebi->funcs.gbm.buffer_create)
|
|
{
|
|
flags = (EBI_BO_GBM_SCANOUT | EBI_BO_GBM_RENDER);
|
|
return _ebi->funcs.gbm.buffer_create(_ebi->mgr, w, h, format, flags);
|
|
}
|
|
|
|
/* else if (_ebi->funcs.tbm.buffer_create) */
|
|
/* surface = _ebi->funcs.tbm.buffer_create(); */
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
evas_bufmgr_buffer_destroy(void *buffer)
|
|
{
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (!_ebi->mgr)) return;
|
|
|
|
/* check for valid buffer */
|
|
if (!buffer) return;
|
|
|
|
/* call function to destroy buffer */
|
|
if (_ebi->funcs.gbm.buffer_destroy)
|
|
_ebi->funcs.gbm.buffer_destroy(buffer);
|
|
|
|
/* else if (_ebi->funcs.tbm.buffer_destroy) */
|
|
/* _ebi->funcs.tbm.buffer_destroy(buffer); */
|
|
}
|
|
|
|
int
|
|
evas_bufmgr_buffer_handle_get(void *buffer)
|
|
{
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (!_ebi->mgr)) return 0;
|
|
|
|
/* check for valid buffer */
|
|
if (!buffer) return 0;
|
|
|
|
/* call function to get buffer handle */
|
|
if (_ebi->funcs.gbm.buffer_handle_get)
|
|
return _ebi->funcs.gbm.buffer_handle_get(buffer).u32;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
evas_bufmgr_buffer_stride_get(void *buffer)
|
|
{
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (!_ebi->mgr)) return 0;
|
|
|
|
/* check for valid buffer */
|
|
if (!buffer) return 0;
|
|
|
|
/* call function to get buffer stride */
|
|
if (_ebi->funcs.gbm.buffer_stride_get)
|
|
return _ebi->funcs.gbm.buffer_stride_get(buffer);
|
|
|
|
/* else if (_ebi->funcs.tbm.buffer_stride_get) */
|
|
/* return _ebi->funcs.tbm.buffer_stride_get(buffer); */
|
|
|
|
return 0;
|
|
}
|
|
|
|
void *
|
|
evas_bufmgr_image_create(void *buffer)
|
|
{
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (_ebi->egl.disp == EGL_NO_DISPLAY)) return NULL;
|
|
|
|
/* check for valid buffer */
|
|
if (!buffer) return NULL;
|
|
|
|
/* try to create an egl image from this buffer */
|
|
if (_ebi->egl.image_create)
|
|
return _ebi->egl.image_create(_ebi->egl.disp, EGL_NO_CONTEXT,
|
|
EGL_NATIVE_PIXMAP_KHR, buffer, NULL);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
evas_bufmgr_image_destroy(void *image)
|
|
{
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (_ebi->egl.disp == EGL_NO_DISPLAY)) return;
|
|
|
|
/* check for valid image */
|
|
if (!image) return;
|
|
|
|
/* destroy egl image */
|
|
if (_ebi->egl.image_destroy)
|
|
_ebi->egl.image_destroy(_ebi->egl.disp, image);
|
|
}
|
|
|
|
unsigned int
|
|
evas_bufmgr_texture_create(void *image)
|
|
{
|
|
GLuint tex;
|
|
|
|
/* check for valid interface */
|
|
if ((!_ebi) || (_ebi->egl.disp == EGL_NO_DISPLAY)) return 0;
|
|
|
|
/* check for valid image */
|
|
if (!image) return 0;
|
|
|
|
glGenTextures(1, &tex);
|
|
glBindTexture(GL_TEXTURE_2D, tex);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
if (_ebi->egl.image_texture) _ebi->egl.image_texture(GL_TEXTURE_2D, image);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
return tex;
|
|
}
|
|
#endif
|