HWComposer.cpp revision 10fbdb6059755f009e02f0ccc2b9d289beb6b086
1/* 2 * Copyright (C) 2010 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#define ATRACE_TAG ATRACE_TAG_GRAPHICS 18 19// Uncomment this to remove support for HWC_DEVICE_API_VERSION_0_3 and older 20// #define HWC_REMOVE_DEPRECATED_VERSIONS 1 21 22#include <stdint.h> 23#include <stdio.h> 24#include <stdlib.h> 25#include <string.h> 26#include <sys/types.h> 27 28#include <utils/Errors.h> 29#include <utils/String8.h> 30#include <utils/Thread.h> 31#include <utils/Trace.h> 32#include <utils/Vector.h> 33 34#include <hardware/hardware.h> 35#include <hardware/hwcomposer.h> 36 37#include <cutils/log.h> 38#include <cutils/properties.h> 39 40#include <EGL/egl.h> 41 42#include "LayerBase.h" 43#include "HWComposer.h" 44#include "SurfaceFlinger.h" 45 46namespace android { 47 48// --------------------------------------------------------------------------- 49// Support for HWC_DEVICE_API_VERSION_0_3 and older: 50// Since v0.3 is deprecated and support will be dropped soon, as much as 51// possible the code is written to target v1.0. When using a v0.3 HWC, we 52// allocate v0.3 structures, but assign them to v1.0 pointers. Fields that 53// exist in both versions are located at the same offset, so in most cases we 54// can just use the v1.0 pointer without branches or casts. 55 56#if HWC_REMOVE_DEPRECATED_VERSIONS 57// We need complete types with to satisfy semantic checks, even though the 58// code paths that use these won't get executed at runtime (and will likely be 59// dead-code-eliminated). When we remove the code to support v0.3 we can remove 60// these as well. 61typedef hwc_layer_1_t hwc_layer_t; 62typedef hwc_layer_list_1_t hwc_layer_list_t; 63typedef hwc_composer_device_1_t hwc_composer_device_t; 64#endif 65 66// This function assumes we've already rejected HWC's with lower-than-required 67// versions. Don't use it for the initial "does HWC meet requirements" check! 68static bool hwcHasVersion(const hwc_composer_device_1_t* hwc, uint32_t version) { 69 if (HWC_REMOVE_DEPRECATED_VERSIONS && 70 version <= HWC_DEVICE_API_VERSION_1_0) { 71 return true; 72 } else { 73 return hwc->common.version >= version; 74 } 75} 76 77static size_t sizeofHwcLayerList(const hwc_composer_device_1_t* hwc, 78 size_t numLayers) { 79 if (hwcHasVersion(hwc, HWC_DEVICE_API_VERSION_1_0)) { 80 return sizeof(hwc_layer_list_1_t) + numLayers*sizeof(hwc_layer_1_t); 81 } else { 82 return sizeof(hwc_layer_list_t) + numLayers*sizeof(hwc_layer_t); 83 } 84} 85 86// --------------------------------------------------------------------------- 87 88struct HWComposer::cb_context { 89 struct callbacks : public hwc_procs_t { 90 // these are here to facilitate the transition when adding 91 // new callbacks (an implementation can check for NULL before 92 // calling a new callback). 93 void (*zero[4])(void); 94 }; 95 callbacks procs; 96 HWComposer* hwc; 97}; 98 99// --------------------------------------------------------------------------- 100 101HWComposer::HWComposer( 102 const sp<SurfaceFlinger>& flinger, 103 EventHandler& handler, 104 nsecs_t refreshPeriod) 105 : mFlinger(flinger), 106 mModule(0), mHwc(0), mList(0), mCapacity(0), 107 mNumOVLayers(0), mNumFBLayers(0), 108 mDpy(EGL_NO_DISPLAY), mSur(EGL_NO_SURFACE), 109 mCBContext(new cb_context), 110 mEventHandler(handler), 111 mRefreshPeriod(refreshPeriod), 112 mVSyncCount(0), mDebugForceFakeVSync(false) 113{ 114 char value[PROPERTY_VALUE_MAX]; 115 property_get("debug.sf.no_hw_vsync", value, "0"); 116 mDebugForceFakeVSync = atoi(value); 117 118 bool needVSyncThread = false; 119 int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &mModule); 120 ALOGW_IF(err, "%s module not found", HWC_HARDWARE_MODULE_ID); 121 if (err == 0) { 122 err = hwc_open_1(mModule, &mHwc); 123 ALOGE_IF(err, "%s device failed to initialize (%s)", 124 HWC_HARDWARE_COMPOSER, strerror(-err)); 125 if (err == 0) { 126 if (HWC_REMOVE_DEPRECATED_VERSIONS && 127 mHwc->common.version < HWC_DEVICE_API_VERSION_1_0) { 128 ALOGE("%s device version %#x too old, will not be used", 129 HWC_HARDWARE_COMPOSER, mHwc->common.version); 130 hwc_close_1(mHwc); 131 mHwc = NULL; 132 } 133 } 134 135 if (mHwc) { 136 if (mHwc->registerProcs) { 137 mCBContext->hwc = this; 138 mCBContext->procs.invalidate = &hook_invalidate; 139 mCBContext->procs.vsync = &hook_vsync; 140 mHwc->registerProcs(mHwc, &mCBContext->procs); 141 memset(mCBContext->procs.zero, 0, sizeof(mCBContext->procs.zero)); 142 } 143 if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_0_3)) { 144 if (mDebugForceFakeVSync) { 145 // make sure to turn h/w vsync off in "fake vsync" mode 146 mHwc->methods->eventControl(mHwc, HWC_EVENT_VSYNC, 0); 147 } 148 } else { 149 needVSyncThread = true; 150 } 151 } 152 } else { 153 needVSyncThread = true; 154 } 155 156 if (needVSyncThread) { 157 // we don't have VSYNC support, we need to fake it 158 mVSyncThread = new VSyncThread(*this); 159 } 160} 161 162HWComposer::~HWComposer() { 163 eventControl(EVENT_VSYNC, 0); 164 free(mList); 165 if (mVSyncThread != NULL) { 166 mVSyncThread->requestExitAndWait(); 167 } 168 if (mHwc) { 169 hwc_close_1(mHwc); 170 } 171 delete mCBContext; 172} 173 174status_t HWComposer::initCheck() const { 175 return mHwc ? NO_ERROR : NO_INIT; 176} 177 178void HWComposer::hook_invalidate(struct hwc_procs* procs) { 179 reinterpret_cast<cb_context *>(procs)->hwc->invalidate(); 180} 181 182void HWComposer::hook_vsync(struct hwc_procs* procs, int dpy, int64_t timestamp) { 183 reinterpret_cast<cb_context *>(procs)->hwc->vsync(dpy, timestamp); 184} 185 186void HWComposer::invalidate() { 187 mFlinger->repaintEverything(); 188} 189 190void HWComposer::vsync(int dpy, int64_t timestamp) { 191 ATRACE_INT("VSYNC", ++mVSyncCount&1); 192 mEventHandler.onVSyncReceived(dpy, timestamp); 193} 194 195void HWComposer::eventControl(int event, int enabled) { 196 status_t err = NO_ERROR; 197 if (mHwc && mHwc->common.version >= HWC_DEVICE_API_VERSION_0_3) { 198 if (!mDebugForceFakeVSync) { 199 err = mHwc->methods->eventControl(mHwc, event, enabled); 200 // error here should not happen -- not sure what we should 201 // do if it does. 202 ALOGE_IF(err, "eventControl(%d, %d) failed %s", 203 event, enabled, strerror(-err)); 204 } 205 } 206 207 if (err == NO_ERROR && mVSyncThread != NULL) { 208 mVSyncThread->setEnabled(enabled); 209 } 210} 211 212void HWComposer::setFrameBuffer(EGLDisplay dpy, EGLSurface sur) { 213 mDpy = (hwc_display_t)dpy; 214 mSur = (hwc_surface_t)sur; 215} 216 217status_t HWComposer::createWorkList(size_t numLayers) { 218 if (mHwc) { 219 if (!mList || mCapacity < numLayers) { 220 free(mList); 221 size_t size = sizeofHwcLayerList(mHwc, numLayers); 222 mList = (hwc_layer_list_1_t*)malloc(size); 223 mCapacity = numLayers; 224 } 225 mList->flags = HWC_GEOMETRY_CHANGED; 226 mList->numHwLayers = numLayers; 227 } 228 return NO_ERROR; 229} 230 231status_t HWComposer::prepare() const { 232 int err = mHwc->prepare(mHwc, mList); 233 if (err == NO_ERROR) { 234 size_t numOVLayers = 0; 235 size_t numFBLayers = 0; 236 size_t count = mList->numHwLayers; 237 for (size_t i=0 ; i<count ; i++) { 238 hwc_layer_1_t* l = NULL; 239 if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) { 240 l = &mList->hwLayers[i]; 241 } else { 242 // mList really has hwc_layer_list_t memory layout 243 hwc_layer_list_t* list = (hwc_layer_list_t*)mList; 244 hwc_layer_t* layer = &list->hwLayers[i]; 245 l = (hwc_layer_1_t*)layer; 246 } 247 if (l->flags & HWC_SKIP_LAYER) { 248 l->compositionType = HWC_FRAMEBUFFER; 249 } 250 switch (l->compositionType) { 251 case HWC_OVERLAY: 252 numOVLayers++; 253 break; 254 case HWC_FRAMEBUFFER: 255 numFBLayers++; 256 break; 257 } 258 } 259 mNumOVLayers = numOVLayers; 260 mNumFBLayers = numFBLayers; 261 } 262 return (status_t)err; 263} 264 265size_t HWComposer::getLayerCount(int type) const { 266 switch (type) { 267 case HWC_OVERLAY: 268 return mNumOVLayers; 269 case HWC_FRAMEBUFFER: 270 return mNumFBLayers; 271 } 272 return 0; 273} 274 275status_t HWComposer::commit() const { 276 int err = mHwc->set(mHwc, mDpy, mSur, mList); 277 if (mList) { 278 mList->flags &= ~HWC_GEOMETRY_CHANGED; 279 } 280 return (status_t)err; 281} 282 283status_t HWComposer::release() const { 284 if (mHwc) { 285 if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_0_3)) { 286 mHwc->methods->eventControl(mHwc, HWC_EVENT_VSYNC, 0); 287 } 288 int err = mHwc->set(mHwc, NULL, NULL, NULL); 289 if (err < 0) { 290 return (status_t)err; 291 } 292 293 if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) { 294 if (mHwc->methods && mHwc->methods->blank) { 295 err = mHwc->methods->blank(mHwc, 1); 296 } 297 } 298 return (status_t)err; 299 } 300 return NO_ERROR; 301} 302 303status_t HWComposer::acquire() const { 304 if (mHwc) { 305 if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) { 306 if (mHwc->methods && mHwc->methods->blank) { 307 int err = mHwc->methods->blank(mHwc, 0); 308 return (status_t)err; 309 } 310 } 311 } 312 313 return NO_ERROR; 314} 315 316status_t HWComposer::disable() { 317 if (mHwc) { 318 free(mList); 319 mList = NULL; 320 int err = mHwc->prepare(mHwc, NULL); 321 return (status_t)err; 322 } 323 return NO_ERROR; 324} 325 326size_t HWComposer::getNumLayers() const { 327 return mList ? mList->numHwLayers : 0; 328} 329 330/* 331 * Helper template to implement a concrete HWCLayer 332 * This holds the pointer to the concrete hwc layer type 333 * and implements the "iterable" side of HWCLayer. 334 */ 335template<typename CONCRETE, typename HWCTYPE> 336class Iterable : public HWComposer::HWCLayer { 337protected: 338 HWCTYPE* const mLayerList; 339 HWCTYPE* mCurrentLayer; 340 Iterable(HWCTYPE* layer) : mLayerList(layer), mCurrentLayer(layer) { } 341 inline HWCTYPE const * getLayer() const { return mCurrentLayer; } 342 inline HWCTYPE* getLayer() { return mCurrentLayer; } 343 virtual ~Iterable() { } 344private: 345 // returns a copy of ourselves 346 virtual HWComposer::HWCLayer* dup() { 347 return new CONCRETE( static_cast<const CONCRETE&>(*this) ); 348 } 349 virtual status_t setLayer(size_t index) { 350 mCurrentLayer = &mLayerList[index]; 351 return NO_ERROR; 352 } 353}; 354 355// #if !HWC_REMOVE_DEPRECATED_VERSIONS 356/* 357 * Concrete implementation of HWCLayer for HWC_DEVICE_API_VERSION_0_3 358 * This implements the HWCLayer side of HWCIterableLayer. 359 */ 360class HWCLayerVersion0 : public Iterable<HWCLayerVersion0, hwc_layer_t> { 361public: 362 HWCLayerVersion0(hwc_layer_t* layer) 363 : Iterable<HWCLayerVersion0, hwc_layer_t>(layer) { } 364 365 virtual int32_t getCompositionType() const { 366 return getLayer()->compositionType; 367 } 368 virtual uint32_t getHints() const { 369 return getLayer()->hints; 370 } 371 virtual int getAndResetReleaseFenceFd() { 372 // not supported on VERSION_03 373 return -1; 374 } 375 virtual void setAcquireFenceFd(int fenceFd) { 376 if (fenceFd != -1) { 377 ALOGE("HWC 0.x can't handle acquire fences"); 378 close(fenceFd); 379 } 380 } 381 382 virtual void setDefaultState() { 383 getLayer()->compositionType = HWC_FRAMEBUFFER; 384 getLayer()->hints = 0; 385 getLayer()->flags = HWC_SKIP_LAYER; 386 getLayer()->transform = 0; 387 getLayer()->blending = HWC_BLENDING_NONE; 388 getLayer()->visibleRegionScreen.numRects = 0; 389 getLayer()->visibleRegionScreen.rects = NULL; 390 } 391 virtual void setSkip(bool skip) { 392 if (skip) { 393 getLayer()->flags |= HWC_SKIP_LAYER; 394 } else { 395 getLayer()->flags &= ~HWC_SKIP_LAYER; 396 } 397 } 398 virtual void setBlending(uint32_t blending) { 399 getLayer()->blending = blending; 400 } 401 virtual void setTransform(uint32_t transform) { 402 getLayer()->transform = transform; 403 } 404 virtual void setFrame(const Rect& frame) { 405 reinterpret_cast<Rect&>(getLayer()->displayFrame) = frame; 406 } 407 virtual void setCrop(const Rect& crop) { 408 reinterpret_cast<Rect&>(getLayer()->sourceCrop) = crop; 409 } 410 virtual void setVisibleRegionScreen(const Region& reg) { 411 getLayer()->visibleRegionScreen.rects = 412 reinterpret_cast<hwc_rect_t const *>( 413 reg.getArray(&getLayer()->visibleRegionScreen.numRects)); 414 } 415 virtual void setBuffer(const sp<GraphicBuffer>& buffer) { 416 if (buffer == 0 || buffer->handle == 0) { 417 getLayer()->compositionType = HWC_FRAMEBUFFER; 418 getLayer()->flags |= HWC_SKIP_LAYER; 419 getLayer()->handle = 0; 420 } else { 421 getLayer()->handle = buffer->handle; 422 } 423 } 424}; 425// #endif // !HWC_REMOVE_DEPRECATED_VERSIONS 426 427/* 428 * Concrete implementation of HWCLayer for HWC_DEVICE_API_VERSION_1_0. 429 * This implements the HWCLayer side of HWCIterableLayer. 430 */ 431class HWCLayerVersion1 : public Iterable<HWCLayerVersion1, hwc_layer_1_t> { 432public: 433 HWCLayerVersion1(hwc_layer_1_t* layer) 434 : Iterable<HWCLayerVersion1, hwc_layer_1_t>(layer) { } 435 436 virtual int32_t getCompositionType() const { 437 return getLayer()->compositionType; 438 } 439 virtual uint32_t getHints() const { 440 return getLayer()->hints; 441 } 442 virtual int getAndResetReleaseFenceFd() { 443 int fd = getLayer()->releaseFenceFd; 444 getLayer()->releaseFenceFd = -1; 445 return fd; 446 } 447 virtual void setAcquireFenceFd(int fenceFd) { 448 getLayer()->acquireFenceFd = fenceFd; 449 } 450 451 virtual void setDefaultState() { 452 getLayer()->compositionType = HWC_FRAMEBUFFER; 453 getLayer()->hints = 0; 454 getLayer()->flags = HWC_SKIP_LAYER; 455 getLayer()->transform = 0; 456 getLayer()->blending = HWC_BLENDING_NONE; 457 getLayer()->visibleRegionScreen.numRects = 0; 458 getLayer()->visibleRegionScreen.rects = NULL; 459 getLayer()->acquireFenceFd = -1; 460 getLayer()->releaseFenceFd = -1; 461 } 462 virtual void setSkip(bool skip) { 463 if (skip) { 464 getLayer()->flags |= HWC_SKIP_LAYER; 465 } else { 466 getLayer()->flags &= ~HWC_SKIP_LAYER; 467 } 468 } 469 virtual void setBlending(uint32_t blending) { 470 getLayer()->blending = blending; 471 } 472 virtual void setTransform(uint32_t transform) { 473 getLayer()->transform = transform; 474 } 475 virtual void setFrame(const Rect& frame) { 476 reinterpret_cast<Rect&>(getLayer()->displayFrame) = frame; 477 } 478 virtual void setCrop(const Rect& crop) { 479 reinterpret_cast<Rect&>(getLayer()->sourceCrop) = crop; 480 } 481 virtual void setVisibleRegionScreen(const Region& reg) { 482 getLayer()->visibleRegionScreen.rects = 483 reinterpret_cast<hwc_rect_t const *>( 484 reg.getArray(&getLayer()->visibleRegionScreen.numRects)); 485 } 486 virtual void setBuffer(const sp<GraphicBuffer>& buffer) { 487 if (buffer == 0 || buffer->handle == 0) { 488 getLayer()->compositionType = HWC_FRAMEBUFFER; 489 getLayer()->flags |= HWC_SKIP_LAYER; 490 getLayer()->handle = 0; 491 } else { 492 getLayer()->handle = buffer->handle; 493 } 494 } 495}; 496 497/* 498 * returns an iterator initialized at a given index in the layer list 499 */ 500HWComposer::LayerListIterator HWComposer::getLayerIterator(size_t index) { 501 if (!mList || index > mList->numHwLayers) { 502 return LayerListIterator(); 503 } 504 if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) { 505 return LayerListIterator(new HWCLayerVersion1(mList->hwLayers), index); 506 } else { 507 hwc_layer_list_t* list0 = (hwc_layer_list_t*)mList; 508 return LayerListIterator(new HWCLayerVersion0(list0->hwLayers), index); 509 } 510} 511 512/* 513 * returns an iterator on the beginning of the layer list 514 */ 515HWComposer::LayerListIterator HWComposer::begin() { 516 return getLayerIterator(0); 517} 518 519/* 520 * returns an iterator on the end of the layer list 521 */ 522HWComposer::LayerListIterator HWComposer::end() { 523 return getLayerIterator(getNumLayers()); 524} 525 526 527 528void HWComposer::dump(String8& result, char* buffer, size_t SIZE, 529 const Vector< sp<LayerBase> >& visibleLayersSortedByZ) const { 530 if (mHwc && mList) { 531 result.append("Hardware Composer state:\n"); 532 result.appendFormat(" mDebugForceFakeVSync=%d\n", 533 mDebugForceFakeVSync); 534 result.appendFormat(" numHwLayers=%u, flags=%08x\n", 535 mList->numHwLayers, mList->flags); 536 result.append( 537 " type | handle | hints | flags | tr | blend | format | source crop | frame name \n" 538 "----------+----------+----------+----------+----+-------+----------+---------------------------+--------------------------------\n"); 539 // " ________ | ________ | ________ | ________ | __ | _____ | ________ | [_____,_____,_____,_____] | [_____,_____,_____,_____] 540 for (size_t i=0 ; i<mList->numHwLayers ; i++) { 541 hwc_layer_1_t l; 542 if (hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_1_0)) { 543 l = mList->hwLayers[i]; 544 } else { 545 hwc_layer_list_t* list0 = (hwc_layer_list_t*)mList; 546 *(hwc_layer_t*)&l = list0->hwLayers[i]; 547 l.acquireFenceFd = l.releaseFenceFd = -1; 548 } 549 const sp<LayerBase> layer(visibleLayersSortedByZ[i]); 550 int32_t format = -1; 551 if (layer->getLayer() != NULL) { 552 const sp<GraphicBuffer>& buffer(layer->getLayer()->getActiveBuffer()); 553 if (buffer != NULL) { 554 format = buffer->getPixelFormat(); 555 } 556 } 557 result.appendFormat( 558 " %8s | %08x | %08x | %08x | %02x | %05x | %08x | [%5d,%5d,%5d,%5d] | [%5d,%5d,%5d,%5d] %s\n", 559 l.compositionType ? "OVERLAY" : "FB", 560 intptr_t(l.handle), l.hints, l.flags, l.transform, l.blending, format, 561 l.sourceCrop.left, l.sourceCrop.top, l.sourceCrop.right, l.sourceCrop.bottom, 562 l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom, 563 layer->getName().string()); 564 } 565 } 566 if (mHwc && hwcHasVersion(mHwc, HWC_DEVICE_API_VERSION_0_1) && mHwc->dump) { 567 mHwc->dump(mHwc, buffer, SIZE); 568 result.append(buffer); 569 } 570} 571 572// --------------------------------------------------------------------------- 573 574HWComposer::VSyncThread::VSyncThread(HWComposer& hwc) 575 : mHwc(hwc), mEnabled(false), 576 mNextFakeVSync(0), 577 mRefreshPeriod(hwc.mRefreshPeriod) 578{ 579} 580 581void HWComposer::VSyncThread::setEnabled(bool enabled) { 582 Mutex::Autolock _l(mLock); 583 mEnabled = enabled; 584 mCondition.signal(); 585} 586 587void HWComposer::VSyncThread::onFirstRef() { 588 run("VSyncThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE); 589} 590 591bool HWComposer::VSyncThread::threadLoop() { 592 { // scope for lock 593 Mutex::Autolock _l(mLock); 594 while (!mEnabled) { 595 mCondition.wait(mLock); 596 } 597 } 598 599 const nsecs_t period = mRefreshPeriod; 600 const nsecs_t now = systemTime(CLOCK_MONOTONIC); 601 nsecs_t next_vsync = mNextFakeVSync; 602 nsecs_t sleep = next_vsync - now; 603 if (sleep < 0) { 604 // we missed, find where the next vsync should be 605 sleep = (period - ((now - next_vsync) % period)); 606 next_vsync = now + sleep; 607 } 608 mNextFakeVSync = next_vsync + period; 609 610 struct timespec spec; 611 spec.tv_sec = next_vsync / 1000000000; 612 spec.tv_nsec = next_vsync % 1000000000; 613 614 int err; 615 do { 616 err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL); 617 } while (err<0 && errno == EINTR); 618 619 if (err == 0) { 620 mHwc.mEventHandler.onVSyncReceived(0, next_vsync); 621 } 622 623 return true; 624} 625 626// --------------------------------------------------------------------------- 627}; // namespace android 628