mirrors/weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Android backend

Browse Source 
The Android backend provides basic EGL/GLES2 graphics, where everything
is always composited. Overlays are not used. Input is stubbed, therefore
there is no input yet.

This adds the first C++ source file into Weston compositor. The Android
gralloc and fb HAL glue code to the Android EGL library is in C++, and
there is no way to access it from plain C. We have a simple wrapper to
the required C++ class API. Android forces the C++ file name extension
to .cpp.

The android backend is compiled by default. However, all Android
specific calls are protected with #ifdef ANDROID, so it will build also
without Android headers. The binary produced without the Android build
system is useless, but allows build-testing generic Weston changes.
Therefore the android backend is not installed.

Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
This commit is contained in:
Pekka Paalanen 2012-05-30 15:53:45 +03:00 committed by Kristian Høgsberg
parent daed3bc1aa
commit 3ae50bb45c
5 changed files with 618 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
configure.ac
View File

@ -13,6 +13,7 @@ AM_SILENT_RULES([yes])
# Check for programs
AC_PROG_CC
AC_PROG_CXX
# Initialize libtool
LT_PREREQ([2.2])
@ -95,6 +96,17 @@ if test x$enable_wayland_compositor = xyes; then
PKG_CHECK_MODULES(WAYLAND_COMPOSITOR, [wayland-client wayland-egl])
fi
AC_ARG_ENABLE(android-compositor,
AS_HELP_STRING([--disable-android-compositor],
[do not build-test the Android 4.0 backend]),,
enable_android_compositor=yes)
AM_CONDITIONAL(ENABLE_ANDROID_COMPOSITOR, test x$enable_android_compositor = xyes)
if test x$enable_android_compositor = xyes; then
AC_DEFINE([BUILD_ANDROID_COMPOSITOR], [1], [Build the compositor for Android 4.0])
fi
AC_ARG_WITH(cairo-glesv2, AS_HELP_STRING([--with-cairo-glesv2],
[Use GLESv2 cairo instead of full GL]),
[cairo_modules="cairo-glesv2"],

15
src/Makefile.am
View File

@ -67,6 +67,10 @@ module_LTLIBRARIES = \
$(wayland_backend) \
$(openwfd_backend)
# Do not install, since the binary produced via autotools is unusable.
# The real backend is built by the Android build system.
noinst_LTLIBRARIES = $(android_backend)
if ENABLE_X11_COMPOSITOR
x11_backend = x11-backend.la
x11_backend_la_LDFLAGS = -module -avoid-version
@ -121,6 +125,17 @@ openwfd_backend_la_CFLAGS = $(OPENWFD_COMPOSITOR_CFLAGS) $(GCC_CFLAGS)
openwfd_backend_la_SOURCES = compositor-openwfd.c tty.c evdev.c evdev.h
endif
if ENABLE_ANDROID_COMPOSITOR
android_backend = android-backend.la
android_backend_la_LDFLAGS = -module -avoid-version
android_backend_la_LIBADD = $(COMPOSITOR_LIBS)
android_backend_la_CFLAGS = $(GCC_CFLAGS) $(COMPOSITOR_CFLAGS)
android_backend_la_SOURCES = \
compositor-android.c \
android-framebuffer.cpp \
android-framebuffer.h
endif
if ENABLE_DESKTOP_SHELL
desktop_shell = desktop-shell.la
desktop_shell_la_LDFLAGS = -module -avoid-version

93
src/android-framebuffer.cpp Normal file
View File

@ -0,0 +1,93 @@
/*
* Copyright © 2012 Collabora, Ltd.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of the copyright holders not be used in
* advertising or publicity pertaining to distribution of the software
* without specific, written prior permission. The copyright holders make
* no representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <cstdlib>
#include "android-framebuffer.h"
#ifdef ANDROID
#include <ui/FramebufferNativeWindow.h>
class AndroidFramebuffer {
public:
int init();
struct android_framebuffer fb_;
private:
android::sp<android::FramebufferNativeWindow> nativefb_;
};
int AndroidFramebuffer::init()
{
struct ANativeWindow *window;
const framebuffer_device_t *fbdev;
int ret1, ret2, ret3;
nativefb_ = new android::FramebufferNativeWindow();
fbdev = nativefb_->getDevice();
if (!fbdev)
return -1;
fb_.priv = this;
window = nativefb_.get();
ret1 = window->query(window, NATIVE_WINDOW_WIDTH, &fb_.width);
ret2 = window->query(window, NATIVE_WINDOW_HEIGHT, &fb_.height);
ret3 = window->query(window, NATIVE_WINDOW_FORMAT, &fb_.format);
fb_.xdpi = window->xdpi;
fb_.ydpi = window->ydpi;
fb_.refresh_rate = fbdev->fps;
if (ret1 != android::NO_ERROR ||
ret2 != android::NO_ERROR ||
ret3 != android::NO_ERROR)
return -1;
fb_.native_window = reinterpret_cast<EGLNativeWindowType>(window);
return 0;
}
void
android_framebuffer_destroy(struct android_framebuffer *fb)
{
AndroidFramebuffer *afb = static_cast<AndroidFramebuffer*>(fb->priv);
delete afb;
}
struct android_framebuffer *
android_framebuffer_create(void)
{
AndroidFramebuffer *afb = new AndroidFramebuffer;
if (afb->init() < 0) {
delete afb;
return NULL;
}
return &afb->fb_;
}
#endif /* ANDROID */

54
src/android-framebuffer.h Normal file
View File

@ -0,0 +1,54 @@
/*
* Copyright © 2012 Collabora, Ltd.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of the copyright holders not be used in
* advertising or publicity pertaining to distribution of the software
* without specific, written prior permission. The copyright holders make
* no representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef ANDROID_FRAMEBUFFER_H
#define ANDROID_FRAMEBUFFER_H
#include <EGL/egl.h>
#ifdef __cplusplus
extern "C" {
#endif
struct android_framebuffer {
EGLNativeWindowType native_window;
int width;
int height;
int format;
float xdpi;
float ydpi;
float refresh_rate;
void *priv;
};
void
android_framebuffer_destroy(struct android_framebuffer *fb);
struct android_framebuffer *
android_framebuffer_create(void);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* ANDROID_FRAMEBUFFER_H */

444
src/compositor-android.c Normal file
View File

@ -0,0 +1,444 @@
/*
* Copyright © 2012 Collabora, Ltd.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of the copyright holders not be used in
* advertising or publicity pertaining to distribution of the software
* without specific, written prior permission. The copyright holders make
* no representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <EGL/egl.h>
#include <GLES2/gl2.h>
#include "compositor.h"
#include "android-framebuffer.h"
struct android_compositor;
struct android_output {
struct android_compositor *compositor;
struct weston_output base;
struct weston_mode mode;
struct android_framebuffer *fb;
EGLSurface egl_surface;
};
struct android_seat {
struct weston_seat base;
};
struct android_compositor {
struct weston_compositor base;
struct android_seat *seat;
};
static inline struct android_output *
to_android_output(struct weston_output *base)
{
return container_of(base, struct android_output, base);
}
static inline struct android_compositor *
to_android_compositor(struct weston_compositor *base)
{
return container_of(base, struct android_compositor, base);
}
static const char *
egl_error_string(EGLint code)
{
#define MYERRCODE(x) case x: return #x;
switch (code) {
MYERRCODE(EGL_SUCCESS)
MYERRCODE(EGL_NOT_INITIALIZED)
MYERRCODE(EGL_BAD_ACCESS)
MYERRCODE(EGL_BAD_ALLOC)
MYERRCODE(EGL_BAD_ATTRIBUTE)
MYERRCODE(EGL_BAD_CONTEXT)
MYERRCODE(EGL_BAD_CONFIG)
MYERRCODE(EGL_BAD_CURRENT_SURFACE)
MYERRCODE(EGL_BAD_DISPLAY)
MYERRCODE(EGL_BAD_SURFACE)
MYERRCODE(EGL_BAD_MATCH)
MYERRCODE(EGL_BAD_PARAMETER)
MYERRCODE(EGL_BAD_NATIVE_PIXMAP)
MYERRCODE(EGL_BAD_NATIVE_WINDOW)
MYERRCODE(EGL_CONTEXT_LOST)
default:
return "unknown";
}
#undef MYERRCODE
}
static void
print_egl_error_state(void)
{
EGLint code;
code = eglGetError();
fprintf(stderr, "EGL error state: %s (0x%04lx)\n",
egl_error_string(code), (long)code);
}
static int
android_output_make_current(struct android_output *output)
{
struct android_compositor *compositor = output->compositor;
EGLBoolean ret;
static int errored;
ret = eglMakeCurrent(compositor->base.display, output->egl_surface,
output->egl_surface, compositor->base.context);
if (ret == EGL_FALSE) {
if (errored)
return -1;
errored = 1;
fprintf(stderr, "Failed to make EGL context current.\n");
print_egl_error_state();
return -1;
}
return 0;
}
static void
android_finish_frame(void *data)
{
struct android_output *output = data;
weston_output_finish_frame(&output->base,
weston_compositor_get_time());
}
static void
android_output_repaint(struct weston_output *base, pixman_region32_t *damage)
{
struct android_output *output = to_android_output(base);
struct android_compositor *compositor = output->compositor;
struct weston_surface *surface;
struct wl_event_loop *loop;
EGLBoolean ret;
static int errored;
if (android_output_make_current(output) < 0)
return;
wl_list_for_each_reverse(surface, &compositor->base.surface_list, link)
weston_surface_draw(surface, &output->base, damage);
weston_output_do_read_pixels(&output->base);
ret = eglSwapBuffers(compositor->base.display, output->egl_surface);
if (ret == EGL_FALSE && !errored) {
errored = 1;
fprintf(stderr, "Failed in eglSwapBuffers.\n");
print_egl_error_state();
}
/* FIXME: does Android have a way to signal page flip done? */
loop = wl_display_get_event_loop(compositor->base.wl_display);
wl_event_loop_add_idle(loop, android_finish_frame, output);
}
static void
android_output_destroy(struct weston_output *base)
{
struct android_output *output = to_android_output(base);
wl_list_remove(&output->base.link);
weston_output_destroy(&output->base);
android_framebuffer_destroy(output->fb);
free(output);
}
static struct android_output *
android_output_create(struct android_compositor *compositor)
{
struct android_output *output;
output = calloc(1, sizeof *output);
if (!output)
return NULL;
output->fb = android_framebuffer_create();
if (!output->fb) {
free(output);
return NULL;
}
output->compositor = compositor;
return output;
}
static void
android_compositor_add_output(struct android_compositor *compositor,
struct android_output *output)
{
float mm_width, mm_height;
output->base.repaint = android_output_repaint;
output->base.destroy = android_output_destroy;
output->base.assign_planes = NULL;
output->base.set_backlight = NULL;
output->base.set_dpms = NULL;
output->base.switch_mode = NULL;
/* only one static mode in list */
output->mode.flags =
WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
output->mode.width = output->fb->width;
output->mode.height = output->fb->height;
output->mode.refresh = ceilf(1000.0f * output->fb->refresh_rate);
wl_list_init(&output->base.mode_list);
wl_list_insert(&output->base.mode_list, &output->mode.link);
output->base.current = &output->mode;
output->base.origin = &output->mode;
output->base.subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN;
output->base.make = "unknown";
output->base.model = "unknown";
mm_width = output->fb->width / output->fb->xdpi * 25.4f;
mm_height = output->fb->height / output->fb->ydpi * 25.4f;
weston_output_init(&output->base, &compositor->base,
0, 0, round(mm_width), round(mm_height),
WL_OUTPUT_FLIPPED);
wl_list_insert(compositor->base.output_list.prev, &output->base.link);
}
static void
android_seat_destroy(struct android_seat *seat)
{
weston_seat_release(&seat->base);
free(seat);
}
static struct android_seat *
android_seat_create(struct android_compositor *compositor)
{
struct android_seat *seat;
seat = calloc(1, sizeof *seat);
if (!seat)
return NULL;
weston_seat_init(&seat->base, &compositor->base);
compositor->base.seat = &seat->base;
return seat;
}
static int
android_egl_choose_config(struct android_compositor *compositor,
struct android_framebuffer *fb,
const EGLint *attribs)
{
EGLBoolean ret;
EGLint count = 0;
EGLint matched = 0;
EGLConfig *configs;
int i;
/*
* The logic is copied from Android frameworks/base/services/
* surfaceflinger/DisplayHardware/DisplayHardware.cpp
*/
compositor->base.config = NULL;
ret = eglGetConfigs(compositor->base.display, NULL, 0, &count);
if (ret == EGL_FALSE || count < 1)
return -1;
configs = calloc(count, sizeof *configs);
if (!configs)
return -1;
ret = eglChooseConfig(compositor->base.display, attribs, configs,
count, &matched);
if (ret == EGL_FALSE || matched < 1)
goto out;
for (i = 0; i < matched; ++i) {
EGLint id;
ret = eglGetConfigAttrib(compositor->base.display, configs[i],
EGL_NATIVE_VISUAL_ID, &id);
if (ret == EGL_FALSE)
continue;
if (id > 0 && fb->format == id) {
compositor->base.config = configs[i];
break;
}
}
out:
free(configs);
if (!compositor->base.config)
return -1;
return 0;
}
static int
android_init_egl(struct android_compositor *compositor,
struct android_output *output)
{
EGLint eglmajor, eglminor;
int ret;
static const EGLint context_attrs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
static const EGLint config_attrs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_ALPHA_SIZE, 0,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
compositor->base.display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (compositor->base.display == EGL_NO_DISPLAY) {
fprintf(stderr, "Failed to create EGL display.\n");
print_egl_error_state();
return -1;
}
ret = eglInitialize(compositor->base.display, &eglmajor, &eglminor);
if (!ret) {
fprintf(stderr, "Failed to initialise EGL.\n");
print_egl_error_state();
return -1;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
fprintf(stderr, "Failed to bind EGL_OPENGL_ES_API.\n");
print_egl_error_state();
return -1;
}
ret = android_egl_choose_config(compositor, output->fb, config_attrs);
if (ret < 0) {
fprintf(stderr, "Failed to find an EGL config.\n");
print_egl_error_state();
return -1;
}
compositor->base.context = eglCreateContext(compositor->base.display,
compositor->base.config,
EGL_NO_CONTEXT,
context_attrs);
if (compositor->base.context == EGL_NO_CONTEXT) {
fprintf(stderr, "Failed to create a GL ES 2 context.\n");
print_egl_error_state();
return -1;
}
output->egl_surface = eglCreateWindowSurface(compositor->base.display,
compositor->base.config,
output->fb->native_window,
NULL);
if (output->egl_surface == EGL_NO_SURFACE) {
fprintf(stderr, "Failed to create FB EGLSurface.\n");
print_egl_error_state();
return -1;
}
if (android_output_make_current(output) < 0)
return -1;
return 0;
}
static void
android_fini_egl(struct android_compositor *compositor)
{
eglMakeCurrent(compositor->base.display,
EGL_NO_SURFACE, EGL_NO_SURFACE,
EGL_NO_CONTEXT);
eglTerminate(compositor->base.display);
eglReleaseThread();
}
static void
android_compositor_destroy(struct weston_compositor *base)
{
struct android_compositor *compositor = to_android_compositor(base);
android_seat_destroy(compositor->seat);
/* destroys outputs, too */
weston_compositor_shutdown(&compositor->base);
android_fini_egl(compositor);
free(compositor);
}
static struct weston_compositor *
android_compositor_create(struct wl_display *display)
{
struct android_compositor *compositor;
struct android_output *output;
compositor = calloc(1, sizeof *compositor);
if (compositor == NULL)
return NULL;
compositor->base.destroy = android_compositor_destroy;
compositor->base.focus = 1;
/* FIXME: all cleanup on failure is missing */
output = android_output_create(compositor);
if (!output)
return NULL;
if (android_init_egl(compositor, output) < 0)
return NULL;
if (weston_compositor_init(&compositor->base, display) < 0)
return NULL;
android_compositor_add_output(compositor, output);
compositor->seat = android_seat_create(compositor);
if (!compositor->seat)
return NULL;
return &compositor->base;
}
WL_EXPORT struct weston_compositor *
backend_init(struct wl_display *display, int argc, char *argv[])
{
return android_compositor_create(display);
}