1 /*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <stdlib.h>
18 #include <stdio.h>
19 #include <string.h>
20 #include <math.h>
21
22 #include <cutils/properties.h>
23
24 #include <utils/RefBase.h>
25 #include <utils/Log.h>
26
27 #include <ui/PixelFormat.h>
28 #include <ui/FramebufferNativeWindow.h>
29
30 #include <GLES/gl.h>
31 #include <EGL/egl.h>
32 #include <EGL/eglext.h>
33
34 #include "DisplayHardware/DisplayHardware.h"
35
36 #include <hardware/gralloc.h>
37
38 #include "DisplayHardwareBase.h"
39 #include "GLExtensions.h"
40 #include "HWComposer.h"
41 #include "SurfaceFlinger.h"
42
43 using namespace android;
44
45
46 static __attribute__((noinline))
checkGLErrors()47 void checkGLErrors()
48 {
49 do {
50 // there could be more than one error flag
51 GLenum error = glGetError();
52 if (error == GL_NO_ERROR)
53 break;
54 ALOGE("GL error 0x%04x", int(error));
55 } while(true);
56 }
57
58 static __attribute__((noinline))
checkEGLErrors(const char * token)59 void checkEGLErrors(const char* token)
60 {
61 struct EGLUtils {
62 static const char *strerror(EGLint err) {
63 switch (err){
64 case EGL_SUCCESS: return "EGL_SUCCESS";
65 case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED";
66 case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS";
67 case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC";
68 case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE";
69 case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG";
70 case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT";
71 case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
72 case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY";
73 case EGL_BAD_MATCH: return "EGL_BAD_MATCH";
74 case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP";
75 case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW";
76 case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER";
77 case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE";
78 case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST";
79 default: return "UNKNOWN";
80 }
81 }
82 };
83
84 EGLint error = eglGetError();
85 if (error && error != EGL_SUCCESS) {
86 ALOGE("%s: EGL error 0x%04x (%s)",
87 token, int(error), EGLUtils::strerror(error));
88 }
89 }
90
91 /*
92 * Initialize the display to the specified values.
93 *
94 */
95
DisplayHardware(const sp<SurfaceFlinger> & flinger,uint32_t dpy)96 DisplayHardware::DisplayHardware(
97 const sp<SurfaceFlinger>& flinger,
98 uint32_t dpy)
99 : DisplayHardwareBase(flinger, dpy),
100 mFlinger(flinger), mFlags(0), mHwc(0)
101 {
102 init(dpy);
103 }
104
~DisplayHardware()105 DisplayHardware::~DisplayHardware()
106 {
107 fini();
108 }
109
getDpiX() const110 float DisplayHardware::getDpiX() const { return mDpiX; }
getDpiY() const111 float DisplayHardware::getDpiY() const { return mDpiY; }
getDensity() const112 float DisplayHardware::getDensity() const { return mDensity; }
getRefreshRate() const113 float DisplayHardware::getRefreshRate() const { return mRefreshRate; }
getWidth() const114 int DisplayHardware::getWidth() const { return mWidth; }
getHeight() const115 int DisplayHardware::getHeight() const { return mHeight; }
getFormat() const116 PixelFormat DisplayHardware::getFormat() const { return mFormat; }
getMaxTextureSize() const117 uint32_t DisplayHardware::getMaxTextureSize() const { return mMaxTextureSize; }
118
getMaxViewportDims() const119 uint32_t DisplayHardware::getMaxViewportDims() const {
120 return mMaxViewportDims[0] < mMaxViewportDims[1] ?
121 mMaxViewportDims[0] : mMaxViewportDims[1];
122 }
123
selectConfigForPixelFormat(EGLDisplay dpy,EGLint const * attrs,PixelFormat format,EGLConfig * outConfig)124 static status_t selectConfigForPixelFormat(
125 EGLDisplay dpy,
126 EGLint const* attrs,
127 PixelFormat format,
128 EGLConfig* outConfig)
129 {
130 EGLConfig config = NULL;
131 EGLint numConfigs = -1, n=0;
132 eglGetConfigs(dpy, NULL, 0, &numConfigs);
133 EGLConfig* const configs = new EGLConfig[numConfigs];
134 eglChooseConfig(dpy, attrs, configs, numConfigs, &n);
135 for (int i=0 ; i<n ; i++) {
136 EGLint nativeVisualId = 0;
137 eglGetConfigAttrib(dpy, configs[i], EGL_NATIVE_VISUAL_ID, &nativeVisualId);
138 if (nativeVisualId>0 && format == nativeVisualId) {
139 *outConfig = configs[i];
140 delete [] configs;
141 return NO_ERROR;
142 }
143 }
144 delete [] configs;
145 return NAME_NOT_FOUND;
146 }
147
148
init(uint32_t dpy)149 void DisplayHardware::init(uint32_t dpy)
150 {
151 mNativeWindow = new FramebufferNativeWindow();
152 framebuffer_device_t const * fbDev = mNativeWindow->getDevice();
153 if (!fbDev) {
154 ALOGE("Display subsystem failed to initialize. check logs. exiting...");
155 exit(0);
156 }
157
158 int format;
159 ANativeWindow const * const window = mNativeWindow.get();
160 window->query(window, NATIVE_WINDOW_FORMAT, &format);
161 mDpiX = mNativeWindow->xdpi;
162 mDpiY = mNativeWindow->ydpi;
163 mRefreshRate = fbDev->fps;
164
165 if (mDpiX == 0 || mDpiY == 0) {
166 ALOGE("invalid screen resolution from fb HAL (xdpi=%f, ydpi=%f), "
167 "defaulting to 160 dpi", mDpiX, mDpiY);
168 mDpiX = mDpiY = 160;
169 }
170
171 class Density {
172 static int getDensityFromProperty(char const* propName) {
173 char property[PROPERTY_VALUE_MAX];
174 int density = 0;
175 if (property_get(propName, property, NULL) > 0) {
176 density = atoi(property);
177 }
178 return density;
179 }
180 public:
181 static int getEmuDensity() {
182 return getDensityFromProperty("qemu.sf.lcd_density"); }
183 static int getBuildDensity() {
184 return getDensityFromProperty("ro.sf.lcd_density"); }
185 };
186
187
188 // The density of the device is provided by a build property
189 mDensity = Density::getBuildDensity() / 160.0f;
190
191 if (mDensity == 0) {
192 // the build doesn't provide a density -- this is wrong!
193 // use xdpi instead
194 ALOGE("ro.sf.lcd_density must be defined as a build property");
195 mDensity = mDpiX / 160.0f;
196 }
197
198 if (Density::getEmuDensity()) {
199 // if "qemu.sf.lcd_density" is specified, it overrides everything
200 mDpiX = mDpiY = mDensity = Density::getEmuDensity();
201 mDensity /= 160.0f;
202 }
203
204
205
206 /* FIXME: this is a temporary HACK until we are able to report the refresh rate
207 * properly from the HAL. The WindowManagerService now relies on this value.
208 */
209 #ifndef REFRESH_RATE
210 mRefreshRate = fbDev->fps;
211 #else
212 mRefreshRate = REFRESH_RATE;
213 #warning "refresh rate set via makefile to REFRESH_RATE"
214 #endif
215
216 mRefreshPeriod = nsecs_t(1e9 / mRefreshRate);
217
218 EGLint w, h, dummy;
219 EGLint numConfigs=0;
220 EGLSurface surface;
221 EGLContext context;
222 EGLBoolean result;
223 status_t err;
224
225 // initialize EGL
226 EGLint attribs[] = {
227 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
228 EGL_NONE, 0,
229 EGL_NONE
230 };
231
232 // debug: disable h/w rendering
233 char property[PROPERTY_VALUE_MAX];
234 if (property_get("debug.sf.hw", property, NULL) > 0) {
235 if (atoi(property) == 0) {
236 ALOGW("H/W composition disabled");
237 attribs[2] = EGL_CONFIG_CAVEAT;
238 attribs[3] = EGL_SLOW_CONFIG;
239 }
240 }
241
242 // TODO: all the extensions below should be queried through
243 // eglGetProcAddress().
244
245 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
246 eglInitialize(display, NULL, NULL);
247 eglGetConfigs(display, NULL, 0, &numConfigs);
248
249 EGLConfig config = NULL;
250 err = selectConfigForPixelFormat(display, attribs, format, &config);
251 ALOGE_IF(err, "couldn't find an EGLConfig matching the screen format");
252
253 EGLint r,g,b,a;
254 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
255 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
256 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
257 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
258
259 if (mNativeWindow->isUpdateOnDemand()) {
260 mFlags |= PARTIAL_UPDATES;
261 }
262
263 if (eglGetConfigAttrib(display, config, EGL_CONFIG_CAVEAT, &dummy) == EGL_TRUE) {
264 if (dummy == EGL_SLOW_CONFIG)
265 mFlags |= SLOW_CONFIG;
266 }
267
268 /*
269 * Create our main surface
270 */
271
272 surface = eglCreateWindowSurface(display, config, mNativeWindow.get(), NULL);
273 eglQuerySurface(display, surface, EGL_WIDTH, &mWidth);
274 eglQuerySurface(display, surface, EGL_HEIGHT, &mHeight);
275
276 if (mFlags & PARTIAL_UPDATES) {
277 // if we have partial updates, we definitely don't need to
278 // preserve the backbuffer, which may be costly.
279 eglSurfaceAttrib(display, surface,
280 EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);
281 }
282
283 /*
284 * Create our OpenGL ES context
285 */
286
287 EGLint contextAttributes[] = {
288 #ifdef EGL_IMG_context_priority
289 #ifdef HAS_CONTEXT_PRIORITY
290 #warning "using EGL_IMG_context_priority"
291 EGL_CONTEXT_PRIORITY_LEVEL_IMG, EGL_CONTEXT_PRIORITY_HIGH_IMG,
292 #endif
293 #endif
294 EGL_NONE, EGL_NONE
295 };
296 context = eglCreateContext(display, config, NULL, contextAttributes);
297
298 mDisplay = display;
299 mConfig = config;
300 mSurface = surface;
301 mContext = context;
302 mFormat = fbDev->format;
303 mPageFlipCount = 0;
304
305 /*
306 * Gather OpenGL ES extensions
307 */
308
309 result = eglMakeCurrent(display, surface, surface, context);
310 if (!result) {
311 ALOGE("Couldn't create a working GLES context. check logs. exiting...");
312 exit(0);
313 }
314
315 GLExtensions& extensions(GLExtensions::getInstance());
316 extensions.initWithGLStrings(
317 glGetString(GL_VENDOR),
318 glGetString(GL_RENDERER),
319 glGetString(GL_VERSION),
320 glGetString(GL_EXTENSIONS),
321 eglQueryString(display, EGL_VENDOR),
322 eglQueryString(display, EGL_VERSION),
323 eglQueryString(display, EGL_EXTENSIONS));
324
325 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
326 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
327
328 ALOGI("EGL informations:");
329 ALOGI("# of configs : %d", numConfigs);
330 ALOGI("vendor : %s", extensions.getEglVendor());
331 ALOGI("version : %s", extensions.getEglVersion());
332 ALOGI("extensions: %s", extensions.getEglExtension());
333 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported");
334 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
335
336 ALOGI("OpenGL informations:");
337 ALOGI("vendor : %s", extensions.getVendor());
338 ALOGI("renderer : %s", extensions.getRenderer());
339 ALOGI("version : %s", extensions.getVersion());
340 ALOGI("extensions: %s", extensions.getExtension());
341 ALOGI("GL_MAX_TEXTURE_SIZE = %d", mMaxTextureSize);
342 ALOGI("GL_MAX_VIEWPORT_DIMS = %d x %d", mMaxViewportDims[0], mMaxViewportDims[1]);
343 ALOGI("flags = %08x", mFlags);
344
345 // Unbind the context from this thread
346 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
347
348
349 // initialize the H/W composer
350 mHwc = new HWComposer(mFlinger, *this, mRefreshPeriod);
351 if (mHwc->initCheck() == NO_ERROR) {
352 mHwc->setFrameBuffer(mDisplay, mSurface);
353 }
354 }
355
setVSyncHandler(const sp<VSyncHandler> & handler)356 void DisplayHardware::setVSyncHandler(const sp<VSyncHandler>& handler) {
357 Mutex::Autolock _l(mLock);
358 mVSyncHandler = handler;
359 }
360
eventControl(int event,int enabled)361 void DisplayHardware::eventControl(int event, int enabled) {
362 if (event == EVENT_VSYNC) {
363 mPowerHAL.vsyncHint(enabled);
364 }
365 mHwc->eventControl(event, enabled);
366 }
367
onVSyncReceived(int dpy,nsecs_t timestamp)368 void DisplayHardware::onVSyncReceived(int dpy, nsecs_t timestamp) {
369 sp<VSyncHandler> handler;
370 { // scope for the lock
371 Mutex::Autolock _l(mLock);
372 mLastHwVSync = timestamp;
373 if (mVSyncHandler != NULL) {
374 handler = mVSyncHandler.promote();
375 }
376 }
377
378 if (handler != NULL) {
379 handler->onVSyncReceived(dpy, timestamp);
380 }
381 }
382
getHwComposer() const383 HWComposer& DisplayHardware::getHwComposer() const {
384 return *mHwc;
385 }
386
387 /*
388 * Clean up. Throw out our local state.
389 *
390 * (It's entirely possible we'll never get here, since this is meant
391 * for real hardware, which doesn't restart.)
392 */
393
fini()394 void DisplayHardware::fini()
395 {
396 eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
397 eglTerminate(mDisplay);
398 }
399
releaseScreen() const400 void DisplayHardware::releaseScreen() const
401 {
402 DisplayHardwareBase::releaseScreen();
403 if (mHwc->initCheck() == NO_ERROR) {
404 mHwc->release();
405 }
406 }
407
acquireScreen() const408 void DisplayHardware::acquireScreen() const
409 {
410 DisplayHardwareBase::acquireScreen();
411 }
412
getPageFlipCount() const413 uint32_t DisplayHardware::getPageFlipCount() const {
414 return mPageFlipCount;
415 }
416
getRefreshTimestamp() const417 nsecs_t DisplayHardware::getRefreshTimestamp() const {
418 // this returns the last refresh timestamp.
419 // if the last one is not available, we estimate it based on
420 // the refresh period and whatever closest timestamp we have.
421 Mutex::Autolock _l(mLock);
422 nsecs_t now = systemTime(CLOCK_MONOTONIC);
423 return now - ((now - mLastHwVSync) % mRefreshPeriod);
424 }
425
getRefreshPeriod() const426 nsecs_t DisplayHardware::getRefreshPeriod() const {
427 return mRefreshPeriod;
428 }
429
compositionComplete() const430 status_t DisplayHardware::compositionComplete() const {
431 return mNativeWindow->compositionComplete();
432 }
433
flip(const Region & dirty) const434 void DisplayHardware::flip(const Region& dirty) const
435 {
436 checkGLErrors();
437
438 EGLDisplay dpy = mDisplay;
439 EGLSurface surface = mSurface;
440
441 #ifdef EGL_ANDROID_swap_rectangle
442 if (mFlags & SWAP_RECTANGLE) {
443 const Region newDirty(dirty.intersect(bounds()));
444 const Rect b(newDirty.getBounds());
445 eglSetSwapRectangleANDROID(dpy, surface,
446 b.left, b.top, b.width(), b.height());
447 }
448 #endif
449
450 if (mFlags & PARTIAL_UPDATES) {
451 mNativeWindow->setUpdateRectangle(dirty.getBounds());
452 }
453
454 mPageFlipCount++;
455
456 if (mHwc->initCheck() == NO_ERROR) {
457 mHwc->commit();
458 } else {
459 eglSwapBuffers(dpy, surface);
460 }
461 checkEGLErrors("eglSwapBuffers");
462
463 // for debugging
464 //glClearColor(1,0,0,0);
465 //glClear(GL_COLOR_BUFFER_BIT);
466 }
467
getFlags() const468 uint32_t DisplayHardware::getFlags() const
469 {
470 return mFlags;
471 }
472
makeCurrent() const473 void DisplayHardware::makeCurrent() const
474 {
475 eglMakeCurrent(mDisplay, mSurface, mSurface, mContext);
476 }
477
dump(String8 & res) const478 void DisplayHardware::dump(String8& res) const
479 {
480 mNativeWindow->dump(res);
481 }
482