diff options
Diffstat (limited to 'libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp')
| -rw-r--r-- | libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp | 335 |
1 files changed, 335 insertions, 0 deletions
diff --git a/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp b/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp new file mode 100644 index 000000000000..5dd94464f159 --- /dev/null +++ b/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp @@ -0,0 +1,335 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "SurfaceFlinger" + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +#include <GLES/egl.h> + +#include <utils/Log.h> + +#include <ui/EGLDisplaySurface.h> + +#include "DisplayHardware/DisplayHardware.h" +#include "ui/BlitHardware.h" + +using namespace android; + +static __attribute__((noinline)) +const char *egl_strerror(EGLint err) +{ + switch (err){ + case EGL_SUCCESS: return "EGL_SUCCESS"; + case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED"; + case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS"; + case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC"; + case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE"; + case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG"; + case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT"; + case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE"; + case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY"; + case EGL_BAD_MATCH: return "EGL_BAD_MATCH"; + case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP"; + case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW"; + case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER"; + case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE"; + case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST"; + default: return "UNKNOWN"; + } +} + +static __attribute__((noinline)) +void checkGLErrors() +{ + GLenum error = glGetError(); + if (error != GL_NO_ERROR) + LOGE("GL error 0x%04x", int(error)); +} + +static __attribute__((noinline)) +void checkEGLErrors(const char* token) +{ + EGLint error = eglGetError(); + // GLESonGL seems to be returning 0 when there is no errors? + if (error && error != EGL_SUCCESS) + LOGE("%s error 0x%04x (%s)", + token, int(error), egl_strerror(error)); +} + + +/* + * Initialize the display to the specified values. + * + */ + +DisplayHardware::DisplayHardware( + const sp<SurfaceFlinger>& flinger, + uint32_t dpy) + : DisplayHardwareBase(flinger, dpy) +{ + init(dpy); +} + +DisplayHardware::~DisplayHardware() +{ + fini(); +} + +float DisplayHardware::getDpiX() const { return mDpiX; } +float DisplayHardware::getDpiY() const { return mDpiY; } +float DisplayHardware::getRefreshRate() const { return mRefreshRate; } + +int DisplayHardware::getWidth() const { + return mWidth; +} +int DisplayHardware::getHeight() const { + return mHeight; +} +PixelFormat DisplayHardware::getFormat() const { + return mFormat; +} + +void DisplayHardware::init(uint32_t dpy) +{ + // initialize EGL + const EGLint attribs[] = { + EGL_RED_SIZE, 5, + EGL_GREEN_SIZE, 6, + EGL_BLUE_SIZE, 5, + EGL_DEPTH_SIZE, 0, + EGL_NONE + }; + EGLint w, h, dummy; + EGLint numConfigs, n; + EGLConfig config; + EGLSurface surface; + EGLContext context; + mFlags = 0; + + // TODO: all the extensions below should be queried through + // eglGetProcAddress(). + + EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); + eglInitialize(display, NULL, NULL); + eglGetConfigs(display, NULL, 0, &numConfigs); + eglChooseConfig(display, attribs, &config, 1, &n); + + /* + * Gather EGL extensions + */ + + const char* const egl_extensions = eglQueryString( + display, EGL_EXTENSIONS); + + const char* egl_extensions_config = egl_extensions; + + if (strstr(egl_extensions, "EGL_ANDROID_query_string_config")) { + egl_extensions_config = eglQueryStringConfigANDROID( + display, config, EGL_EXTENSIONS); + } + + LOGI("EGL informations:"); + LOGI("# of configs : %d", numConfigs); + LOGI("vendor : %s", eglQueryString(display, EGL_VENDOR)); + LOGI("version : %s", eglQueryString(display, EGL_VERSION)); + LOGI("extensions: %s", egl_extensions); + LOGI("ext/config: %s", egl_extensions_config); + LOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported"); + + if (strstr(egl_extensions_config, "EGL_ANDROID_swap_rectangle")) { + mFlags |= SWAP_RECTANGLE_EXTENSION; + // TODO: get the real "update_on_demand" behavior + mFlags |= UPDATE_ON_DEMAND; + } + if (eglGetConfigAttrib(display, config, EGL_CONFIG_CAVEAT, &dummy) == EGL_TRUE) { + if (dummy == EGL_SLOW_CONFIG) + mFlags |= SLOW_CONFIG; + } + + /* + * Create our main surface + */ + + mDisplaySurface = new EGLDisplaySurface(); + + surface = eglCreateWindowSurface(display, config, mDisplaySurface.get(), NULL); + //checkEGLErrors("eglCreateDisplaySurfaceANDROID"); + + if (eglQuerySurface(display, surface, EGL_SWAP_BEHAVIOR, &dummy) == EGL_TRUE) { + if (dummy == EGL_BUFFER_PRESERVED) { + mFlags |= BUFFER_PRESERVED; + if (strstr(egl_extensions_config, "EGL_ANDROID_copy_front_to_back")) { + mFlags |= COPY_BACK_EXTENSION; + } + } + } + + GLint value = EGL_UNKNOWN; + eglQuerySurface(display, surface, EGL_HORIZONTAL_RESOLUTION, &value); + if (value == EGL_UNKNOWN) { + mDpiX = 160.0f; + } else { + mDpiX = 25.4f * float(value)/EGL_DISPLAY_SCALING; + } + value = EGL_UNKNOWN; + eglQuerySurface(display, surface, EGL_VERTICAL_RESOLUTION, &value); + if (value == EGL_UNKNOWN) { + mDpiY = 160.0f; + } else { + mDpiY = 25.4f * float(value)/EGL_DISPLAY_SCALING; + } + mRefreshRate = 60.f; // TODO: get the real refresh rate + + /* + * Create our OpenGL ES context + */ + + context = eglCreateContext(display, config, NULL, NULL); + //checkEGLErrors("eglCreateContext"); + + eglQuerySurface(display, surface, EGL_WIDTH, &mWidth); + eglQuerySurface(display, surface, EGL_HEIGHT, &mHeight); + + + /* + * Gather OpenGL ES extensions + */ + + eglMakeCurrent(display, surface, surface, context); + const char* const gl_extensions = (const char*)glGetString(GL_EXTENSIONS); + LOGI("OpenGL informations:"); + LOGI("vendor : %s", glGetString(GL_VENDOR)); + LOGI("renderer : %s", glGetString(GL_RENDERER)); + LOGI("version : %s", glGetString(GL_VERSION)); + LOGI("extensions: %s", gl_extensions); + + if (strstr(gl_extensions, "GL_ARB_texture_non_power_of_two")) { + mFlags |= NPOT_EXTENSION; + } + if (strstr(gl_extensions, "GL_OES_draw_texture")) { + mFlags |= DRAW_TEXTURE_EXTENSION; + } + if (strstr(gl_extensions, "GL_ANDROID_direct_texture")) { + mFlags |= DIRECT_TEXTURE; + } + + // Unbind the context from this thread + eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + + mDisplay = display; + mConfig = config; + mSurface = surface; + mContext = context; + mFormat = GGL_PIXEL_FORMAT_RGB_565; + + mBlitEngine = copybit_init(); +} + +/* + * Clean up. Throw out our local state. + * + * (It's entirely possible we'll never get here, since this is meant + * for real hardware, which doesn't restart.) + */ + +void DisplayHardware::fini() +{ + eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + eglTerminate(mDisplay); + copybit_term(mBlitEngine); +} + +void DisplayHardware::releaseScreen() const +{ + DisplayHardwareBase::releaseScreen(); +} + +void DisplayHardware::acquireScreen() const +{ + DisplayHardwareBase::acquireScreen(); +} + +void DisplayHardware::getDisplaySurface(copybit_image_t* img) const +{ + img->w = mDisplaySurface->stride; + img->h = mDisplaySurface->height; + img->format = mDisplaySurface->format; + img->offset = mDisplaySurface->offset; + img->base = (void*)mDisplaySurface->base; + img->fd = mDisplaySurface->fd; +} + +void DisplayHardware::getDisplaySurface(GGLSurface* fb) const +{ + fb->version= sizeof(GGLSurface); + fb->width = mDisplaySurface->width; + fb->height = mDisplaySurface->height; + fb->stride = mDisplaySurface->stride; + fb->format = mDisplaySurface->format; + fb->data = (GGLubyte*)mDisplaySurface->base + mDisplaySurface->offset; +} + +uint32_t DisplayHardware::getPageFlipCount() const { + return mDisplaySurface->getPageFlipCount(); +} + +/* + * "Flip" the front and back buffers. + */ + +void DisplayHardware::flip(const Region& dirty) const +{ + checkGLErrors(); + + EGLDisplay dpy = mDisplay; + EGLSurface surface = mSurface; + + Region newDirty(dirty); + newDirty.andSelf(Rect(mWidth, mHeight)); + + if (mFlags & BUFFER_PRESERVED) { + const Region copyback(mDirty.subtract(newDirty)); + mDirty = newDirty; + mDisplaySurface->copyFrontToBack(copyback); + } + + if (mFlags & SWAP_RECTANGLE_EXTENSION) { + const Rect& b(newDirty.bounds()); + eglSwapRectangleANDROID( + dpy, surface, + b.left, b.top, b.width(), b.height()); + } + + eglSwapBuffers(dpy, surface); + checkEGLErrors("eglSwapBuffers"); + + // for debugging + //glClearColor(1,0,0,0); + //glClear(GL_COLOR_BUFFER_BIT); +} + +uint32_t DisplayHardware::getFlags() const +{ + return mFlags; +} + +void DisplayHardware::makeCurrent() const +{ + eglMakeCurrent(mDisplay, mSurface, mSurface, mContext); +} |