+++ /dev/null
-From 1995ec08267c8063ca72590e700c8612b04a63b5 Mon Sep 17 00:00:00 2001
-From: Meng Mingming <mingming.meng@nxp.com>
-Date: Mon, 16 Jan 2017 10:15:02 +0800
-Subject: [PATCH 2/5] MGS-2521 [#ccc] Enable g2d-renderer for weston 1.11
-
-Enable g2d-renderer for weston 1.11
-weston-start -- --use-g2d=1(--use-gl=1) $OPTARGS
-
-Upstream Status: Inappropriate [i.MX specific]
-
-Date: Jan 16, 2017
-Signed-off-by: Meng Mingming <mingming.meng@nxp.com>
----
- Makefile.am | 16 +
- src/compositor-fbdev.c | 66 ++-
- src/compositor-fbdev.h | 1 +
- src/g2d-renderer.c | 1317 ++++++++++++++++++++++++++++++++++++++++++++++++
- src/g2d-renderer.h | 47 ++
- src/main.c | 6 +-
- 6 files changed, 1448 insertions(+), 5 deletions(-)
- create mode 100644 src/g2d-renderer.c
- create mode 100644 src/g2d-renderer.h
-
-diff --git a/Makefile.am b/Makefile.am
-index 00b74e5..a044b64 100644
---- a/Makefile.am
-+++ b/Makefile.am
-@@ -248,6 +248,22 @@ gl_renderer_la_SOURCES = \
- shared/helpers.h
- endif
-
-+module_LTLIBRARIES += g2d-renderer.la
-+g2d_renderer_la_LDFLAGS = -module -avoid-version
-+g2d_renderer_la_LIBADD = $(COMPOSITOR_LIBS) $(EGL_LIBS) -lg2d
-+g2d_renderer_la_CFLAGS = \
-+ $(COMPOSITOR_CFLAGS) \
-+ $(EGL_CFLAGS) \
-+ $(GCC_CFLAGS) -DHAVE_G2D
-+g2d_renderer_la_SOURCES = \
-+ src/g2d-renderer.h \
-+ src/g2d-renderer.c \
-+ src/vertex-clipping.c \
-+ src/vertex-clipping.h
-+if ENABLE_EGL
-+g2d_renderer_la_CFLAGS += -DENABLE_EGL
-+endif
-+
- if ENABLE_X11_COMPOSITOR
- module_LTLIBRARIES += x11-backend.la
- x11_backend_la_LDFLAGS = -module -avoid-version
-diff --git a/src/compositor-fbdev.c b/src/compositor-fbdev.c
-index 06f4696..cff9513 100644
---- a/src/compositor-fbdev.c
-+++ b/src/compositor-fbdev.c
-@@ -50,6 +50,7 @@
- #include "libinput-seat.h"
- #include "gl-renderer.h"
- #include "presentation-time-server-protocol.h"
-+#include "g2d-renderer.h"
-
- struct fbdev_backend {
- struct weston_backend base;
-@@ -59,6 +60,7 @@ struct fbdev_backend {
- struct udev *udev;
- struct udev_input input;
- int use_pixman;
-+ int use_g2d;
- uint32_t output_transform;
- struct wl_listener session_listener;
- NativeDisplayType display;
-@@ -100,6 +102,7 @@ struct fbdev_output {
- };
-
- struct gl_renderer_interface *gl_renderer;
-+struct g2d_renderer_interface *g2d_renderer;
-
- static const char default_seat[] = "seat0";
-
-@@ -516,6 +519,14 @@ fbdev_output_create(struct fbdev_backend *backend,
- if (backend->use_pixman) {
- if (pixman_renderer_output_create(&output->base) < 0)
- goto out_hw_surface;
-+ } else if(backend->use_g2d) {
-+ const char *g2d_device = device;
-+
-+ if (g2d_renderer->output_create(&output->base,
-+ backend->compositor->wl_display, g2d_device) < 0) {
-+ weston_log("g2d_renderer_output_create failed.\n");
-+ goto out_hw_surface;
-+ }
- } else {
- setenv("HYBRIS_EGLPLATFORM", "wayland", 1);
- output->window = fbCreateWindow(backend->display, -1, -1, 0, 0);
-@@ -571,6 +582,8 @@ fbdev_output_destroy(struct weston_output *base)
- if (backend->use_pixman) {
- if (base->renderer_state != NULL)
- pixman_renderer_output_destroy(base);
-+ } else if(backend->use_g2d) {
-+ g2d_renderer->output_destroy(base);
- } else {
- gl_renderer->output_destroy(base);
- }
-@@ -782,7 +795,8 @@ fbdev_backend_create(struct weston_compositor *compositor, int *argc, char *argv
- backend->base.restore = fbdev_restore;
-
- backend->prev_state = WESTON_COMPOSITOR_ACTIVE;
-- backend->use_pixman = !param->use_gl;
-+ backend->use_pixman = !(param->use_gl || param->use_g2d);
-+ backend->use_g2d = param->use_g2d;
- backend->output_transform = param->output_transform;
-
- weston_setup_vt_switch_bindings(compositor);
-@@ -790,6 +804,46 @@ fbdev_backend_create(struct weston_compositor *compositor, int *argc, char *argv
- if (backend->use_pixman) {
- if (pixman_renderer_init(compositor) < 0)
- goto out_launcher;
-+ } else if(backend->use_g2d) {
-+ int x = 0, y = 0;
-+ int i=0;
-+ int count = 0;
-+ int k=0, dispCount = 0;
-+ char displays[5][32];
-+ g2d_renderer = weston_load_module("g2d-renderer.so",
-+ "g2d_renderer_interface");
-+ if (!g2d_renderer) {
-+ weston_log("could not load g2d renderer\n");
-+ goto out_launcher;
-+ }
-+
-+ if (g2d_renderer->create(backend->compositor) < 0) {
-+ weston_log("g2d_renderer_create failed.\n");
-+ goto out_launcher;
-+ }
-+
-+ weston_log("param->device=%s\n",param->device);
-+ count = strlen(param->device);
-+
-+ for(i= 0; i < count; i++) {
-+ if(param->device[i] == ',') {
-+ displays[dispCount][k] = '\0';
-+ dispCount++;
-+ k = 0;
-+ continue;
-+ }
-+ displays[dispCount][k++] = param->device[i];
-+ }
-+ displays[dispCount][k] = '\0';
-+ dispCount++;
-+
-+ for(i= 0; i < dispCount; i++){
-+ if (fbdev_output_create(backend, x, y, displays[i]) < 0)
-+ goto out_launcher;
-+ x += container_of(backend->compositor->output_list.prev,
-+ struct weston_output,
-+ link)->width;
-+ }
- } else {
- gl_renderer = weston_load_module("gl-renderer.so",
- "gl_renderer_interface");
-@@ -811,7 +865,8 @@ fbdev_backend_create(struct weston_compositor *compositor, int *argc, char *argv
- goto out_launcher;
- }
- }
-- if (fbdev_output_create(backend, 0, 0, param->device) < 0)
-+ if(!backend->use_g2d)
-+ if (fbdev_output_create(backend, 0, 0, param->device) < 0)
- goto out_launcher;
-
- udev_input_init(&backend->input, compositor, backend->udev, seat_id);
-@@ -840,6 +895,7 @@ config_init_to_defaults(struct weston_fbdev_backend_config *config)
- config->tty = 0; /* default to current tty */
- config->device = "/dev/fb0"; /* default frame buffer */
- config->use_gl = 0;
-+ config->use_g2d = 0;
- config->output_transform = WL_OUTPUT_TRANSFORM_NORMAL;
- }
-
-@@ -861,7 +917,11 @@ backend_init(struct weston_compositor *compositor, int *argc, char *argv[],
- config_init_to_defaults(&config);
- memcpy(&config, config_base, config_base->struct_size);
-
-- config.use_gl = 1;
-+ if(config.use_g2d) {
-+ config.use_gl = 0;
-+ } else {
-+ config.use_gl = 1;
-+ }
-
- b = fbdev_backend_create(compositor, argc, argv, wc, &config);
- if (b == NULL)
-diff --git a/src/compositor-fbdev.h b/src/compositor-fbdev.h
-index bd60bdc..32a8598 100644
---- a/src/compositor-fbdev.h
-+++ b/src/compositor-fbdev.h
-@@ -40,6 +40,7 @@ struct weston_fbdev_backend_config {
- int tty;
- char *device;
- int use_gl;
-+ int use_g2d;
-
- uint32_t output_transform;
- };
-diff --git a/src/g2d-renderer.c b/src/g2d-renderer.c
-new file mode 100644
-index 0000000..c30aa62
---- /dev/null
-+++ b/src/g2d-renderer.c
-@@ -0,0 +1,1317 @@
-+/*
-+ * Copyright (c) 2016 Freescale Semiconductor, Inc.
-+ * Copyright © 2012 Intel Corporation
-+ * Copyright © 2015 Collabora, Ltd.
-+ *
-+ * 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.
-+ */
-+
-+#define _GNU_SOURCE
-+
-+#include <stdlib.h>
-+#include <string.h>
-+#include <ctype.h>
-+#include <float.h>
-+#include <assert.h>
-+#include <pthread.h>
-+#include <linux/fb.h>
-+#include <sys/ioctl.h>
-+#include <fcntl.h>
-+#include <unistd.h>
-+#include <g2dExt.h>
-+#include <HAL/gc_hal_eglplatform.h>
-+
-+#include "compositor.h"
-+#include "g2d-renderer.h"
-+#include "vertex-clipping.h"
-+#include "shared/helpers.h"
-+
-+#define BUFFER_DAMAGE_COUNT 2
-+#define ALIGN_WIDTH(a) (((a) + 15) & ~15)
-+
-+struct wl_viv_buffer
-+{
-+ struct wl_resource *resource;
-+ gcoSURF surface;
-+ gctINT32 width;
-+ gctINT32 height;
-+ gctINT32 format;
-+ gctUINT alignedWidth;
-+ gctUINT alignedHeight;
-+ gctUINT32 physical[3];
-+ gctUINT32 gpuBaseAddr;
-+ gceTILING tiling;
-+};
-+
-+typedef struct _g2dRECT
-+{
-+ int left;
-+ int top;
-+ int right;
-+ int bottom;
-+} g2dRECT;
-+
-+struct fb_screeninfo {
-+ struct fb_var_screeninfo varinfo;
-+ struct fb_fix_screeninfo fixinfo;
-+ unsigned int x_resolution;
-+ unsigned int y_resolution;
-+ size_t buffer_length; /* length of frame buffer memory in bytes */
-+ size_t physical;
-+ size_t stride;
-+ size_t stride_bytes;
-+ enum g2d_format pixel_format; /* frame buffer pixel format */
-+ int fb_fd;
-+};
-+
-+struct g2d_output_state {
-+ int current_buffer;
-+ pixman_region32_t buffer_damage[BUFFER_DAMAGE_COUNT];
-+ struct g2d_surfaceEx *renderSurf;
-+ int nNumBuffers;
-+ int activebuffer;
-+ struct g2d_surfaceEx offscreenSurface;
-+ struct g2d_buf *offscreen_buf;
-+ struct fb_screeninfo fb_info;
-+ struct fb_screeninfo *mirror_fb_info;
-+ struct g2d_surfaceEx *mirrorSurf;
-+ int directBlit;
-+ int clone_display_num;
-+ int width;
-+ int height;
-+};
-+
-+struct g2d_surface_state {
-+ float color[4];
-+ struct weston_buffer_reference buffer_ref;
-+ int pitch; /* in pixels */
-+ int attached;
-+ pixman_region32_t texture_damage;
-+ struct g2d_surfaceEx g2d_surface;
-+ struct g2d_buf *shm_buf;
-+ int shm_buf_length;
-+ int bpp;
-+
-+ struct weston_surface *surface;
-+ struct wl_listener surface_destroy_listener;
-+ struct wl_listener renderer_destroy_listener;
-+};
-+
-+struct g2d_renderer {
-+ struct weston_renderer base;
-+ struct wl_signal destroy_signal;
-+#ifdef ENABLE_EGL
-+ NativeDisplayType display;
-+ EGLDisplay egl_display;
-+ struct wl_display *wl_display;
-+#endif
-+ void *handle;
-+};
-+
-+static int
-+g2d_renderer_create_surface(struct weston_surface *surface);
-+
-+static inline struct g2d_surface_state *
-+get_surface_state(struct weston_surface *surface)
-+{
-+ if (!surface->renderer_state)
-+ g2d_renderer_create_surface(surface);
-+ return (struct g2d_surface_state *)surface->renderer_state;
-+}
-+
-+static inline struct g2d_renderer *
-+get_renderer(struct weston_compositor *ec)
-+{
-+ return (struct g2d_renderer *)ec->renderer;
-+}
-+
-+#define max(a, b) (((a) > (b)) ? (a) : (b))
-+#define min(a, b) (((a) > (b)) ? (b) : (a))
-+/*
-+ * Compute the boundary vertices of the intersection of the global coordinate
-+ * aligned rectangle 'rect', and an arbitrary quadrilateral produced from
-+ * 'surf_rect' when transformed from surface coordinates into global coordinates.
-+ * The vertices are written to 'ex' and 'ey', and the return value is the
-+ * number of vertices. Vertices are produced in clockwise winding order.
-+ * Guarantees to produce either zero vertices, or 3-8 vertices with non-zero
-+ * polygon area.
-+ */
-+static int
-+calculate_edges(struct weston_view *ev, pixman_box32_t *rect,
-+ pixman_box32_t *surf_rect, float *ex, float *ey)
-+{
-+
-+ struct clip_context ctx;
-+ int i, n;
-+ float min_x, max_x, min_y, max_y;
-+ struct polygon8 surf = {
-+ { surf_rect->x1, surf_rect->x2, surf_rect->x2, surf_rect->x1 },
-+ { surf_rect->y1, surf_rect->y1, surf_rect->y2, surf_rect->y2 },
-+ 4
-+ };
-+
-+ ctx.clip.x1 = rect->x1;
-+ ctx.clip.y1 = rect->y1;
-+ ctx.clip.x2 = rect->x2;
-+ ctx.clip.y2 = rect->y2;
-+
-+ /* transform surface to screen space: */
-+ for (i = 0; i < surf.n; i++)
-+ weston_view_to_global_float(ev, surf.x[i], surf.y[i],
-+ &surf.x[i], &surf.y[i]);
-+
-+ /* find bounding box: */
-+ min_x = max_x = surf.x[0];
-+ min_y = max_y = surf.y[0];
-+
-+ for (i = 1; i < surf.n; i++) {
-+ min_x = min(min_x, surf.x[i]);
-+ max_x = max(max_x, surf.x[i]);
-+ min_y = min(min_y, surf.y[i]);
-+ max_y = max(max_y, surf.y[i]);
-+ }
-+
-+ /* First, simple bounding box check to discard early transformed
-+ * surface rects that do not intersect with the clip region:
-+ */
-+ if ((min_x >= ctx.clip.x2) || (max_x <= ctx.clip.x1) ||
-+ (min_y >= ctx.clip.y2) || (max_y <= ctx.clip.y1))
-+ return 0;
-+
-+ /* Simple case, bounding box edges are parallel to surface edges,
-+ * there will be only four edges. We just need to clip the surface
-+ * vertices to the clip rect bounds:
-+ */
-+ if (!ev->transform.enabled)
-+ return clip_simple(&ctx, &surf, ex, ey);
-+
-+ /* Transformed case: use a general polygon clipping algorithm to
-+ * clip the surface rectangle with each side of 'rect'.
-+ * The algorithm is Sutherland-Hodgman, as explained in
-+ * http://www.codeguru.com/cpp/misc/misc/graphics/article.php/c8965/Polygon-Clipping.htm
-+ * but without looking at any of that code.
-+ */
-+ n = clip_transformed(&ctx, &surf, ex, ey);
-+
-+ if (n < 3)
-+ return 0;
-+
-+ return n;
-+}
-+
-+
-+static inline struct g2d_output_state *
-+get_output_state(struct weston_output *output)
-+{
-+ return (struct g2d_output_state *)output->renderer_state;
-+}
-+
-+static void
-+g2d_getG2dTiling(IN gceTILING tiling, enum g2d_tiling* g2dTiling)
-+{
-+ switch(tiling)
-+ {
-+ case gcvLINEAR:
-+ *g2dTiling = G2D_LINEAR;
-+ break;
-+ case gcvTILED:
-+ *g2dTiling = G2D_TILED;
-+ break;
-+ case gcvSUPERTILED:
-+ *g2dTiling = G2D_SUPERTILED;
-+ break;
-+ default:
-+ weston_log("Error in function %s\n", __func__);
-+ break;
-+ }
-+}
-+
-+static void
-+g2d_getG2dFormat(IN gceSURF_FORMAT Format, enum g2d_format* g2dFormat)
-+{
-+ switch(Format)
-+ {
-+ case gcvSURF_R5G6B5:
-+ *g2dFormat = G2D_RGB565;
-+ break;
-+ case gcvSURF_A8B8G8R8:
-+ *g2dFormat = G2D_RGBA8888;
-+ break;
-+ case gcvSURF_X8B8G8R8:
-+ *g2dFormat = G2D_RGBA8888;
-+ break;
-+ case gcvSURF_A8R8G8B8:
-+ *g2dFormat = G2D_BGRA8888;
-+ break;
-+ case gcvSURF_X8R8G8B8:
-+ *g2dFormat = G2D_BGRX8888;
-+ break;
-+ case gcvSURF_B5G6R5:
-+ *g2dFormat = G2D_BGR565;
-+ break;
-+ case gcvSURF_B8G8R8A8:
-+ *g2dFormat = G2D_ARGB8888;
-+ break;
-+ case gcvSURF_R8G8B8A8:
-+ *g2dFormat = G2D_ABGR8888;
-+ break;
-+ case gcvSURF_B8G8R8X8:
-+ *g2dFormat = G2D_XRGB8888;
-+ break;
-+ case gcvSURF_R8G8B8X8:
-+ *g2dFormat = G2D_XBGR8888;
-+ break;
-+ case gcvSURF_NV12:
-+ *g2dFormat = G2D_NV12;
-+ break;
-+ case gcvSURF_NV21:
-+ *g2dFormat = G2D_NV21;
-+ break;
-+ case gcvSURF_I420:
-+ *g2dFormat = G2D_I420;
-+ break;
-+ case gcvSURF_YV12:
-+ *g2dFormat = G2D_YV12;
-+ break;
-+ case gcvSURF_YUY2:
-+ *g2dFormat = G2D_YUYV;
-+ break;
-+ case gcvSURF_YVYU:
-+ *g2dFormat = G2D_YVYU;
-+ break;
-+ case gcvSURF_UYVY:
-+ *g2dFormat = G2D_UYVY;
-+ break;
-+ case gcvSURF_VYUY:
-+ *g2dFormat = G2D_VYUY;
-+ break;
-+ case gcvSURF_NV16:
-+ *g2dFormat = G2D_NV16;
-+ break;
-+ case gcvSURF_NV61:
-+ *g2dFormat = G2D_NV61;
-+ break;
-+ default:
-+ weston_log("Error in function %s, Format not supported\n", __func__);
-+ break;
-+ }
-+}
-+
-+static void printG2dSurfaceInfo(struct g2d_surfaceEx* g2dSurface, const char* msg)
-+{
-+ weston_log("%s physicAddr = %x left = %d right = %d top=%d bottom=%d stride= %d tiling = %d, format=%d \n",
-+ msg,
-+ g2dSurface->base.planes[0],
-+ g2dSurface->base.left,
-+ g2dSurface->base.right,
-+ g2dSurface->base.top,
-+ g2dSurface->base.bottom,
-+ g2dSurface->base.stride,
-+ g2dSurface->tiling,
-+ g2dSurface->base.format);
-+}
-+
-+static void
-+get_g2dSurface(struct wl_viv_buffer *buffer, struct g2d_surfaceEx *g2dSurface)
-+{
-+ if(buffer->width < 0 || buffer->height < 0)
-+ {
-+ weston_log("invalid EGL buffer in function %s\n", __func__);
-+ return;
-+ }
-+ g2d_getG2dFormat(buffer->format, &g2dSurface->base.format);
-+ g2d_getG2dTiling(buffer->tiling, &g2dSurface->tiling);
-+ g2dSurface->base.planes[0] = buffer->physical[0] + buffer->gpuBaseAddr;
-+ g2dSurface->base.planes[1] = buffer->physical[1] + buffer->gpuBaseAddr;
-+ g2dSurface->base.planes[2] = buffer->physical[2] + buffer->gpuBaseAddr;
-+ g2dSurface->base.left = 0;
-+ g2dSurface->base.top = 0;
-+ g2dSurface->base.right = buffer->width;
-+ g2dSurface->base.bottom = buffer->height;
-+ g2dSurface->base.stride = buffer->alignedWidth;
-+ g2dSurface->base.width = buffer->width;
-+ g2dSurface->base.height = buffer->height;
-+ g2dSurface->base.rot = G2D_ROTATION_0;
-+}
-+
-+static void
-+g2d_SetSurfaceRect(struct g2d_surfaceEx* g2dSurface, g2dRECT* rect)
-+{
-+ if(g2dSurface && rect)
-+ {
-+ g2dSurface->base.left = rect->left;
-+ g2dSurface->base.top = rect->top;
-+ g2dSurface->base.right = rect->right;
-+ g2dSurface->base.bottom = rect->bottom;
-+ }
-+}
-+
-+static int
-+g2d_blitSurface(void *handle, struct g2d_surfaceEx * srcG2dSurface, struct g2d_surfaceEx *dstG2dSurface,
-+ g2dRECT *srcRect, g2dRECT *dstRect)
-+{
-+ g2d_SetSurfaceRect(srcG2dSurface, srcRect);
-+ g2d_SetSurfaceRect(dstG2dSurface, dstRect);
-+ srcG2dSurface->base.blendfunc = G2D_ONE;
-+ dstG2dSurface->base.blendfunc = G2D_ONE_MINUS_SRC_ALPHA;
-+
-+ if(g2d_blitEx(handle, srcG2dSurface, dstG2dSurface))
-+ {
-+ printG2dSurfaceInfo(srcG2dSurface, "SRC:");
-+ printG2dSurfaceInfo(dstG2dSurface, "DST:");
-+ return -1;
-+ }
-+ return 0;
-+}
-+
-+static void
-+g2d_flip_surface(struct weston_output *output)
-+{
-+ struct g2d_output_state *go = get_output_state(output);
-+ go->fb_info.varinfo.yoffset = go->activebuffer * go->fb_info.y_resolution;
-+
-+ if(ioctl(go->fb_info.fb_fd, FBIOPAN_DISPLAY, &(go->fb_info.varinfo)) < 0)
-+ {
-+ weston_log("FBIOPAN_DISPLAY Failed\n");
-+ }
-+ go->activebuffer = (go->activebuffer + 1) % go->nNumBuffers;
-+}
-+
-+static void
-+copy_to_framebuffer(struct weston_output *output)
-+{
-+ struct g2d_renderer *gr = get_renderer(output->compositor);
-+ struct g2d_output_state *go = get_output_state(output);
-+ if(!go->directBlit && go->nNumBuffers == 1)
-+ {
-+ g2dRECT srcRect = {0, 0, go->offscreenSurface.base.width, go->offscreenSurface.base.height};
-+ g2dRECT dstrect = srcRect;
-+ g2dRECT clipRect = srcRect;
-+ g2d_set_clipping(gr->handle, clipRect.left, clipRect.top, clipRect.right, clipRect.bottom);
-+ g2d_blitSurface(gr->handle, &go->offscreenSurface,
-+ &go->renderSurf[go->activebuffer], &srcRect, &dstrect);
-+ }
-+
-+ if(go->clone_display_num)
-+ {
-+ int i = 0;
-+ for(i = 0; i < go->clone_display_num; i++)
-+ {
-+ g2dRECT srcRect = {0, 0, go->renderSurf[go->activebuffer].base.width, go->renderSurf[go->activebuffer].base.height};
-+ g2dRECT dstrect = {0, 0, go->mirrorSurf[i].base.width, go->mirrorSurf[i].base.height};
-+ g2dRECT clipRect = srcRect;
-+ g2d_set_clipping(gr->handle, clipRect.left, clipRect.top, clipRect.right, clipRect.bottom);
-+ if(go->directBlit || go->nNumBuffers > 1)
-+ {
-+ g2d_blitSurface(gr->handle, &go->renderSurf[go->activebuffer],
-+ &go->mirrorSurf[i], &srcRect, &dstrect);
-+ }
-+ else
-+ {
-+ g2d_blitSurface(gr->handle, &go->offscreenSurface,
-+ &go->mirrorSurf[i], &srcRect, &dstrect);
-+ }
-+ }
-+ }
-+
-+ g2d_finish(gr->handle);
-+
-+ if(go->nNumBuffers > 1)
-+ {
-+ g2d_flip_surface(output);
-+ }
-+}
-+
-+static int
-+is_view_visible(struct weston_view *view)
-+{
-+ /* Return false, if surface is guaranteed to be totally obscured. */
-+ int ret;
-+ pixman_region32_t unocc;
-+
-+ pixman_region32_init(&unocc);
-+ pixman_region32_subtract(&unocc, &view->transform.boundingbox,
-+ &view->clip);
-+ ret = pixman_region32_not_empty(&unocc);
-+ pixman_region32_fini(&unocc);
-+
-+ return ret;
-+}
-+
-+static void
-+use_output(struct weston_output *output)
-+{
-+ struct weston_compositor *compositor = output->compositor;
-+ struct weston_view *view;
-+ struct g2d_output_state *go = get_output_state(output);
-+ int visibleViews=0;
-+ int fullscreenViews=0;
-+
-+ if(go->nNumBuffers == 1)
-+ {
-+ wl_list_for_each_reverse(view, &compositor->view_list, link)
-+ if (view->plane == &compositor->primary_plane && is_view_visible(view))
-+ {
-+ visibleViews++;
-+ if(view->surface->width == go->width && view->surface->height == go->height)
-+ {
-+ pixman_box32_t *bb_rects;
-+ int nbb=0;
-+ bb_rects = pixman_region32_rectangles(&view->transform.boundingbox, &nbb);
-+ if(nbb == 1)
-+ if(bb_rects[0].x1 == 0 && bb_rects[0].y1 ==0)
-+ fullscreenViews++;
-+ }
-+ }
-+
-+ go->directBlit = ((visibleViews == 1) || (fullscreenViews > 1));
-+ }
-+}
-+
-+static int
-+g2d_renderer_read_pixels(struct weston_output *output,
-+ pixman_format_code_t format, void *pixels,
-+ uint32_t x, uint32_t y,
-+ uint32_t width, uint32_t height)
-+{
-+ return 0;
-+}
-+
-+static int g2d_int_from_double(double d)
-+{
-+ return wl_fixed_to_int(wl_fixed_from_double(d));
-+}
-+
-+static void
-+repaint_region(struct weston_view *ev, struct weston_output *output, struct g2d_output_state *go, pixman_region32_t *region,
-+ pixman_region32_t *surf_region){
-+
-+ struct g2d_renderer *gr = get_renderer(ev->surface->compositor);
-+ struct g2d_surface_state *gs = get_surface_state(ev->surface);
-+
-+ pixman_box32_t *rects, *surf_rects, *bb_rects;
-+ int i, j, nrects, nsurf, nbb=0;
-+ g2dRECT srcRect = {0};
-+ g2dRECT dstrect = {0};
-+ g2dRECT clipRect = {0};
-+ int dstWidth = 0;
-+ int dstHeight = 0;
-+ struct g2d_surfaceEx *dstsurface;
-+
-+ bb_rects = pixman_region32_rectangles(&ev->transform.boundingbox, &nbb);
-+
-+ if(!gs->attached || nbb <= 0)
-+ {
-+ return;
-+ }
-+
-+ rects = pixman_region32_rectangles(region, &nrects);
-+ surf_rects = pixman_region32_rectangles(surf_region, &nsurf);
-+ srcRect.left = ev->geometry.x < 0.0 ? g2d_int_from_double(fabsf(ev->geometry.x)) : 0;
-+ srcRect.top = ev->geometry.y < 0.0 ? g2d_int_from_double(fabsf(ev->geometry.y)) : 0;
-+ srcRect.right = ev->surface->width;
-+ srcRect.bottom = ev->surface->height;
-+ if(go->nNumBuffers > 1 || go->directBlit)
-+ {
-+ dstsurface = &go->renderSurf[go->activebuffer];
-+ }
-+ else
-+ {
-+ dstsurface = &go->offscreenSurface;
-+ }
-+ dstWidth = dstsurface->base.width;
-+ dstHeight = dstsurface->base.height;
-+ for (i = 0; i < nrects; i++)
-+ {
-+ pixman_box32_t *rect = &rects[i];
-+ gctFLOAT min_x, max_x, min_y, max_y;
-+
-+ dstrect.left = (bb_rects[0].x1 < 0) ? rect->x1 : bb_rects[0].x1;
-+ dstrect.top = (bb_rects[0].y1 < 0) ? rect->y1 : bb_rects[0].y1;
-+ dstrect.right = bb_rects[0].x2;
-+ dstrect.bottom = bb_rects[0].y2;
-+ /*Multi display support*/
-+ if(output->x > 0)
-+ {
-+ dstrect.left = dstrect.left - output->x;
-+ dstrect.right = dstrect.right - output->x;
-+ }
-+ if(dstrect.left < 0)
-+ {
-+ srcRect.left -= dstrect.left;
-+ dstrect.left = 0;
-+ if(srcRect.left > ev->surface->width)
-+ break;
-+ }
-+ if(dstrect.right > dstWidth)
-+ {
-+ dstrect.right = dstWidth;
-+ srcRect.right = srcRect.left + dstrect.right - dstrect.left;
-+ if(srcRect.right > ev->surface->width)
-+ break;
-+ }
-+ if(dstrect.bottom > dstHeight)
-+ {
-+ dstrect.bottom = dstHeight;
-+ srcRect.bottom = srcRect.top + dstrect.bottom - dstrect.top;
-+ if(srcRect.bottom < 0)
-+ break;
-+ }
-+
-+ for (j = 0; j < nsurf; j++)
-+ {
-+ pixman_box32_t *surf_rect = &surf_rects[j];
-+ gctFLOAT ex[8], ey[8]; /* edge points in screen space */
-+ int n;
-+ int m=0;
-+ n = calculate_edges(ev, rect, surf_rect, ex, ey);
-+ if (n < 3)
-+ continue;
-+
-+ min_x = max_x = ex[0];
-+ min_y = max_y = ey[0];
-+ for (m = 1; m < n; m++)
-+ {
-+ min_x = min(min_x, ex[m]);
-+ max_x = max(max_x, ex[m]);
-+ min_y = min(min_y, ey[m]);
-+ max_y = max(max_y, ey[m]);
-+ }
-+
-+ clipRect.left = g2d_int_from_double(min_x);
-+ clipRect.top = g2d_int_from_double(min_y);
-+ clipRect.right = g2d_int_from_double(max_x);
-+ clipRect.bottom = g2d_int_from_double(max_y);
-+
-+ if(output->x > 0)
-+ {
-+ clipRect.left = clipRect.left - output->x;
-+ clipRect.right = clipRect.right - output->x;
-+ }
-+ g2d_set_clipping(gr->handle, clipRect.left, clipRect.top, clipRect.right, clipRect.bottom);
-+ g2d_blitSurface(gr->handle, &gs->g2d_surface, dstsurface, &srcRect, &dstrect);
-+ }
-+ }
-+}
-+
-+static void
-+draw_view(struct weston_view *ev, struct weston_output *output,
-+ pixman_region32_t *damage) /* in global coordinates */
-+{
-+ struct weston_compositor *ec = ev->surface->compositor;
-+ struct g2d_output_state *go = get_output_state(output);
-+ struct g2d_surface_state *gs = get_surface_state(ev->surface);
-+ /* repaint bounding region in global coordinates: */
-+ pixman_region32_t repaint;
-+ /* non-opaque region in surface coordinates: */
-+ pixman_region32_t surface_blend;
-+ pixman_region32_t *buffer_damage;
-+
-+ pixman_region32_init(&repaint);
-+ pixman_region32_intersect(&repaint,
-+ &ev->transform.boundingbox, damage);
-+ pixman_region32_subtract(&repaint, &repaint, &ev->clip);
-+
-+ if (!pixman_region32_not_empty(&repaint))
-+ goto out;
-+
-+ buffer_damage = &go->buffer_damage[go->current_buffer];
-+ pixman_region32_subtract(buffer_damage, buffer_damage, &repaint);
-+
-+ /* blended region is whole surface minus opaque region: */
-+ pixman_region32_init_rect(&surface_blend, 0, 0,
-+ ev->surface->width, ev->surface->height);
-+ pixman_region32_subtract(&surface_blend, &surface_blend, &ev->surface->opaque);
-+
-+ struct g2d_renderer *gr = get_renderer(ec);
-+ if (pixman_region32_not_empty(&ev->surface->opaque)) {
-+ repaint_region(ev, output, go, &repaint, &ev->surface->opaque);
-+ }
-+
-+ if (pixman_region32_not_empty(&surface_blend)) {
-+ g2d_enable(gr->handle,G2D_BLEND);
-+ if (ev->alpha < 1.0)
-+ {
-+ g2d_enable(gr->handle, G2D_GLOBAL_ALPHA);
-+ gs->g2d_surface.base.global_alpha = ev->alpha * 0xFF;
-+ }
-+ repaint_region(ev, output, go, &repaint, &surface_blend);
-+ g2d_disable(gr->handle, G2D_GLOBAL_ALPHA);
-+ g2d_disable(gr->handle, G2D_BLEND);
-+ }
-+ pixman_region32_fini(&surface_blend);
-+
-+out:
-+ pixman_region32_fini(&repaint);
-+}
-+
-+static void
-+repaint_views(struct weston_output *output, pixman_region32_t *damage)
-+{
-+ struct weston_compositor *compositor = output->compositor;
-+ struct weston_view *view;
-+
-+ wl_list_for_each_reverse(view, &compositor->view_list, link)
-+ if (view->plane == &compositor->primary_plane)
-+ draw_view(view, output, damage);
-+}
-+
-+static void
-+g2d_renderer_repaint_output(struct weston_output *output,
-+ pixman_region32_t *output_damage)
-+{
-+ struct g2d_output_state *go = get_output_state(output);
-+ struct weston_compositor *compositor = output->compositor;
-+ struct g2d_renderer *gr = get_renderer(compositor);
-+ int i;
-+
-+ use_output(output);
-+ for (i = 0; i < 2; i++)
-+ pixman_region32_union(&go->buffer_damage[i],
-+ &go->buffer_damage[i],
-+ output_damage);
-+
-+ pixman_region32_union(output_damage, output_damage,
-+ &go->buffer_damage[go->current_buffer]);
-+
-+ repaint_views(output, output_damage);
-+ g2d_finish(gr->handle);
-+
-+ pixman_region32_copy(&output->previous_damage, output_damage);
-+ wl_signal_emit(&output->frame_signal, output);
-+ copy_to_framebuffer(output);
-+ go->current_buffer ^= 1;
-+}
-+
-+static void
-+g2d_renderer_attach_egl(struct weston_surface *es, struct weston_buffer *buffer)
-+{
-+ struct wl_viv_buffer *vivBuffer = wl_resource_get_user_data(buffer->resource);
-+ struct g2d_surface_state *gs = get_surface_state(es);
-+ buffer->width = vivBuffer->width;
-+ buffer->height = vivBuffer->height;
-+ get_g2dSurface(vivBuffer, &gs->g2d_surface);
-+}
-+
-+static void
-+g2d_renderer_flush_damage(struct weston_surface *surface)
-+{
-+ struct g2d_surface_state *gs = get_surface_state(surface);
-+ struct weston_buffer *buffer = gs->buffer_ref.buffer;
-+ struct weston_view *view;
-+ int texture_used;
-+ pixman_region32_union(&gs->texture_damage,
-+ &gs->texture_damage, &surface->damage);
-+
-+ if (!buffer)
-+ return;
-+
-+ texture_used = 0;
-+ wl_list_for_each(view, &surface->views, surface_link) {
-+ if (view->plane == &surface->compositor->primary_plane) {
-+ texture_used = 1;
-+ break;
-+ }
-+ }
-+ if (!texture_used)
-+ return;
-+
-+ if (!pixman_region32_not_empty(&gs->texture_damage))
-+ goto done;
-+
-+ if(wl_shm_buffer_get(buffer->resource))
-+ {
-+ uint8_t *src = wl_shm_buffer_get_data(buffer->shm_buffer);
-+ uint8_t *dst = gs->shm_buf->buf_vaddr;
-+ int bpp = gs->bpp;
-+ wl_shm_buffer_begin_access(buffer->shm_buffer);
-+ if(gs->shm_buf)
-+ {
-+ int alignedWidth = ALIGN_WIDTH(buffer->width);
-+ if(alignedWidth == buffer->width)
-+ {
-+ int size = wl_shm_buffer_get_stride(buffer->shm_buffer)*buffer->height;
-+ memcpy(dst, src, size);
-+ }
-+ else
-+ {
-+ int i, j;
-+ for (i = 0; i < buffer->height; i++)
-+ {
-+ for (j = 0; j < buffer->width; j++)
-+ {
-+ int dstOff = i * alignedWidth + j;
-+ int srcOff = (i * buffer->width + j);
-+ memcpy(dst + dstOff * bpp, src + srcOff * bpp, bpp);
-+ }
-+ }
-+ }
-+ }
-+ else
-+ {
-+ weston_log("Error: This shm buffer was not attached\n");
-+ }
-+ wl_shm_buffer_end_access(buffer->shm_buffer);
-+ }
-+ else
-+ {
-+ g2d_renderer_attach_egl(surface, buffer);
-+ }
-+
-+done:
-+ pixman_region32_fini(&gs->texture_damage);
-+ pixman_region32_init(&gs->texture_damage);
-+
-+ weston_buffer_reference(&gs->buffer_ref, NULL);
-+}
-+
-+static void
-+g2d_renderer_attach_shm(struct weston_surface *es, struct weston_buffer *buffer,
-+ struct wl_shm_buffer *shm_buffer)
-+{
-+ struct g2d_surface_state *gs = get_surface_state(es);
-+ int buffer_length = 0;
-+ int alloc_new_buff = 1;
-+ int alignedWidth = 0;
-+ enum g2d_format g2dFormat = 0;
-+ buffer->shm_buffer = shm_buffer;
-+ buffer->width = wl_shm_buffer_get_width(shm_buffer);
-+ buffer->height = wl_shm_buffer_get_height(shm_buffer);
-+ alignedWidth = ALIGN_WIDTH(buffer->width);
-+
-+ switch (wl_shm_buffer_get_format(shm_buffer)) {
-+ case WL_SHM_FORMAT_XRGB8888:
-+ g2dFormat = G2D_BGRX8888;
-+ gs->bpp = 4;
-+ break;
-+ case WL_SHM_FORMAT_ARGB8888:
-+ g2dFormat = G2D_BGRA8888;
-+ gs->bpp = 4;
-+ break;
-+ case WL_SHM_FORMAT_RGB565:
-+ g2dFormat = G2D_RGB565;
-+ gs->bpp = 2;
-+ break;
-+ default:
-+ weston_log("warning: unknown shm buffer format: %08x\n",
-+ wl_shm_buffer_get_format(shm_buffer));
-+ return;
-+ }
-+
-+ buffer_length = alignedWidth * buffer->height * gs->bpp;
-+
-+ /* Only allocate a new g2d buff if it is larger than existing one.*/
-+ gs->shm_buf_length = buffer_length;
-+ if(gs->shm_buf && gs->shm_buf->buf_size > buffer_length)
-+ {
-+ alloc_new_buff = 0;
-+ }
-+
-+ if(alloc_new_buff)
-+ {
-+ if(gs->shm_buf)
-+ g2d_free(gs->shm_buf);
-+ gs->shm_buf = g2d_alloc(buffer_length, 0);
-+ gs->g2d_surface.base.planes[0] = gs->shm_buf->buf_paddr;
-+ }
-+ gs->g2d_surface.base.left = 0;
-+ gs->g2d_surface.base.top = 0;
-+ gs->g2d_surface.base.right = buffer->width;
-+ gs->g2d_surface.base.bottom = buffer->height;
-+ gs->g2d_surface.base.stride = alignedWidth;
-+ gs->g2d_surface.base.width = buffer->width;
-+ gs->g2d_surface.base.height = buffer->height;
-+ gs->g2d_surface.base.rot = G2D_ROTATION_0;
-+ gs->g2d_surface.base.clrcolor = 0xFF400000;
-+ gs->g2d_surface.tiling = G2D_LINEAR;
-+ gs->g2d_surface.base.format = g2dFormat;
-+}
-+
-+static void
-+g2d_renderer_attach(struct weston_surface *es, struct weston_buffer *buffer)
-+{
-+ struct g2d_surface_state *gs = get_surface_state(es);
-+ struct wl_shm_buffer *shm_buffer;
-+ weston_buffer_reference(&gs->buffer_ref, buffer);
-+
-+ if(buffer==NULL)
-+ return;
-+
-+ shm_buffer = wl_shm_buffer_get(buffer->resource);
-+
-+ if(shm_buffer)
-+ {
-+ g2d_renderer_attach_shm(es, buffer, shm_buffer);
-+ }
-+ else
-+ {
-+ g2d_renderer_attach_egl(es, buffer);
-+ }
-+ gs->attached = 1;
-+}
-+
-+static void
-+surface_state_destroy(struct g2d_surface_state *gs, struct g2d_renderer *gr)
-+{
-+ wl_list_remove(&gs->surface_destroy_listener.link);
-+ wl_list_remove(&gs->renderer_destroy_listener.link);
-+ if(gs->surface)
-+ gs->surface->renderer_state = NULL;
-+
-+ if(gs->shm_buf)
-+ {
-+ g2d_free(gs->shm_buf);
-+ gs->shm_buf = NULL;
-+ }
-+
-+ weston_buffer_reference(&gs->buffer_ref, NULL);
-+ free(gs);
-+}
-+
-+static void
-+surface_state_handle_surface_destroy(struct wl_listener *listener, void *data)
-+{
-+ struct g2d_surface_state *gs;
-+ struct g2d_renderer *gr;
-+
-+ gs = container_of(listener, struct g2d_surface_state,
-+ surface_destroy_listener);
-+
-+ gr = get_renderer(gs->surface->compositor);
-+ surface_state_destroy(gs, gr);
-+}
-+
-+static void
-+surface_state_handle_renderer_destroy(struct wl_listener *listener, void *data)
-+{
-+ struct g2d_surface_state *gs;
-+ struct g2d_renderer *gr;
-+
-+ gr = data;
-+
-+ gs = container_of(listener, struct g2d_surface_state,
-+ renderer_destroy_listener);
-+
-+ surface_state_destroy(gs, gr);
-+}
-+
-+
-+static int
-+g2d_renderer_create_surface(struct weston_surface *surface)
-+{
-+ struct g2d_surface_state *gs;
-+ struct g2d_renderer *gr = get_renderer(surface->compositor);
-+
-+ gs = zalloc(sizeof *gs);
-+ if (gs == NULL)
-+ return -1;
-+
-+ /* A buffer is never attached to solid color surfaces, yet
-+ * they still go through texcoord computations. Do not divide
-+ * by zero there.
-+ */
-+ gs->pitch = 1;
-+
-+ gs->surface = surface;
-+
-+ pixman_region32_init(&gs->texture_damage);
-+ surface->renderer_state = gs;
-+
-+ gs->surface_destroy_listener.notify =
-+ surface_state_handle_surface_destroy;
-+ wl_signal_add(&surface->destroy_signal,
-+ &gs->surface_destroy_listener);
-+
-+ gs->renderer_destroy_listener.notify =
-+ surface_state_handle_renderer_destroy;
-+ wl_signal_add(&gr->destroy_signal,
-+ &gs->renderer_destroy_listener);
-+
-+ if (surface->buffer_ref.buffer) {
-+ g2d_renderer_attach(surface, surface->buffer_ref.buffer);
-+ g2d_renderer_flush_damage(surface);
-+ }
-+
-+ return 0;
-+}
-+
-+static void
-+g2d_renderer_surface_set_color(struct weston_surface *surface,
-+ float red, float green, float blue, float alpha)
-+{
-+ struct g2d_surface_state *gs = get_surface_state(surface);
-+
-+ gs->color[0] = red;
-+ gs->color[1] = green;
-+ gs->color[2] = blue;
-+ gs->color[3] = alpha;
-+}
-+
-+
-+static void
-+g2d_renderer_output_destroy(struct weston_output *output)
-+{
-+ struct g2d_output_state *go = get_output_state(output);
-+ int i;
-+
-+ for (i = 0; i < 2; i++)
-+ {
-+ pixman_region32_fini(&go->buffer_damage[i]);
-+ }
-+
-+ if(go->offscreen_buf)
-+ {
-+ g2d_free(go->offscreen_buf);
-+ go->offscreen_buf = NULL;
-+ }
-+
-+ if(go->fb_info.fb_fd)
-+ {
-+ close(go->fb_info.fb_fd);
-+ go->fb_info.fb_fd = 0;
-+ }
-+
-+ if(go->renderSurf)
-+ {
-+ free(go->renderSurf);
-+ go->renderSurf = NULL;
-+ }
-+ for (i = 0; i < go->clone_display_num; i++)
-+ {
-+ if(go->mirror_fb_info[i].fb_fd)
-+ {
-+ close(go->mirror_fb_info[i].fb_fd);
-+ go->mirror_fb_info[i].fb_fd = 0;
-+ }
-+ }
-+ if(go->mirrorSurf)
-+ {
-+ free(go->mirrorSurf);
-+ go->mirrorSurf = NULL;
-+ }
-+ if(go->mirror_fb_info)
-+ {
-+ free(go->mirror_fb_info);
-+ go->mirror_fb_info = NULL;
-+ }
-+
-+ free(go);
-+}
-+
-+static void
-+g2d_renderer_destroy(struct weston_compositor *ec)
-+{
-+ struct g2d_renderer *gr = get_renderer(ec);
-+
-+ wl_signal_emit(&gr->destroy_signal, gr);
-+ g2d_close(gr->handle);
-+#ifdef ENABLE_EGL
-+ eglUnbindWaylandDisplayWL(gr->egl_display);
-+ eglTerminate(gr->egl_display);
-+ fbDestroyDisplay(gr->display);
-+#endif
-+ free(ec->renderer);
-+ ec->renderer = NULL;
-+}
-+
-+static int
-+g2d_renderer_create(struct weston_compositor *ec)
-+{
-+ struct g2d_renderer *gr;
-+ gr = malloc(sizeof *gr);
-+ if (gr == NULL)
-+ return -1;
-+
-+ gr->base.read_pixels = g2d_renderer_read_pixels;
-+ gr->base.repaint_output = g2d_renderer_repaint_output;
-+ gr->base.flush_damage = g2d_renderer_flush_damage;
-+ gr->base.attach = g2d_renderer_attach;
-+ gr->base.surface_set_color = g2d_renderer_surface_set_color;
-+ gr->base.destroy = g2d_renderer_destroy;
-+
-+ if(g2d_open(&gr->handle))
-+ {
-+ weston_log("g2d_open fail.\n");
-+ return -1;
-+ }
-+ ec->renderer = &gr->base;
-+ wl_signal_init(&gr->destroy_signal);
-+ return 0;
-+}
-+
-+static int
-+calculate_g2d_format(struct fb_var_screeninfo *varinfo, enum g2d_format *g2dFormat)
-+{
-+ /* Get the color format. */
-+ switch (varinfo->green.length)
-+ {
-+ case 6:
-+ *g2dFormat= G2D_RGB565;
-+ break;
-+
-+ case 8:
-+ if (varinfo->blue.offset == 0)
-+ {
-+ *g2dFormat = (varinfo->transp.length == 0) ? G2D_BGRX8888 : G2D_BGRA8888;
-+ }
-+ else
-+ {
-+ *g2dFormat = (varinfo->transp.length == 0) ? G2D_RGBX8888 : G2D_RGBA8888;
-+ }
-+ break;
-+
-+ default:
-+ *g2dFormat = -1;
-+ break;
-+ }
-+ return 0;
-+}
-+
-+static int
-+get_G2dSurface_from_screeninfo(struct fb_screeninfo *info, struct g2d_surfaceEx* g2dSurface)
-+{
-+ if(info && g2dSurface)
-+ {
-+ g2dSurface->base.planes[0] = info->physical;
-+ g2dSurface->base.left = 0;
-+ g2dSurface->base.top = 0;
-+ g2dSurface->base.right = info->x_resolution;
-+ g2dSurface->base.bottom = info->y_resolution;
-+ g2dSurface->base.stride = info->stride;
-+ g2dSurface->base.width = info->x_resolution;
-+ g2dSurface->base.height = info->y_resolution;
-+ g2dSurface->base.format = info->pixel_format;
-+ g2dSurface->base.rot = G2D_ROTATION_0;
-+ g2dSurface->base.clrcolor = 0xFF400000;
-+ g2dSurface->tiling = G2D_LINEAR;
-+ return 0;
-+ }
-+ return -1;
-+}
-+
-+static int
-+fb_query_screen_info(struct g2d_output_state *output, int fd,
-+ struct fb_screeninfo *info)
-+{
-+ struct g2d_output_state *go = output;
-+ struct fb_var_screeninfo *varinfo = &info->varinfo;
-+ struct fb_fix_screeninfo *fixinfo = &info->fixinfo;
-+
-+ /* Probe the device for screen information. */
-+ if (ioctl(fd, FBIOGET_VSCREENINFO, varinfo) < 0) {
-+ return -1;
-+ }
-+
-+ if(go->nNumBuffers > 1){
-+ varinfo->yres_virtual = varinfo->yres * go->nNumBuffers;
-+ if (ioctl(fd, FBIOPUT_VSCREENINFO, varinfo) < 0)
-+ return -1;
-+ }
-+
-+ if (ioctl(fd, FBIOGET_FSCREENINFO, fixinfo) < 0 ||
-+ ioctl(fd, FBIOGET_VSCREENINFO, varinfo) < 0){
-+ return -1;
-+ }
-+ /* Store the pertinent data. */
-+ info->x_resolution = varinfo->xres;
-+ info->y_resolution = varinfo->yres;
-+ info->physical = fixinfo->smem_start;
-+ info->buffer_length = fixinfo->smem_len;
-+ info->stride = fixinfo->line_length / (varinfo->bits_per_pixel >> 3);
-+ info->stride_bytes = fixinfo->line_length;
-+ calculate_g2d_format(varinfo, &info->pixel_format);
-+
-+ if (info->pixel_format < 0) {
-+ weston_log("Frame buffer uses an unsupported format.\n");
-+ return -1;
-+ }
-+
-+ return 0;
-+}
-+
-+static int
-+fb_frame_buffer_open(struct g2d_output_state *output, const char *fb_dev,
-+ struct fb_screeninfo *screen_info)
-+{
-+ /* Open the frame buffer device. */
-+ screen_info->fb_fd = open(fb_dev, O_RDWR | O_CLOEXEC);
-+ if (screen_info->fb_fd < 0) {
-+ weston_log("Failed to open frame buffer device%s \n", fb_dev);
-+ return -1;
-+ }
-+
-+ /* Grab the screen info. */
-+ if (fb_query_screen_info(output, screen_info->fb_fd, screen_info) < 0) {
-+ weston_log("Failed to get frame buffer info \n");
-+
-+ close(screen_info->fb_fd);
-+ return -1;
-+ }
-+
-+ return 0;
-+}
-+
-+static void
-+getBufferNumber(struct g2d_output_state *go)
-+{
-+ char *p = NULL;
-+ p = getenv("FB_MULTI_BUFFER");
-+ if (p == gcvNULL)
-+ {
-+ go->nNumBuffers = 1;
-+ }
-+ else
-+ {
-+ go->nNumBuffers = atoi(p);
-+ if (go->nNumBuffers < 2)
-+ {
-+ go->nNumBuffers = 1;
-+ }
-+ else if(go->nNumBuffers >= 2)
-+ {
-+ go->nNumBuffers = 2;
-+ go->activebuffer = 1;
-+ }
-+ }
-+ weston_log("FB_MULTI_BUFFER = %d\n", go->nNumBuffers);
-+}
-+
-+static int
-+g2d_renderer_surface_create(struct g2d_output_state *go, struct g2d_renderer *gr, const char *device)
-+{
-+ int i = 0;
-+ int offset = 0;
-+ weston_log("Opend device=%s\n", device);
-+ if(fb_frame_buffer_open(go, device, &go->fb_info) < 0)
-+ {
-+ weston_log("Open frame buffer failed.\n");
-+ return -1;
-+ }
-+ go->renderSurf = zalloc(sizeof(struct g2d_surfaceEx) * go->nNumBuffers);
-+ offset = go->fb_info.stride_bytes * go->fb_info.y_resolution;
-+ for(i = 0; i < go->nNumBuffers; i++)
-+ {
-+ get_G2dSurface_from_screeninfo(&go->fb_info, &go->renderSurf[i]);
-+ go->renderSurf[i].base.planes[0] = go->fb_info.physical
-+ + (offset * i);
-+ g2d_clear(gr->handle, &go->renderSurf[i].base);
-+ }
-+
-+ if(go->nNumBuffers == 1)
-+ {
-+ go->offscreenSurface = (go->renderSurf[go->activebuffer]);
-+ go->offscreen_buf = g2d_alloc(go->fb_info.buffer_length, 0);
-+ go->offscreenSurface.base.planes[0] = go->offscreen_buf->buf_paddr;
-+ g2d_clear(gr->handle, &go->offscreenSurface.base);
-+ }
-+ return 0;
-+}
-+
-+static int
-+g2d_renderer_output_create(struct weston_output *output, struct wl_display *wl_display, const char *device)
-+
-+ {
-+ struct g2d_renderer *gr = get_renderer(output->compositor);
-+ struct g2d_output_state *go;
-+ int i;
-+ int clone_display_num = 0;
-+ int count = 0;
-+ int k=0, dispCount = 0;
-+ char displays[5][32];
-+ weston_log("g2d_renderer_output_create device=%s\n", device);
-+ count = strlen(device);
-+
-+ if(count > 0)
-+ {
-+ for(i= 0; i < count; i++)
-+ {
-+ if(device[i] == ',')
-+ {
-+ displays[dispCount][k] = '\0';
-+ dispCount++;
-+ k = 0;
-+ continue;
-+ }
-+ else if(device[i] != ' ')
-+ {
-+ displays[dispCount][k++] = device[i];
-+ }
-+ }
-+ displays[dispCount][k] = '\0';
-+ clone_display_num = dispCount++;
-+ weston_log("clone_display_num = %d\n", clone_display_num);
-+ }
-+ else
-+ {
-+ weston_log("Invalid device name\n");
-+ return -1;
-+ }
-+
-+ go = zalloc(sizeof *go);
-+ if (go == NULL)
-+ return -1;
-+ go->clone_display_num = clone_display_num;
-+ output->renderer_state = go;
-+#ifdef ENABLE_EGL
-+ gr->wl_display = wl_display;
-+ gr->display = fbGetDisplay(wl_display);
-+ gr->egl_display = eglGetDisplay(gr->display);
-+ eglBindWaylandDisplayWL(gr->egl_display, wl_display);
-+#endif
-+ getBufferNumber(go);
-+
-+ if(g2d_renderer_surface_create(go, gr, displays[0]) < 0)
-+ {
-+ weston_log("Create Render surface failed.\n");
-+ return -1;
-+ }
-+
-+ if(go->clone_display_num)
-+ {
-+ go->mirrorSurf = zalloc(sizeof(struct g2d_surfaceEx) * clone_display_num);
-+ go->mirror_fb_info = zalloc(sizeof(struct fb_screeninfo) * clone_display_num);
-+ if(go->mirrorSurf == NULL || go->mirror_fb_info == NULL)
-+ return -1;
-+
-+ for(i = 0; i < clone_display_num; i++)
-+ {
-+ if(fb_frame_buffer_open(go, displays[i + 1], &go->mirror_fb_info[i]) < 0)
-+ {
-+ weston_log("Open frame buffer failed.\n");
-+ return -1;
-+ }
-+ get_G2dSurface_from_screeninfo(&go->mirror_fb_info[i], &go->mirrorSurf[i]);
-+ go->mirrorSurf[i].base.planes[0] = go->mirror_fb_info[i].physical;
-+ g2d_clear(gr->handle, &go->mirrorSurf[i].base);
-+ }
-+ }
-+ g2d_finish(gr->handle);
-+ for (i = 0; i < BUFFER_DAMAGE_COUNT; i++)
-+ pixman_region32_init(&go->buffer_damage[i]);
-+ return 0;
-+ }
-+
-+ WL_EXPORT struct g2d_renderer_interface g2d_renderer_interface = {
-+ .create = g2d_renderer_create,
-+ .output_create = g2d_renderer_output_create,
-+ .output_destroy = g2d_renderer_output_destroy,
-+};
-diff --git a/src/g2d-renderer.h b/src/g2d-renderer.h
-new file mode 100644
-index 0000000..fc4ca49
---- /dev/null
-+++ b/src/g2d-renderer.h
-@@ -0,0 +1,47 @@
-+/*
-+ * Copyright (c) 2015 Freescale Semiconductor, Inc.
-+ * Copyright © 2013 Vasily Khoruzhick <anarsoul@gmail.com>
-+ *
-+ * 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.
-+ */
-+#ifndef __g2d_renderer_h_
-+#define __g2d_renderer_h_
-+
-+#include "compositor.h"
-+
-+#ifdef ENABLE_EGL
-+#include <EGL/egl.h>
-+#include <EGL/eglext.h>
-+#endif
-+
-+struct g2d_renderer_interface {
-+
-+ int (*create)(struct weston_compositor *ec);
-+
-+ int (*output_create)(struct weston_output *output,
-+ struct wl_display *wl_display,
-+ const char *device);
-+
-+ void (*output_destroy)(struct weston_output *output);
-+};
-+
-+#endif
-diff --git a/src/main.c b/src/main.c
-index 3279ac6..5d0bdc4 100644
---- a/src/main.c
-+++ b/src/main.c
-@@ -285,7 +285,8 @@ usage(int error_code)
- "Options for fbdev-backend.so:\n\n"
- " --tty=TTY\t\tThe tty to use\n"
- " --device=DEVICE\tThe framebuffer device to use\n"
-- " --use-gl\t\tUse the GL renderer\n\n");
-+ " --use-gl=1\t\tUse the GL renderer\n"
-+ " --use-g2d=1\t\tUse the g2d renderer\n\n");
- #endif
-
- #if defined(BUILD_HEADLESS_COMPOSITOR)
-@@ -868,7 +869,8 @@ load_fbdev_backend(struct weston_compositor *c, char const * backend,
- const struct weston_option fbdev_options[] = {
- { WESTON_OPTION_INTEGER, "tty", 0, &config.tty },
- { WESTON_OPTION_STRING, "device", 0, &config.device },
-- { WESTON_OPTION_BOOLEAN, "use-gl", 0, &config.use_gl },
-+ { WESTON_OPTION_INTEGER, "use-gl", 0, &config.use_gl },
-+ { WESTON_OPTION_INTEGER, "use-g2d", 0, &config.use_g2d },
- };
-
- parse_options(fbdev_options, ARRAY_LENGTH(fbdev_options), argc, argv);
---
-2.7.4
-
