[Mesa-dev] [PATCH v4 03/10] egl/tizen: add support of the swrast related features for tizen platform (v2)
Gwan-gyeong Mun
elongbug at gmail.com
Fri Oct 6 22:03:20 UTC 2017
It implements the egl swrast related features for tizen platform on platform_tizen.c
It works with libtpl-egl (Tizen Porting Layer for egl) and libtbm (Tizen Buffer Manager)
where back buffers of windows are backed by GEM objects. In Tizen a native window
has a queue (tbm_surface_queue) of back buffers allocated by the WL_TBM
(wayland client case, WL_TBM is abbreviation of wayland-tbm protocol) or gbm
(tizen has implements gbm with tbm) or tbm through tbm_backend.
For each frame, EGL needs to
dequeue the next back buffer - tizen_window_dequeue_buffer()
render to the buffer
enqueue the buffer - tizen_window_enqueue_buffer()
After enqueuing, the buffer is no longer valid to EGL.
v2:
- Fixes from Emil's review:
a) Add a treating of fail case on tizen_window_enqueue_buffer_with_damage()
b) Follow coding style
c) Remove unneeded compiler pragma
d) Use a stride helper for tizen_swrast_get_image()
e) Fix tizen_swrast_get_image() as drm platform's implementation
referenced commit: fe2a6281b3b299998fe7399e7dbcc2077d773824
f) Fix tizen_swrast_put_image2() as drm platform's implementation
referenced commit: 3a5e3aa5a53cff55a5e31766d713a41ffa5a93d7
g) Add tizen_add_configs_for_surface_type() helper function which removes
roundtrips.
h) Refactor for tizen_add_configs()
- Add image_image_lookup extension to tizen_swrast_loader_extensions
Referenced documents:
[1] https://www.x.org/wiki/Events/XDC2016/Program/XDC2016_Tizen_Window_System_EGL_Vulkan.pdf
[2] https://wiki.tizen.org/wiki/3.0_Porting_Guide/Graphics_and_UI/libtpl-egl
[3] https://wiki.tizen.org/wiki/TBM
Signed-off-by: Mun Gwan-gyeong <elongbug at gmail.com>
---
src/egl/Makefile.am | 6 +
src/egl/drivers/dri2/platform_tizen.c | 646 ++++++++++++++++++++++++++++++++++
2 files changed, 652 insertions(+)
create mode 100644 src/egl/drivers/dri2/platform_tizen.c
diff --git a/src/egl/Makefile.am b/src/egl/Makefile.am
index eeb745f973..648672998e 100644
--- a/src/egl/Makefile.am
+++ b/src/egl/Makefile.am
@@ -108,6 +108,12 @@ libEGL_common_la_LIBADD += $(ANDROID_LIBS)
dri2_backend_FILES += drivers/dri2/platform_android.c
endif
+if HAVE_PLATFORM_TIZEN
+AM_CFLAGS += $(TIZEN_CFLAGS)
+libEGL_common_la_LIBADD += $(TIZEN_LIBS)
+dri2_backend_FILES += drivers/dri2/platform_tizen.c
+endif
+
AM_CFLAGS += \
-I$(top_srcdir)/src/loader \
-I$(top_builddir)/src/egl/drivers/dri2 \
diff --git a/src/egl/drivers/dri2/platform_tizen.c b/src/egl/drivers/dri2/platform_tizen.c
new file mode 100644
index 0000000000..7cee03f784
--- /dev/null
+++ b/src/egl/drivers/dri2/platform_tizen.c
@@ -0,0 +1,646 @@
+/*
+ * Mesa 3-D graphics library
+ *
+ * Copyright (C) 2017 Samsung Electronics co., Ltd. All Rights Reserved
+ *
+ * Based on platform_android, which has
+ *
+ * Copyright (C) 2010-2011 Chia-I Wu <olvaffe at gmail.com>
+ * Copyright (C) 2010-2011 LunarG Inc.
+ * Copyright © 2011 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Gwan-gyeong Mun <elongbug at gmail.com>
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <xf86drm.h>
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "egl_dri2.h"
+#include "egl_dri2_fallbacks.h"
+#include "loader.h"
+
+static EGLBoolean
+tizen_window_dequeue_buffer(struct dri2_egl_surface *dri2_surf)
+{
+ int width, height;
+
+ dri2_surf->tbm_surface = tpl_surface_dequeue_buffer(dri2_surf->tpl_surface);
+
+ if (!dri2_surf->tbm_surface)
+ return EGL_FALSE;
+
+ tbm_surface_internal_ref(dri2_surf->tbm_surface);
+
+ tpl_surface_get_size(dri2_surf->tpl_surface, &width, &height);
+ if (dri2_surf->base.Width != width || dri2_surf->base.Height != height) {
+ dri2_surf->base.Width = width;
+ dri2_surf->base.Height = height;
+ }
+
+ return EGL_TRUE;
+}
+
+static EGLBoolean
+tizen_window_enqueue_buffer_with_damage(_EGLDisplay *disp,
+ struct dri2_egl_surface *dri2_surf,
+ const EGLint *rects,
+ EGLint n_rects)
+{
+ tpl_result_t ret;
+
+ /* To avoid blocking other EGL calls, release the display mutex before
+ * we enter tizen_window_enqueue_buffer() and re-acquire the mutex upon
+ * return.
+ */
+ mtx_unlock(&disp->Mutex);
+
+ if (n_rects < 1 || rects == NULL) {
+ /* if there is no damage, call the normal API tpl_surface_enqueue_buffer */
+ ret = tpl_surface_enqueue_buffer(dri2_surf->tpl_surface,
+ dri2_surf->tbm_surface);
+ } else {
+ /* if there are rectangles of damage region,
+ call the API tpl_surface_enqueue_buffer_with_damage() */
+ ret = tpl_surface_enqueue_buffer_with_damage(dri2_surf->tpl_surface,
+ dri2_surf->tbm_surface,
+ n_rects, rects);
+ }
+
+ if (ret != TPL_ERROR_NONE) {
+ _eglLog(_EGL_WARNING, "%s : %d :tpl_surface_enqueue fail", __func__, __LINE__);
+ goto cleanup;
+ }
+
+ tbm_surface_internal_unref(dri2_surf->tbm_surface);
+ dri2_surf->tbm_surface = NULL;
+
+ mtx_lock(&disp->Mutex);
+
+ return EGL_TRUE;
+
+cleanup:
+ tbm_surface_internal_unref(dri2_surf->tbm_surface);
+ dri2_surf->tbm_surface = NULL;
+ mtx_lock(&disp->Mutex);
+
+ return EGL_FALSE;
+}
+
+static EGLBoolean
+tizen_window_enqueue_buffer(_EGLDisplay *disp, struct dri2_egl_surface *dri2_surf)
+{
+ return tizen_window_enqueue_buffer_with_damage(disp, dri2_surf, NULL, 0);
+}
+
+static void
+tizen_window_cancel_buffer(_EGLDisplay *disp, struct dri2_egl_surface *dri2_surf)
+{
+ tizen_window_enqueue_buffer(disp, dri2_surf);
+}
+
+static _EGLSurface *
+tizen_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
+ _EGLConfig *conf, void *native_window,
+ const EGLint *attrib_list)
+{
+ __DRIcreateNewDrawableFunc createNewDrawable;
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+ struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
+ struct dri2_egl_surface *dri2_surf;
+ const __DRIconfig *config;
+ tpl_surface_type_t tpl_surf_type = TPL_SURFACE_ERROR;
+ tpl_result_t ret = TPL_ERROR_INVALID_PARAMETER;
+
+ dri2_surf = calloc(1, sizeof *dri2_surf);
+ if (!dri2_surf) {
+ _eglError(EGL_BAD_ALLOC, "tizen_create_surface");
+ return NULL;
+ }
+
+ if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
+ goto cleanup_surface;
+
+ config = dri2_get_dri_config(dri2_conf, type,
+ dri2_surf->base.GLColorspace);
+ if (!config)
+ goto cleanup_surface;
+
+ if (type == EGL_WINDOW_BIT) {
+ unsigned int alpha, depth;
+
+ if (!native_window) {
+ _eglError(EGL_BAD_NATIVE_WINDOW, "tizen_create_surface needs vaild native window");
+ goto cleanup_surface;
+ }
+ dri2_surf->native_win = native_window;
+
+ dri2_dpy->core->getConfigAttrib(config, __DRI_ATTRIB_DEPTH_SIZE, &depth);
+ dri2_dpy->core->getConfigAttrib(config, __DRI_ATTRIB_ALPHA_SIZE, &alpha);
+
+ ret = tpl_display_get_native_window_info(dri2_dpy->tpl_display,
+ (tpl_handle_t)native_window,
+ &dri2_surf->base.Width,
+ &dri2_surf->base.Height,
+ &dri2_surf->tbm_format,
+ depth, alpha);
+
+ if (ret != TPL_ERROR_NONE || dri2_surf->tbm_format == 0) {
+ _eglError(EGL_BAD_NATIVE_WINDOW, "tizen_create_surface fails on tpl_display_get_native_window_info()");
+ goto cleanup_surface;
+ }
+
+ tpl_surf_type = TPL_SURFACE_TYPE_WINDOW;
+ } else if (type == EGL_PIXMAP_BIT) {
+
+ if (!native_window) {
+ _eglError(EGL_BAD_NATIVE_PIXMAP, "tizen_create_surface needs valid native pixmap");
+ goto cleanup_surface;
+ }
+ ret = tpl_display_get_native_pixmap_info(dri2_dpy->tpl_display,
+ (tpl_handle_t)native_window,
+ &dri2_surf->base.Width,
+ &dri2_surf->base.Height,
+ &dri2_surf->tbm_format);
+
+ if (ret != TPL_ERROR_NONE || dri2_surf->tbm_format == 0) {
+ _eglError(EGL_BAD_NATIVE_PIXMAP, "tizen_create_surface fails on tpl_display_get_native_pixmap_info");
+ goto cleanup_surface;
+ }
+
+ tpl_surf_type = TPL_SURFACE_TYPE_PIXMAP;
+ } else {
+ _eglError(EGL_BAD_NATIVE_WINDOW, "tizen_create_surface does not support PBuffer");
+ goto cleanup_surface;
+ }
+
+ dri2_surf->tpl_surface = tpl_surface_create(dri2_dpy->tpl_display,
+ (tpl_handle_t)native_window,
+ tpl_surf_type,
+ dri2_surf->tbm_format);
+ if (!dri2_surf->tpl_surface)
+ goto cleanup_surface;
+
+ createNewDrawable = dri2_dpy->swrast->createNewDrawable;
+
+ dri2_surf->dri_drawable = (*createNewDrawable)(dri2_dpy->dri_screen, config,
+ dri2_surf);
+ if (dri2_surf->dri_drawable == NULL) {
+ _eglError(EGL_BAD_ALLOC, "createNewDrawable");
+ goto cleanup_tpl_surface;
+ }
+
+ return &dri2_surf->base;
+
+cleanup_tpl_surface:
+ tpl_object_unreference((tpl_object_t *)dri2_surf->tpl_surface);
+cleanup_surface:
+ free(dri2_surf);
+
+ return NULL;
+}
+
+static _EGLSurface *
+tizen_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
+ _EGLConfig *conf, void *native_window,
+ const EGLint *attrib_list)
+{
+ return tizen_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
+ native_window, attrib_list);
+}
+
+static _EGLSurface *
+tizen_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
+ _EGLConfig *conf, void *native_pixmap,
+ const EGLint *attrib_list)
+{
+ return tizen_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
+ native_pixmap, attrib_list);
+}
+
+static EGLBoolean
+tizen_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
+{
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+ struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
+
+ if (dri2_surf->base.Type == EGL_WINDOW_BIT && dri2_surf->tbm_surface)
+ tizen_window_cancel_buffer(disp, dri2_surf);
+
+ dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
+
+ tpl_object_unreference((tpl_object_t *)dri2_surf->tpl_surface);
+
+ free(dri2_surf);
+
+ return EGL_TRUE;
+}
+
+static int
+update_buffers(struct dri2_egl_surface *dri2_surf)
+{
+ if (dri2_surf->base.Type != EGL_WINDOW_BIT)
+ return 0;
+
+ /* try to dequeue the next back buffer */
+ if (!dri2_surf->tbm_surface && !tizen_window_dequeue_buffer(dri2_surf)) {
+ _eglLog(_EGL_WARNING, "Could not dequeue buffer from native window");
+ return -1;
+ }
+
+ return 0;
+}
+
+static EGLBoolean
+tizen_swap_buffers_with_damage(_EGLDriver *drv, _EGLDisplay *disp,
+ _EGLSurface *draw, const EGLint *rects,
+ EGLint n_rects)
+{
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+ struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
+
+ if (dri2_surf->base.Type != EGL_WINDOW_BIT)
+ return EGL_TRUE;
+
+ if (dri2_surf->tbm_surface)
+ tizen_window_enqueue_buffer_with_damage(disp, dri2_surf, rects, n_rects);
+
+ dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable);
+
+ return EGL_TRUE;
+}
+
+static EGLBoolean
+tizen_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
+{
+ return tizen_swap_buffers_with_damage (drv, disp, draw, NULL, 0);
+}
+
+static EGLBoolean
+tizen_query_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
+ EGLint attribute, EGLint *value)
+{
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
+ struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
+ int width = 0, height = 0;
+
+ if (dri2_surf->base.Type == EGL_WINDOW_BIT && dri2_surf->native_win) {
+ if (tpl_display_get_native_window_info(dri2_dpy->tpl_display,
+ dri2_surf->native_win,
+ &width, &height,
+ NULL, 0, 0) != TPL_ERROR_NONE)
+ return EGL_FALSE;
+
+ switch (attribute) {
+ case EGL_WIDTH:
+ *value = width;
+ return EGL_TRUE;
+ case EGL_HEIGHT:
+ *value = height;
+ return EGL_TRUE;
+ default:
+ break;
+ }
+ }
+
+ return _eglQuerySurface(drv, dpy, surf, attribute, value);
+}
+
+static int
+tizen_swrast_get_stride_for_format(tbm_format format, int w)
+{
+ switch (format) {
+ case TBM_FORMAT_RGB565:
+ return 2 * w;
+ case TBM_FORMAT_BGRA8888:
+ case TBM_FORMAT_RGBA8888:
+ case TBM_FORMAT_RGBX8888:
+ default:
+ return 4 * w;
+ }
+}
+
+static void
+tizen_swrast_get_drawable_info(__DRIdrawable * draw,
+ int *x, int *y, int *w, int *h,
+ void *loaderPrivate)
+{
+ struct dri2_egl_surface *dri2_surf = loaderPrivate;
+
+ if (update_buffers(dri2_surf) < 0)
+ return;
+
+ *x = 0;
+ *y = 0;
+ *w = dri2_surf->base.Width;
+ *h = dri2_surf->base.Height;
+}
+
+static void
+tizen_swrast_get_image(__DRIdrawable * read,
+ int x, int y, int w, int h,
+ char *data, void *loaderPrivate)
+{
+ struct dri2_egl_surface *dri2_surf = loaderPrivate;
+ tbm_surface_info_s surf_info;
+ int ret = TBM_SURFACE_ERROR_NONE;
+ int internal_stride, stride, i;
+ int x_bytes, w_bytes;
+ char *src, *dst;
+
+ if (update_buffers(dri2_surf) < 0)
+ return;
+
+ ret = tbm_surface_map(dri2_surf->tbm_surface, TBM_SURF_OPTION_READ, &surf_info);
+
+ if (ret != TBM_SURFACE_ERROR_NONE) {
+ _eglLog(_EGL_WARNING, "Could not tbm_surface_map");
+ return;
+ }
+
+ x_bytes = tizen_swrast_get_stride_for_format(dri2_surf->tbm_format, x);
+ w_bytes = tizen_swrast_get_stride_for_format(dri2_surf->tbm_format, w);
+ internal_stride = surf_info.planes[0].stride;
+ stride = w_bytes;
+
+ dst = data;
+ src = (char*)surf_info.planes[0].ptr + x_bytes + (y * internal_stride);
+
+ for (i = 0; i < h; i++) {
+ memcpy(dst, src, w_bytes);
+ dst += stride;
+ src += internal_stride;
+ }
+
+ tbm_surface_unmap(dri2_surf->tbm_surface);
+}
+
+static void
+tizen_swrast_put_image2(__DRIdrawable * draw, int op,
+ int x, int y, int w, int h, int stride,
+ char *data, void *loaderPrivate)
+{
+ struct dri2_egl_surface *dri2_surf = loaderPrivate;
+ tbm_surface_info_s surf_info;
+ int ret = TBM_SURFACE_ERROR_NONE;
+ int internal_stride, i;
+ int x_bytes, w_bytes;
+ char *src, *dst;
+
+ if (op != __DRI_SWRAST_IMAGE_OP_DRAW && op != __DRI_SWRAST_IMAGE_OP_SWAP)
+ return;
+
+ if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
+ if (update_buffers(dri2_surf) < 0) {
+ _eglLog(_EGL_WARNING, "Could not get native buffer");
+ return;
+ }
+
+ ret = tbm_surface_map(dri2_surf->tbm_surface, TBM_SURF_OPTION_WRITE, &surf_info);
+ if (ret != TBM_SURFACE_ERROR_NONE) {
+ _eglLog(_EGL_WARNING, "Could not tbm_surface_map");
+ return;
+ }
+
+ x_bytes = tizen_swrast_get_stride_for_format(dri2_surf->tbm_format, x);
+ w_bytes = tizen_swrast_get_stride_for_format(dri2_surf->tbm_format, w);
+ internal_stride = surf_info.planes[0].stride;
+
+ dst = (char*)surf_info.planes[0].ptr + x_bytes + (y * internal_stride);
+ src = data;
+
+ for (i = 0; i < h; i++) {
+ memcpy(dst, src, w_bytes);
+ dst += internal_stride;
+ src += stride;
+ }
+
+ tbm_surface_unmap(dri2_surf->tbm_surface);
+ }
+}
+
+static void
+tizen_swrast_put_image(__DRIdrawable * draw, int op,
+ int x, int y, int w, int h,
+ char *data, void *loaderPrivate)
+{
+ struct dri2_egl_surface *dri2_surf = loaderPrivate;
+ int stride;
+
+ if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
+ if (update_buffers(dri2_surf) < 0) {
+ _eglLog(_EGL_WARNING, "Could not get native buffer");
+ return;
+ }
+
+ stride = tizen_swrast_get_stride_for_format(dri2_surf->tbm_format, w);
+ tizen_swrast_put_image2(draw, op, x, y, w, h, stride, data, loaderPrivate);
+ }
+}
+
+static int
+tizen_add_configs_for_surface_type(_EGLDisplay *dpy, int surface_type,
+ int *idx, int cfg_cnt)
+{
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
+ tpl_surface_type_t tpl_surface_type;
+ static const struct {
+ unsigned int rgba_masks[4];
+ struct {
+ unsigned alpha;
+ unsigned red;
+ unsigned green;
+ unsigned blue;
+ } size;
+ } visuals[] = {
+ { { 0xff0000, 0xff00, 0x00ff, 0xff000000 }, { 0, 8, 8, 8 } },
+ { { 0xff0000, 0xff00, 0x00ff, 0 }, { 8, 8, 8, 8 } },
+ };
+ int i;
+
+ if (surface_type == EGL_WINDOW_BIT)
+ tpl_surface_type = TPL_SURFACE_TYPE_WINDOW;
+ else if (surface_type == EGL_PIXMAP_BIT)
+ tpl_surface_type = TPL_SURFACE_TYPE_PIXMAP;
+ else {
+ _eglLog(_EGL_WARNING, "Not surpported Surface Type: %d", surface_type);
+ return cfg_cnt;
+ }
+
+ for (i = *idx; dri2_dpy->driver_configs[i]; i++) {
+ for (int j = 0; j < ARRAY_SIZE(visuals); j++) {
+ struct dri2_egl_config *dri2_conf;
+ unsigned int depth = 32;
+ tpl_bool_t is_slow;
+ EGLint config_attrs[] = {
+ EGL_NATIVE_VISUAL_ID, 0,
+ EGL_NONE,
+ };
+ tpl_result_t res;
+
+ res = tpl_display_query_config(dri2_dpy->tpl_display, tpl_surface_type,
+ visuals[j].size.red, visuals[j].size.green,
+ visuals[j].size.blue, visuals[j].size.alpha,
+ depth, &config_attrs[1], &is_slow);
+
+ if (res != TPL_ERROR_NONE)
+ continue;
+
+ dri2_conf = dri2_add_config(dpy, dri2_dpy->driver_configs[i],
+ cfg_cnt + 1, surface_type, config_attrs,
+ visuals[j].rgba_masks);
+
+ if (dri2_conf && (dri2_conf->base.ConfigID == cfg_cnt + 1))
+ cfg_cnt++;
+ }
+ }
+
+ *idx = i;
+ return cfg_cnt;
+}
+
+static EGLBoolean
+tizen_add_configs(_EGLDriver *drv, _EGLDisplay *dpy)
+{
+ int idx = 0;
+ int cfg_cnt = 0;
+
+ cfg_cnt = tizen_add_configs_for_surface_type(dpy, EGL_WINDOW_BIT, &idx, cfg_cnt);
+ cfg_cnt = tizen_add_configs_for_surface_type(dpy, EGL_PIXMAP_BIT, &idx, cfg_cnt);
+
+ return (cfg_cnt != 0);
+}
+
+static const struct dri2_egl_display_vtbl tizen_display_vtbl = {
+ .authenticate = NULL,
+ .create_window_surface = tizen_create_window_surface,
+ .create_pixmap_surface = tizen_create_pixmap_surface,
+ .create_pbuffer_surface = dri2_fallback_create_pbuffer_surface,
+ .destroy_surface = tizen_destroy_surface,
+ .create_image = dri2_create_image_khr,
+ .swap_buffers = tizen_swap_buffers,
+ .swap_buffers_with_damage = tizen_swap_buffers_with_damage,
+ .swap_buffers_region = dri2_fallback_swap_buffers_region,
+ .post_sub_buffer = dri2_fallback_post_sub_buffer,
+ .copy_buffers = dri2_fallback_copy_buffers,
+ .query_buffer_age = dri2_fallback_query_buffer_age,
+ .query_surface = tizen_query_surface,
+ .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
+ .get_sync_values = dri2_fallback_get_sync_values,
+ .get_dri_drawable = dri2_surface_get_dri_drawable,
+};
+
+static const __DRIswrastLoaderExtension tizen_swrast_loader_extension = {
+ .base = { __DRI_SWRAST_LOADER, 2 },
+
+ .getDrawableInfo = tizen_swrast_get_drawable_info,
+ .putImage = tizen_swrast_put_image,
+ .getImage = tizen_swrast_get_image,
+ .putImage2 = tizen_swrast_put_image2,
+};
+
+static const __DRIextension *tizen_swrast_loader_extensions[] = {
+ &tizen_swrast_loader_extension.base,
+ &image_lookup_extension.base,
+ NULL,
+};
+
+EGLBoolean
+dri2_initialize_tizen(_EGLDriver *drv, _EGLDisplay *dpy)
+{
+ struct dri2_egl_display *dri2_dpy;
+ tpl_display_t *tpl_display = NULL;
+ const char *err;
+ int tbm_bufmgr_fd = -1;
+
+ loader_set_logger(_eglLog);
+
+ dri2_dpy = calloc(1, sizeof *dri2_dpy);
+ if (!dri2_dpy)
+ return _eglError(EGL_BAD_ALLOC, "eglInitialize");
+
+ dri2_dpy->fd = -1;
+ dpy->DriverData = (void *) dri2_dpy;
+
+ /* The TPL_BACKEND_UNKNOWN type for tpl_display decides the tpl's "Display Backend"
+ * as a PlatformDiplay at runtime.
+ */
+ tpl_display = tpl_display_create(TPL_BACKEND_UNKNOWN, dpy->PlatformDisplay);
+ if (!tpl_display) {
+ err = "DRI2: failed to create tpl_display";
+ goto cleanup;
+ }
+ dri2_dpy->tpl_display = tpl_display;
+
+ /* Get tbm_bufmgr's fd */
+ tbm_bufmgr_fd = tbm_drm_helper_get_fd();
+
+ if (tbm_bufmgr_fd == -1) {
+ err = "DRI2: failed to get tbm_bufmgr fd";
+ goto cleanup;
+ }
+
+ dri2_dpy->fd = tbm_bufmgr_fd;
+ dri2_dpy->driver_name = strdup("swrast");
+ if (!dri2_load_driver_swrast(dpy)) {
+ err = "DRI2: failed to load swrast driver";
+ goto cleanup;
+ }
+ dri2_dpy->loader_extensions = tizen_swrast_loader_extensions;
+
+ if (!dri2_create_screen(dpy)) {
+ err = "DRI2: failed to create screen";
+ goto cleanup;
+ }
+
+ if (!dri2_setup_extensions(dpy)) {
+ err = "DRI2: failed to setup extensions";
+ goto cleanup;
+ }
+
+ dri2_setup_screen(dpy);
+
+ if (!tizen_add_configs(drv, dpy)) {
+ err = "DRI2: failed to add configs";
+ goto cleanup;
+ }
+
+ /* Fill vtbl last to prevent accidentally calling virtual function during
+ * initialization.
+ */
+ dri2_dpy->vtbl = &tizen_display_vtbl;
+
+ return EGL_TRUE;
+
+cleanup:
+ dri2_display_destroy(dpy);
+
+ return _eglError(EGL_NOT_INITIALIZED, err);
+}
--
2.14.2
More information about the mesa-dev
mailing list