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