kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

evas: add eglfs evas module. 

EGL Fullscreen is a module intended to support many proprietary GL driver that come
with custom API to create framebuffer/window. This one is starting by covering Android
with libhybris/hwcomposer. Later on, it should be able to support easily the Raspberry Pi
driver.

At this moment this does not work properly. Activate it at your own risk ! Do not report
bug if you don't know what you are doing :-) A backend for Ecore_Evas will come later on
along with a patch for Ecore_FB to use libinput. Finally a few patch should hopefully
enable this backend to work and compile more easily (relying on proper header detection
and dlopen/dlsym for access to proprietary function).

You can read more about the goal of this patch by reading our wiki at :
https://phab.enlightenment.org/w/boot2efl/

Signed-off-by: Cedric Bail <cedric@osg.samsung.com>
This commit is contained in:
Nicolas Aguirre 2016-03-18 08:56:59 +01:00 committed by Cedric Bail
parent 652895ad4a
commit 290fc88e3f
10 changed files with 2245 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile.am
View File

@ -188,6 +188,10 @@ if BUILD_ENGINE_FB
pkgconfig_DATA += pc/evas-fb.pc
endif
if BUILD_ENGINE_EGLFS
pkgconfig_DATA += pc/evas-eglfs.pc
endif
if BUILD_ENGINE_BUFFER
pkgconfig_DATA += pc/evas-software-buffer.pc
endif

17
configure.ac
View File

@ -1624,6 +1624,19 @@ AC_ARG_ENABLE([fb],
],
[want_fb="no"])
# Eglfs
AC_ARG_ENABLE([eglfs],
[AS_HELP_STRING([--enable-eglfs],[enable hardware accelerated framebuffer access. @<:@default=disabled@:>@])],
[
if test "x${enableval}" = "xyes" ; then
want_eglfs="yes"
want_fb="yes"
else
want_eglfs="no"
fi
],
[want_eglfs="no"])
# SDL
AC_ARG_ENABLE([sdl],
[AS_HELP_STRING([--enable-sdl],[enable SDL support. @<:@default=disabled@:>@])],
@ -2080,6 +2093,7 @@ EVAS_CHECK_ENGINE([wayland-egl], [${want_evas_engine_wayland_egl}], [no], [Wayla
EVAS_CHECK_ENGINE([wayland-shm], [${want_wayland}], [no], [Wayland Shm])
EVAS_CHECK_ENGINE([drm], [${want_drm}], [no], [Drm])
EVAS_CHECK_ENGINE([gl-drm], [${want_gl_drm}], [no], [OpenGL Drm])
EVAS_CHECK_ENGINE([eglfs], [${want_eglfs}], [no], [OpenGL Fb])
# Software XCB
@ -2236,6 +2250,7 @@ if test "x$have_evas_engine_gl_xlib" = "xyes" || \
test "x$have_evas_engine_gl_sdl" = "xyes" || \
test "x$have_evas_engine_gl_cocoa" = "xyes" || \
test "x$have_evas_engine_gl_drm" = "xyes" || \
test "x$have_evas_engine_eglfs" = "xyes" || \
test "x$have_evas_engine_wayland_egl" = "xyes"; then
have_evas_engine_gl_common="yes"
fi
@ -2244,6 +2259,7 @@ if test "x$have_evas_engine_gl_xlib" = "xstatic" || \
test "x$have_evas_engine_gl_sdl" = "xstatic" || \
test "x$have_evas_engine_gl_cocoa" = "xstatic" || \
test "x$have_evas_engine_gl_drm" = "xstatic" || \
test "x$have_evas_engine_eglfs" = "xstatic" || \
test "x$have_evas_engine_wayland_egl" = "xstatic"; then
have_evas_engine_gl_common="yes"
have_static_evas_engine_gl_common="yes"
@ -5095,6 +5111,7 @@ pc/eo-js.pc
pc/efl.pc
pc/efl-cxx.pc
pc/evas-fb.pc
pc/evas-eglfs.pc
pc/evas-opengl-x11.pc
pc/evas-opengl-sdl.pc
pc/evas-opengl-cocoa.pc

43
m4/evas_check_engine.m4
View File

@ -661,6 +661,49 @@ AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
])
dnl use: EVAS_CHECK_ENGINE_DEP_EGLFS(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
AC_DEFUN([EVAS_CHECK_ENGINE_DEP_EGLFS],
[
requirement=""
have_dep="no"
have_hw_dep="no"
evas_engine_[]$1[]_cflags=""
evas_engine_[]$1[]_libs=""
if test "x${with_opengl}" = "xes" ; then
gl_library="glesv2"
else
AC_MSG_ERROR([We do not support Eglfs without OpenGL ES. Please consider OpenGL ES if you want to use it.])
fi
PKG_CHECK_EXISTS([egl >= 7.10 ${gl_library}],
[
have_dep="yes"
requirement="egl >= 7.10 ${gl_library}"
],
[have_dep="no"])
if test "x${have_dep}" = "xyes" ; then
if test "x$3" = "xstatic" ; then
requirements_pc_evas="${requirement} ${requirements_pc_evas}"
requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
else
PKG_CHECK_MODULES([EGLFS], [${requirement}])
evas_engine_[]$1[]_cflags="${EGLFS_CFLAGS}"
evas_engine_[]$1[]_libs="${EGLFS_LIBS}"
evas_engine_gl_common_libs="$evas_engine_[]$1[]_libdirs -lGLESv2 -lm -lEGL"
fi
fi
AC_SUBST([evas_engine_$1_cflags])
AC_SUBST([evas_engine_$1_libs])
AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
])
dnl use: EVAS_ENGINE(name, want_engine, [DEPENDENCY-CHECK-CODE])
dnl

1
pc/.gitignore vendored
View File

@ -44,6 +44,7 @@
/ethumb_client.pc
/evas-drm.pc
/evas-fb.pc
/evas-eglfs.pc
/evas-opengl-cocoa.pc
/evas-opengl-sdl.pc
/evas-opengl-x11.pc

3
pc/evas-eglfs.pc.in Normal file
View File

@ -0,0 +1,3 @@
Name: evas-eglfs
Description: Evas eglfs engine
Version: @VERSION@

42
src/Makefile_Evas.am
View File

@ -874,6 +874,9 @@ endif
if BUILD_ENGINE_GL_DRM
modules_evas_engines_gl_common_libevas_engine_gl_common_la_CPPFLAGS += @evas_engine_gl_drm_cflags@
endif
if BUILD_ENGINE_EGLFS
modules_evas_engines_gl_common_libevas_engine_gl_common_la_CPPFLAGS += @evas_engine_eglfs_cflags@
endif
modules_evas_engines_gl_common_libevas_engine_gl_common_la_LIBADD = @USE_EVAS_LIBS@
modules_evas_engines_gl_common_libevas_engine_gl_common_la_DEPENDENCIES = @USE_EVAS_INTERNAL_LIBS@
modules_evas_engines_gl_common_libevas_engine_gl_common_la_LDFLAGS = -module @EFL_LTMODULE_FLAGS@
@ -1330,6 +1333,45 @@ modules_evas_engines_gl_drm_module_la_LIBTOOLFLAGS = --tag=disable-static
endif
endif
if BUILD_ENGINE_EGLFS
dist_installed_evasmainheaders_DATA += modules/evas/engines/eglfs/Evas_Engine_Eglfs.h
EGLFS_SOURCES = \
modules/evas/engines/eglfs/evas_outbuf.c \
modules/evas/engines/eglfs/evas_engine.c \
modules/evas/engines/eglfs/evas_engine.h \
modules/evas/engines/eglfs/Evas_Engine_Eglfs.h
if EVAS_STATIC_BUILD_EGLFS
lib_evas_libevas_la_SOURCES += $(EGLFS_SOURCES)
lib_evas_libevas_la_CPPFLAGS += @evas_engine_eglfs_cflags@
lib_evas_libevas_la_LIBADD += @evas_engine_eglfs_libs@
else
engineeglfspkgdir = $(libdir)/evas/modules/engines/eglfs/$(MODULE_ARCH)
engineeglfspkg_LTLIBRARIES = modules/evas/engines/eglfs/module.la
# Workaround for broken parallel install support in automake (relink issue)
# http://debbugs.gnu.org/cgi/bugreport.cgi?bug=7328
install_engineeglfspkgLTLIBRARIES = install-engineeglfspkgLTLIBRARIES
$(install_engineeglfspkgLTLIBRARIES): install-libLTLIBRARIES
modules_evas_engines_eglfs_module_la_SOURCES = $(EGLFS_SOURCES)
modules_evas_engines_eglfs_module_la_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
-I$(top_srcdir)/src/lib/evas/include \
-I$(top_srcdir)/src/lib/evas/cserve2 \
-I$(top_srcdir)/src/modules/evas/engines/eglfs \
@EVAS_CFLAGS@ \
@ECORE_DRM_CFLAGS@ \
@evas_engine_eglfs_cflags@
modules_evas_engines_eglfs_module_la_LIBADD = \
@USE_EVAS_LIBS@ \
@USE_ECORE_DRM_LIBS@ \
@evas_engine_eglfs_libs@ \
@USE_EEZE_INTERNAL_LIBS@
modules_evas_engines_eglfs_module_la_DEPENDENCIES = @USE_EVAS_INTERNAL_LIBS@ @USE_EEZE_INTERNAL_LIBS@ @USE_ECORE_DRM_INTERNAL_LIBS@
modules_evas_engines_eglfs_module_la_LDFLAGS = -module @EFL_LTMODULE_FLAGS@
modules_evas_engines_eglfs_module_la_LIBTOOLFLAGS = --tag=disable-static
endif
endif
### Cserve2 binary
if EVAS_CSERVE2

45
src/modules/evas/engines/eglfs/Evas_Engine_Eglfs.h Normal file
View File

@ -0,0 +1,45 @@
#ifndef _EVAS_ENGINE_EGLFS_H
# define _EVAS_ENGINE_EGLFS_H
typedef enum _Evas_Engine_Info_Eglfs_Swap_Mode
{
EVAS_ENGINE_EGLFS_SWAP_MODE_AUTO = 0,
EVAS_ENGINE_EGLFS_SWAP_MODE_FULL = 1,
EVAS_ENGINE_EGLFS_SWAP_MODE_COPY = 2,
EVAS_ENGINE_EGLFS_SWAP_MODE_DOUBLE = 3,
EVAS_ENGINE_EGLFS_SWAP_MODE_TRIPLE = 4,
EVAS_ENGINE_EGLFS_SWAP_MODE_QUADRUPLE = 5
} Evas_Engine_Info_Eglfs_Swap_Mode;
typedef struct _Evas_Engine_Info_Eglfs Evas_Engine_Info_Eglfs;
struct _Evas_Engine_Info_Eglfs
{
/* PRIVATE - don't mess with this baby or evas will poke its tongue out */
/* at you and make nasty noises */
Evas_Engine_Info magic;
struct
{
unsigned int rotation, depth;
unsigned int crtc_id, conn_id, buffer_id;
unsigned int format, flags;
Eina_Bool destination_alpha : 1;
Eina_Bool vsync : 1;
Eina_Bool indirect : 1;
unsigned char swap_mode : 4;
} info;
struct
{
void (*pre_swap)(void *data, Evas *evas);
void (*post_swap)(void *data, Evas *evas);
void *data;
} callback;
/* non-blocking or blocking mode */
Evas_Engine_Render_Mode render_mode;
};
#endif

1254
src/modules/evas/engines/eglfs/evas_engine.c Normal file
View File

File diff suppressed because it is too large Load Diff

133
src/modules/evas/engines/eglfs/evas_engine.h Normal file
View File

@ -0,0 +1,133 @@
#ifndef EVAS_ENGINE_H
# define EVAS_ENGINE_H
# include "evas_common_private.h"
# include "evas_macros.h"
# include "evas_private.h"
# include "Evas.h"
# include "Evas_Engine_Eglfs.h"
# define EGL_EGLEXT_PROTOTYPES
# define GL_GLEXT_PROTOTYPES
# include <EGL/egl.h>
# include <EGL/eglext.h>
# include <EGL/eglmesaext.h>
# include <GLES2/gl2.h>
# include <GLES2/gl2ext.h>
# include <hwcomposer.h>
# include <hardware/hardware.h>
# include <hardware/hwcomposer.h>
# include "../gl_generic/Evas_Engine_GL_Generic.h"
extern int _evas_engine_eglfs_log_dom;
extern int _extn_have_buffer_age;
# ifdef ERR
# undef ERR
# endif
# define ERR(...) EINA_LOG_DOM_ERR(_evas_engine_eglfs_log_dom, __VA_ARGS__)
# ifdef DBG
# undef DBG
# endif
# define DBG(...) EINA_LOG_DOM_DBG(_evas_engine_eglfs_log_dom, __VA_ARGS__)
# ifdef INF
# undef INF
# endif
# define INF(...) EINA_LOG_DOM_INFO(_evas_engine_eglfs_log_dom, __VA_ARGS__)
# ifdef WRN
# undef WRN
# endif
# define WRN(...) EINA_LOG_DOM_WARN(_evas_engine_eglfs_log_dom, __VA_ARGS__)
# ifdef CRI
# undef CRI
# endif
# define CRI(...) EINA_LOG_DOM_CRIT(_evas_engine_eglfs_log_dom, __VA_ARGS__)
extern Evas_GL_Common_Context_New glsym_evas_gl_common_context_new;
extern Evas_GL_Common_Context_Call glsym_evas_gl_common_context_flush;
extern Evas_GL_Common_Context_Call glsym_evas_gl_common_context_free;
extern Evas_GL_Common_Context_Call glsym_evas_gl_common_context_use;
extern Evas_GL_Common_Context_Call glsym_evas_gl_common_context_newframe;
extern Evas_GL_Common_Context_Call glsym_evas_gl_common_context_done;
extern Evas_GL_Common_Context_Resize_Call glsym_evas_gl_common_context_resize;
extern Evas_GL_Common_Buffer_Dump_Call glsym_evas_gl_common_buffer_dump;
extern Evas_GL_Preload_Render_Call glsym_evas_gl_preload_render_lock;
extern Evas_GL_Preload_Render_Call glsym_evas_gl_preload_render_unlock;
struct _Context_3D
{
EGLDisplay display;
EGLContext context;
EGLSurface surface;
};
struct _Outbuf
{
Evas_Engine_Info_Eglfs *info;
Evas_Engine_GL_Context *gl_context;
Evas *evas; // used for pre_swap, post_swap
int w, h;
unsigned int rotation, depth;
Render_Engine_Swap_Mode swap_mode;
struct
{
EGLContext context[1];
EGLSurface surface[1];
EGLConfig config;
EGLDisplay disp;
} egl;
struct
{
int prev_age, frame_cnt;
int curr, last, num;
Eina_List *pending_writes;
} priv;
Eina_Bool destination_alpha : 1;
Eina_Bool vsync : 1;
Eina_Bool lost_back : 1;
Eina_Bool surf : 1;
Eina_Bool drew : 1;
};
Outbuf *evas_outbuf_new(Evas_Engine_Info_Eglfs *info, int w, int h, Render_Engine_Swap_Mode swap_mode);
void evas_outbuf_free(Outbuf *ob);
void evas_outbuf_use(Outbuf *ob);
void evas_outbuf_resurf(Outbuf *ob);
void evas_outbuf_unsurf(Outbuf *ob);
void evas_outbuf_reconfigure(Outbuf *ob, int w, int h, int rot, Outbuf_Depth depth);
Render_Engine_Swap_Mode evas_outbuf_buffer_state_get(Outbuf *ob);
int evas_outbuf_rot_get(Outbuf *ob);
Eina_Bool evas_outbuf_update_region_first_rect(Outbuf *ob);
void *evas_outbuf_update_region_new(Outbuf *ob, int x, int y, int w, int h, int *cx, int *cy, int *cw, int *ch);
void evas_outbuf_update_region_push(Outbuf *ob, RGBA_Image *update, int x, int y, int w, int h);
void evas_outbuf_update_region_free(Outbuf *ob, RGBA_Image *update);
void evas_outbuf_flush(Outbuf *ob, Tilebuf_Rect *rects, Evas_Render_Mode render_mode);
Evas_Engine_GL_Context* evas_outbuf_gl_context_get(Outbuf *ob);
void *evas_outbuf_egl_display_get(Outbuf *ob);
Context_3D *evas_outbuf_gl_context_new(Outbuf *ob);
void evas_outbuf_gl_context_use(Context_3D *ctx);
EGLNativeWindowType create_hwcomposernativewindow(void);
static inline Eina_Bool
_re_wincheck(Outbuf *ob)
{
if (ob->surf) return EINA_TRUE;
evas_outbuf_resurf(ob);
ob->lost_back = 1;
if (!ob->surf) ERR("GL engine can't re-create window surface!");
return EINA_FALSE;
}
extern unsigned int (*glsym_eglSwapBuffersWithDamage)(EGLDisplay a, void *b, const EGLint *d, EGLint c);
#endif

703
src/modules/evas/engines/eglfs/evas_outbuf.c Normal file
View File

@ -0,0 +1,703 @@
#include "evas_engine.h"
#include <hybris/hwcomposerwindow/hwcomposer.h>
#include <hardware/hwcomposer.h>
#include <hardware/hardware.h>
#include <android-config.h>
static hwc_layer_1_t *fblayer;
static hwc_composer_device_1_t *hwcDevicePtr;
static hwc_display_contents_1_t **mList;
void present(void *user_data, struct ANativeWindow *window,
struct ANativeWindowBuffer *buffer)
{
int oldretire = mList[0]->retireFenceFd;
mList[0]->retireFenceFd = -1;
fblayer->handle = buffer->handle;
fblayer->acquireFenceFd = HWCNativeBufferGetFence(buffer);
fblayer->releaseFenceFd = -1;
int err = hwcDevicePtr->prepare(hwcDevicePtr, HWC_NUM_DISPLAY_TYPES, mList);
//assert(err == 0);
err = hwcDevicePtr->set(hwcDevicePtr, HWC_NUM_DISPLAY_TYPES, mList);
//assert(err == 0);
HWCNativeBufferSetFence(buffer, fblayer->releaseFenceFd);
if (oldretire != -1)
{
sync_wait(oldretire, -1);
close(oldretire);
}
}
EGLNativeWindowType create_hwcomposernativewindow(void)
{
int err;
hw_module_t *hwcModule = 0;
hwcDevicePtr = 0;
err = hw_get_module(HWC_HARDWARE_MODULE_ID, (const hw_module_t **) &hwcModule);
//assert(err == 0);
err = hwc_open_1(hwcModule, &hwcDevicePtr);
//assert(err == 0);
hwcDevicePtr->blank(hwcDevicePtr, 0, 0);
uint32_t configs[5];
size_t numConfigs = 5;
err = hwcDevicePtr->getDisplayConfigs(hwcDevicePtr, 0, configs, &numConfigs);
//assert (err == 0);
int32_t attr_values[2];
uint32_t attributes[] = { HWC_DISPLAY_WIDTH, HWC_DISPLAY_HEIGHT, HWC_DISPLAY_NO_ATTRIBUTE };
hwcDevicePtr->getDisplayAttributes(hwcDevicePtr, 0,
configs[0], attributes, attr_values);
size_t size = sizeof(hwc_display_contents_1_t) + 2 * sizeof(hwc_layer_1_t);
hwc_display_contents_1_t *list = (hwc_display_contents_1_t *) malloc(size);
mList = (hwc_display_contents_1_t **) malloc(HWC_NUM_DISPLAY_TYPES * sizeof(hwc_display_contents_1_t *));
const hwc_rect_t r = { 0, 0, attr_values[0], attr_values[1] };
int counter = 0;
for (; counter < HWC_NUM_DISPLAY_TYPES; counter++)
mList[counter] = NULL;
// Assign buffer only to the first item, otherwise you get tearing
// if passed the same to multiple places
mList[0] = list;
fblayer = &list->hwLayers[0];
memset(fblayer, 0, sizeof(hwc_layer_1_t));
fblayer->compositionType = HWC_FRAMEBUFFER;
fblayer->hints = 0;
fblayer->flags = 0;
fblayer->handle = 0;
fblayer->transform = 0;
fblayer->blending = HWC_BLENDING_NONE;
fblayer->sourceCrop = r;
fblayer->displayFrame = r;
fblayer->visibleRegionScreen.numRects = 1;
fblayer->visibleRegionScreen.rects = &fblayer->displayFrame;
fblayer->acquireFenceFd = -1;
fblayer->releaseFenceFd = -1;
fblayer = &list->hwLayers[1];
memset(fblayer, 0, sizeof(hwc_layer_1_t));
fblayer->compositionType = HWC_FRAMEBUFFER_TARGET;
fblayer->hints = 0;
fblayer->flags = 0;
fblayer->handle = 0;
fblayer->transform = 0;
fblayer->blending = HWC_BLENDING_NONE;
fblayer->sourceCrop = r;
fblayer->displayFrame = r;
fblayer->visibleRegionScreen.numRects = 1;
fblayer->visibleRegionScreen.rects = &fblayer->displayFrame;
fblayer->acquireFenceFd = -1;
fblayer->releaseFenceFd = -1;
list->retireFenceFd = -1;
list->flags = HWC_GEOMETRY_CHANGED;
list->numHwLayers = 2;
EGLNativeWindowType win = NULL;
win = (EGLNativeWindowType)HWCNativeWindowCreate(attr_values[0], attr_values[1], HAL_PIXEL_FORMAT_RGBA_8888, present, NULL);
return win;
}
/* local variables */
static Outbuf *_evas_eglfs_window = NULL;
static EGLContext context = EGL_NO_CONTEXT;
static int win_count = 0;
static Eina_Bool
_evas_outbuf_make_current(void *data, void *doit)
{
Outbuf *ob;
if (!(ob = data)) return EINA_FALSE;
if (doit)
{
if (!eglMakeCurrent(ob->egl.disp, ob->egl.surface[0],
ob->egl.surface[0], ob->egl.context[0]))
return EINA_FALSE;
}
else
{
if (!eglMakeCurrent(ob->egl.disp, EGL_NO_SURFACE,
EGL_NO_SURFACE, EGL_NO_CONTEXT))
return EINA_FALSE;
}
return EINA_TRUE;
}
void _hwcomposer_present_cb(void *user_data, struct ANativeWindow *window, struct ANativeWindowBuffer *buffer)
{
}
static Eina_Bool
_evas_outbuf_egl_setup(Outbuf *ob)
{
int ctx_attr[3];
int cfg_attr[40];
int maj = 0, min = 0, n = 0, i = 0;
EGLint ncfg;
EGLConfig *cfgs;
const GLubyte *vendor, *renderer, *version, *glslversion;
Eina_Bool blacklist = EINA_FALSE;
/* setup egl surface */
ctx_attr[0] = EGL_CONTEXT_CLIENT_VERSION;
ctx_attr[1] = 2;
ctx_attr[2] = EGL_NONE;
cfg_attr[n++] = EGL_BUFFER_SIZE;
cfg_attr[n++] = 32;
cfg_attr[n++] = EGL_DEPTH_SIZE;
cfg_attr[n++] = EGL_DONT_CARE;
cfg_attr[n++] = EGL_STENCIL_SIZE;
cfg_attr[n++] = EGL_DONT_CARE;
cfg_attr[n++] = EGL_RENDERABLE_TYPE;
cfg_attr[n++] = EGL_OPENGL_ES2_BIT;
cfg_attr[n++] = EGL_SURFACE_TYPE;
cfg_attr[n++] = EGL_WINDOW_BIT;
cfg_attr[n++] = EGL_ALPHA_SIZE;
if (ob->destination_alpha) cfg_attr[n++] = 1;
else cfg_attr[n++] = 0;
cfg_attr[n++] = EGL_NONE;
int err;
hw_module_t *hwcModule = 0;
hwc_composer_device_1_t *hwcDevicePtr = 0;
err = hw_get_module(HWC_HARDWARE_MODULE_ID, (const hw_module_t **) &hwcModule);
if (err != 0)
{
ERR("hw_get_module() fail. code=%d", err);
return EINA_FALSE;
}
err = hwc_open_1(hwcModule, &hwcDevicePtr);
if (err != 0)
{
ERR("hwc_open_1 fail. code=%d", err);
return EINA_FALSE;
}
hwcDevicePtr->blank(hwcDevicePtr, 0, 0);
uint32_t configs[5];
size_t numConfigs = 5;
err = hwcDevicePtr->getDisplayConfigs(hwcDevicePtr, 0, configs, &numConfigs);
if (err != 0)
{
ERR("getDisplayConfig. code=%d", err);
return EINA_FALSE;
}
int32_t attr_values[2];
uint32_t attributes[] = { HWC_DISPLAY_WIDTH, HWC_DISPLAY_HEIGHT, HWC_DISPLAY_NO_ATTRIBUTE };
hwcDevicePtr->getDisplayAttributes(hwcDevicePtr, 0,
configs[0], attributes, attr_values);
DBG("width: %i height: %i\n", attr_values[0], attr_values[1]);
size_t size = sizeof(hwc_display_contents_1_t) + 2 * sizeof(hwc_layer_1_t);
hwc_display_contents_1_t *list = (hwc_display_contents_1_t *) malloc(size);
hwc_display_contents_1_t **mList = (hwc_display_contents_1_t **) malloc(HWC_NUM_DISPLAY_TYPES * sizeof(hwc_display_contents_1_t *));
const hwc_rect_t r = { 0, 0, attr_values[0], attr_values[1] };
int counter = 0;
for (; counter < HWC_NUM_DISPLAY_TYPES; counter++)
mList[counter] = NULL;
mList[0] = list;
hwc_layer_1_t *layer = &list->hwLayers[0];
memset(layer, 0, sizeof(hwc_layer_1_t));
layer->compositionType = HWC_FRAMEBUFFER;
layer->hints = 0;
layer->flags = 0;
layer->handle = 0;
layer->transform = 0;
layer->blending = HWC_BLENDING_NONE;
layer->sourceCrop = r;
layer->displayFrame = r;
layer->visibleRegionScreen.numRects = 1;
layer->visibleRegionScreen.rects = &layer->displayFrame;
layer->acquireFenceFd = -1;
layer->releaseFenceFd = -1;
layer = &list->hwLayers[1];
memset(layer, 0, sizeof(hwc_layer_1_t));
layer->compositionType = HWC_FRAMEBUFFER_TARGET;
layer->hints = 0;
layer->flags = 0;
layer->handle = 0;
layer->transform = 0;
layer->blending = HWC_BLENDING_NONE;
layer->sourceCrop = r;
layer->displayFrame = r;
layer->visibleRegionScreen.numRects = 1;
layer->visibleRegionScreen.rects = &layer->displayFrame;
layer->acquireFenceFd = -1;
layer->releaseFenceFd = -1;
list->retireFenceFd = -1;
list->flags = HWC_GEOMETRY_CHANGED;
list->numHwLayers = 2;
ob->egl.disp = eglGetDisplay(NULL);
if (ob->egl.disp == EGL_NO_DISPLAY)
{
ERR("eglGetDisplay() fail. code=%#x", eglGetError());
return EINA_FALSE;
}
if (!eglInitialize(ob->egl.disp, &maj, &min))
{
ERR("eglInitialize() fail. code=%#x", eglGetError());
return EINA_FALSE;
}
eglBindAPI(EGL_OPENGL_ES_API);
if (eglGetError() != EGL_SUCCESS)
{
ERR("eglBindAPI() fail. code=%#x", eglGetError());
return EINA_FALSE;
}
if (!eglGetConfigs(ob->egl.disp, NULL, 0, &ncfg) || (ncfg == 0))
{
ERR("eglGetConfigs() fail. code=%#x", eglGetError());
return EINA_FALSE;
}
cfgs = malloc(ncfg * sizeof(EGLConfig));
if (!cfgs)
{
ERR("Failed to malloc space for egl configs");
return EINA_FALSE;
}
if (!eglChooseConfig(ob->egl.disp, cfg_attr, cfgs,
ncfg, &ncfg) || (ncfg == 0))
{
ERR("eglChooseConfig() fail. code=%#x", eglGetError());
return EINA_FALSE;
}
// First is always best...
ob->egl.config = cfgs[0];
EGLNativeWindowType win = create_hwcomposernativewindow();
ob->egl.surface[0] =
eglCreateWindowSurface(ob->egl.disp, ob->egl.config,
(EGLNativeWindowType)win, NULL);
if (ob->egl.surface[0] == EGL_NO_SURFACE)
{
ERR("eglCreateWindowSurface() fail for %p. code=%#x",
NULL, eglGetError());
return EINA_FALSE;
}
ob->egl.context[0] =
eglCreateContext(ob->egl.disp, ob->egl.config, EGL_NO_CONTEXT, ctx_attr);
if (ob->egl.context[0] == EGL_NO_CONTEXT)
{
ERR("eglCreateContext() fail. code=%#x", eglGetError());
return EINA_FALSE;
}
if (context == EGL_NO_CONTEXT) context = ob->egl.context[0];
if (eglMakeCurrent(ob->egl.disp, ob->egl.surface[0],
ob->egl.surface[0], ob->egl.context[0]) == EGL_FALSE)
{
ERR("eglMakeCurrent() fail. code=%#x", eglGetError());
return EINA_FALSE;
}
vendor = glGetString(GL_VENDOR);
renderer = glGetString(GL_RENDERER);
version = glGetString(GL_VERSION);
glslversion = glGetString(GL_SHADING_LANGUAGE_VERSION);
if (!vendor) vendor = (unsigned char *)"-UNKNOWN-";
if (!renderer) renderer = (unsigned char *)"-UNKNOWN-";
if (!version) version = (unsigned char *)"-UNKNOWN-";
if (!glslversion) glslversion = (unsigned char *)"-UNKNOWN-";
if (getenv("EVAS_GL_INFO"))
{
fprintf(stderr, "vendor : %s\n", vendor);
fprintf(stderr, "renderer: %s\n", renderer);
fprintf(stderr, "version : %s\n", version);
fprintf(stderr, "glsl ver: %s\n", glslversion);
}
if (strstr((const char *)vendor, "Mesa Project"))
{
if (strstr((const char *)renderer, "Software Rasterizer"))
blacklist = EINA_TRUE;
}
if (strstr((const char *)renderer, "softpipe"))
blacklist = EINA_TRUE;
if (strstr((const char *)renderer, "llvmpipe"))
blacklist = EINA_TRUE;
if ((blacklist) && (!getenv("EVAS_GL_NO_BLACKLIST")))
{
ERR("OpenGL Driver blacklisted:");
ERR("Vendor: %s", (const char *)vendor);
ERR("Renderer: %s", (const char *)renderer);
ERR("Version: %s", (const char *)version);
return EINA_FALSE;
}
ob->gl_context = glsym_evas_gl_common_context_new();
if (!ob->gl_context) return EINA_FALSE;
#ifdef GL_GLES
ob->gl_context->egldisp = ob->egl.disp;
ob->gl_context->eglctxt = ob->egl.context[0];
#endif
evas_outbuf_use(ob);
glsym_evas_gl_common_context_resize(ob->gl_context,
ob->w, ob->h, ob->rotation);
ob->surf = EINA_TRUE;
return EINA_TRUE;
}
Outbuf *
evas_outbuf_new(Evas_Engine_Info_Eglfs *info, int w, int h, Render_Engine_Swap_Mode swap_mode)
{
Outbuf *ob;
char *num;
if (!info) return NULL;
/* try to allocate space for outbuf */
if (!(ob = calloc(1, sizeof(Outbuf)))) return NULL;
win_count++;
ob->w = w;
ob->h = h;
ob->info = info;
ob->depth = info->info.depth;
ob->rotation = info->info.rotation;
ob->destination_alpha = info->info.destination_alpha;
ob->swap_mode = swap_mode;
ob->priv.num = 2;
if ((num = getenv("EVAS_EGLFS_BUFFERS")))
{
ob->priv.num = atoi(num);
if (ob->priv.num <= 0) ob->priv.num = 1;
else if (ob->priv.num > 4) ob->priv.num = 4;
}
if ((num = getenv("EVAS_EGLFS_VSYNC")))
ob->vsync = atoi(num);
if (!_evas_outbuf_egl_setup(ob))
{
evas_outbuf_free(ob);
return NULL;
}
return ob;
}
void
evas_outbuf_free(Outbuf *ob)
{
int ref = 0;
win_count--;
evas_outbuf_use(ob);
if (ob == _evas_eglfs_window) _evas_eglfs_window = NULL;
if (ob->gl_context)
{
ref = ob->gl_context->references - 1;
glsym_evas_gl_common_context_free(ob->gl_context);
}
eglMakeCurrent(ob->egl.disp, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
if (ob->egl.context[0] != context)
eglDestroyContext(ob->egl.disp, ob->egl.context[0]);
if (ob->egl.surface[0] != EGL_NO_SURFACE)
eglDestroySurface(ob->egl.disp, ob->egl.surface[0]);
if (ref == 0)
{
if (context) eglDestroyContext(ob->egl.disp, context);
eglTerminate(ob->egl.disp);
eglReleaseThread();
context = EGL_NO_CONTEXT;
}
free(ob);
}
void
evas_outbuf_use(Outbuf *ob)
{
Eina_Bool force = EINA_FALSE;
glsym_evas_gl_preload_render_lock(_evas_outbuf_make_current, ob);
if (_evas_eglfs_window)
{
if (eglGetCurrentContext() != _evas_eglfs_window->egl.context[0])
force = EINA_TRUE;
}
if ((_evas_eglfs_window != ob) || (force))
{
if (_evas_eglfs_window)
{
glsym_evas_gl_common_context_use(_evas_eglfs_window->gl_context);
glsym_evas_gl_common_context_flush(_evas_eglfs_window->gl_context);
}
_evas_eglfs_window = ob;
if (ob)
{
if (ob->egl.surface[0] != EGL_NO_SURFACE)
{
if (eglMakeCurrent(ob->egl.disp, ob->egl.surface[0],
ob->egl.surface[0],
ob->egl.context[0]) == EGL_FALSE)
ERR("eglMakeCurrent() failed!");
}
}
}
if (ob) glsym_evas_gl_common_context_use(ob->gl_context);
}
void
evas_outbuf_resurf(Outbuf *ob)
{
if (ob->surf) return;
if (getenv("EVAS_GL_INFO")) printf("resurf %p\n", ob);
ob->egl.surface[0] =
eglCreateWindowSurface(ob->egl.disp, ob->egl.config,
NULL, NULL);
if (ob->egl.surface[0] == EGL_NO_SURFACE)
{
ERR("eglCreateWindowSurface() fail for %p. code=%#x",
NULL, eglGetError());
return;
}
if (eglMakeCurrent(ob->egl.disp, ob->egl.surface[0], ob->egl.surface[0],
ob->egl.context[0]) == EGL_FALSE)
ERR("eglMakeCurrent() failed!");
ob->surf = EINA_TRUE;
}
void
evas_outbuf_unsurf(Outbuf *ob)
{
if (!ob->surf) return;
if (!getenv("EVAS_GL_WIN_RESURF")) return;
if (getenv("EVAS_GL_INFO")) printf("unsurf %p\n", ob);
if (_evas_eglfs_window)
glsym_evas_gl_common_context_flush(_evas_eglfs_window->gl_context);
if (_evas_eglfs_window == ob)
{
eglMakeCurrent(ob->egl.disp, EGL_NO_SURFACE,
EGL_NO_SURFACE, EGL_NO_CONTEXT);
if (ob->egl.surface[0] != EGL_NO_SURFACE)
eglDestroySurface(ob->egl.disp, ob->egl.surface[0]);
ob->egl.surface[0] = EGL_NO_SURFACE;
_evas_eglfs_window = NULL;
}
ob->surf = EINA_FALSE;
}
void
evas_outbuf_reconfigure(Outbuf *ob, int w, int h, int rot, Outbuf_Depth depth)
{
if (depth == OUTBUF_DEPTH_INHERIT) depth = ob->depth;
ob->w = w;
ob->h = h;
ob->depth = depth;
ob->rotation = rot;
evas_outbuf_use(ob);
glsym_evas_gl_common_context_resize(ob->gl_context, w, h, rot);
}
Render_Engine_Swap_Mode
evas_outbuf_buffer_state_get(Outbuf *ob)
{
return MODE_FULL;
// Forces re-rendering all the screen, that is bad for performance. However
// partial rendering makes black area. We should try to find a better solution.
}
int
evas_outbuf_rot_get(Outbuf *ob)
{
return ob->rotation;
}
Eina_Bool
evas_outbuf_update_region_first_rect(Outbuf *ob)
{
glsym_evas_gl_preload_render_lock(_evas_outbuf_make_current, ob);
evas_outbuf_use(ob);
if (!_re_wincheck(ob)) return EINA_TRUE;
glsym_evas_gl_common_context_flush(ob->gl_context);
glsym_evas_gl_common_context_newframe(ob->gl_context);
return EINA_FALSE;
}
void *
evas_outbuf_update_region_new(Outbuf *ob, int x, int y, int w, int h, int *cx EINA_UNUSED, int *cy EINA_UNUSED, int *cw EINA_UNUSED, int *ch EINA_UNUSED)
{
if ((w == ob->w) && (h == ob->h))
ob->gl_context->master_clip.enabled = EINA_FALSE;
else
{
ob->gl_context->master_clip.enabled = EINA_TRUE;
ob->gl_context->master_clip.x = x;
ob->gl_context->master_clip.y = y;
ob->gl_context->master_clip.w = w;
ob->gl_context->master_clip.h = h;
}
return ob->gl_context->def_surface;
}
void
evas_outbuf_update_region_push(Outbuf *ob, RGBA_Image *update EINA_UNUSED, int x EINA_UNUSED, int y EINA_UNUSED, int w EINA_UNUSED, int h EINA_UNUSED)
{
/* Is it really necessary to flush per region ? Shouldn't we be able to
still do that for the full canvas when doing partial update */
if (!_re_wincheck(ob)) return;
ob->drew = EINA_TRUE;
glsym_evas_gl_common_context_flush(ob->gl_context);
}
void
evas_outbuf_update_region_free(Outbuf *ob EINA_UNUSED, RGBA_Image *update EINA_UNUSED)
{
/* Nothing to do here as we don't really create an image per area */
}
void
evas_outbuf_flush(Outbuf *ob, Tilebuf_Rect *rects EINA_UNUSED, Evas_Render_Mode render_mode)
{
if (render_mode == EVAS_RENDER_MODE_ASYNC_INIT) goto end;
if (!_re_wincheck(ob)) goto end;
if (!ob->drew) goto end;
ob->drew = EINA_FALSE;
evas_outbuf_use(ob);
glsym_evas_gl_common_context_done(ob->gl_context);
if (!ob->vsync)
{
if (ob->info->info.vsync) eglSwapInterval(ob->egl.disp, 1);
else eglSwapInterval(ob->egl.disp, 0);
ob->vsync = 1;
}
if (ob->info->callback.pre_swap)
ob->info->callback.pre_swap(ob->info->callback.data, ob->evas);
eglSwapBuffers(ob->egl.disp, ob->egl.surface[0]);
if (ob->info->callback.post_swap)
ob->info->callback.post_swap(ob->info->callback.data, ob->evas);
ob->priv.frame_cnt++;
end:
glsym_evas_gl_preload_render_unlock(_evas_outbuf_make_current, ob);
}
Evas_Engine_GL_Context *
evas_outbuf_gl_context_get(Outbuf *ob)
{
return ob->gl_context;
}
void *
evas_outbuf_egl_display_get(Outbuf *ob)
{
return ob->egl.disp;
}
Context_3D *
evas_outbuf_gl_context_new(Outbuf *ob)
{
Context_3D *ctx;
int context_attrs[3] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
if (!ob) return NULL;
ctx = calloc(1, sizeof(Context_3D));
if (!ctx) return NULL;
ctx->context = eglCreateContext(ob->egl.disp, ob->egl.config,
ob->egl.context[0], context_attrs);
if (!ctx->context)
{
ERR("EGL context creation failed.");
goto error;
}
ctx->display = ob->egl.disp;
ctx->surface = ob->egl.surface[0];
return ctx;
error:
free(ctx);
return NULL;
}
void
evas_outbuf_gl_context_free(Context_3D *ctx)
{
eglDestroyContext(ctx->display, ctx->context);
free(ctx);
}
void
evas_outbuf_gl_context_use(Context_3D *ctx)
{
if (eglMakeCurrent(ctx->display, ctx->surface,
ctx->surface, ctx->context) == EGL_FALSE)
ERR("eglMakeCurrent() failed.");
}