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 LOG_TAG "Surface" 18 #define ATRACE_TAG ATRACE_TAG_GRAPHICS 19 //#define LOG_NDEBUG 0 20 21 #include <gui/Surface.h> 22 23 #include <inttypes.h> 24 25 #include <android/native_window.h> 26 27 #include <utils/Log.h> 28 #include <utils/Trace.h> 29 #include <utils/NativeHandle.h> 30 31 #include <ui/DisplayStatInfo.h> 32 #include <ui/Fence.h> 33 #include <ui/HdrCapabilities.h> 34 #include <ui/Region.h> 35 36 #include <gui/BufferItem.h> 37 #include <gui/IProducerListener.h> 38 39 #include <gui/ISurfaceComposer.h> 40 #include <private/gui/ComposerService.h> 41 42 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h> 43 #include <configstore/Utils.h> 44 45 namespace android { 46 47 Surface::Surface(const sp<IGraphicBufferProducer>& bufferProducer, bool controlledByApp) 48 : mGraphicBufferProducer(bufferProducer), 49 mCrop(Rect::EMPTY_RECT), 50 mBufferAge(0), 51 mGenerationNumber(0), 52 mSharedBufferMode(false), 53 mAutoRefresh(false), 54 mSharedBufferSlot(BufferItem::INVALID_BUFFER_SLOT), 55 mSharedBufferHasBeenQueued(false), 56 mQueriedSupportedTimestamps(false), 57 mFrameTimestampsSupportsPresent(false), 58 mEnableFrameTimestamps(false), 59 mFrameEventHistory(std::make_unique<ProducerFrameEventHistory>()) { 60 // Initialize the ANativeWindow function pointers. 61 ANativeWindow::setSwapInterval = hook_setSwapInterval; 62 ANativeWindow::dequeueBuffer = hook_dequeueBuffer; 63 ANativeWindow::cancelBuffer = hook_cancelBuffer; 64 ANativeWindow::queueBuffer = hook_queueBuffer; 65 ANativeWindow::query = hook_query; 66 ANativeWindow::perform = hook_perform; 67 68 ANativeWindow::dequeueBuffer_DEPRECATED = hook_dequeueBuffer_DEPRECATED; 69 ANativeWindow::cancelBuffer_DEPRECATED = hook_cancelBuffer_DEPRECATED; 70 ANativeWindow::lockBuffer_DEPRECATED = hook_lockBuffer_DEPRECATED; 71 ANativeWindow::queueBuffer_DEPRECATED = hook_queueBuffer_DEPRECATED; 72 73 const_cast<int&>(ANativeWindow::minSwapInterval) = 0; 74 const_cast<int&>(ANativeWindow::maxSwapInterval) = 1; 75 76 mReqWidth = 0; 77 mReqHeight = 0; 78 mReqFormat = 0; 79 mReqUsage = 0; 80 mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO; 81 mDataSpace = HAL_DATASPACE_UNKNOWN; 82 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE; 83 mTransform = 0; 84 mStickyTransform = 0; 85 mDefaultWidth = 0; 86 mDefaultHeight = 0; 87 mUserWidth = 0; 88 mUserHeight = 0; 89 mTransformHint = 0; 90 mConsumerRunningBehind = false; 91 mConnectedToCpu = false; 92 mProducerControlledByApp = controlledByApp; 93 mSwapIntervalZero = false; 94 } 95 96 Surface::~Surface() { 97 if (mConnectedToCpu) { 98 Surface::disconnect(NATIVE_WINDOW_API_CPU); 99 } 100 } 101 102 sp<ISurfaceComposer> Surface::composerService() const { 103 return ComposerService::getComposerService(); 104 } 105 106 nsecs_t Surface::now() const { 107 return systemTime(); 108 } 109 110 sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const { 111 return mGraphicBufferProducer; 112 } 113 114 void Surface::setSidebandStream(const sp<NativeHandle>& stream) { 115 mGraphicBufferProducer->setSidebandStream(stream); 116 } 117 118 void Surface::allocateBuffers() { 119 uint32_t reqWidth = mReqWidth ? mReqWidth : mUserWidth; 120 uint32_t reqHeight = mReqHeight ? mReqHeight : mUserHeight; 121 mGraphicBufferProducer->allocateBuffers(reqWidth, reqHeight, 122 mReqFormat, mReqUsage); 123 } 124 125 status_t Surface::setGenerationNumber(uint32_t generation) { 126 status_t result = mGraphicBufferProducer->setGenerationNumber(generation); 127 if (result == NO_ERROR) { 128 mGenerationNumber = generation; 129 } 130 return result; 131 } 132 133 uint64_t Surface::getNextFrameNumber() const { 134 Mutex::Autolock lock(mMutex); 135 return mNextFrameNumber; 136 } 137 138 String8 Surface::getConsumerName() const { 139 return mGraphicBufferProducer->getConsumerName(); 140 } 141 142 status_t Surface::setDequeueTimeout(nsecs_t timeout) { 143 return mGraphicBufferProducer->setDequeueTimeout(timeout); 144 } 145 146 status_t Surface::getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer, 147 sp<Fence>* outFence, float outTransformMatrix[16]) { 148 return mGraphicBufferProducer->getLastQueuedBuffer(outBuffer, outFence, 149 outTransformMatrix); 150 } 151 152 status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) { 153 ATRACE_CALL(); 154 155 DisplayStatInfo stats; 156 status_t err = composerService()->getDisplayStats(NULL, &stats); 157 158 *outRefreshDuration = stats.vsyncPeriod; 159 160 return NO_ERROR; 161 } 162 163 void Surface::enableFrameTimestamps(bool enable) { 164 Mutex::Autolock lock(mMutex); 165 // If going from disabled to enabled, get the initial values for 166 // compositor and display timing. 167 if (!mEnableFrameTimestamps && enable) { 168 FrameEventHistoryDelta delta; 169 mGraphicBufferProducer->getFrameTimestamps(&delta); 170 mFrameEventHistory->applyDelta(delta); 171 } 172 mEnableFrameTimestamps = enable; 173 } 174 175 status_t Surface::getCompositorTiming( 176 nsecs_t* compositeDeadline, nsecs_t* compositeInterval, 177 nsecs_t* compositeToPresentLatency) { 178 Mutex::Autolock lock(mMutex); 179 if (!mEnableFrameTimestamps) { 180 return INVALID_OPERATION; 181 } 182 183 if (compositeDeadline != nullptr) { 184 *compositeDeadline = 185 mFrameEventHistory->getNextCompositeDeadline(now()); 186 } 187 if (compositeInterval != nullptr) { 188 *compositeInterval = mFrameEventHistory->getCompositeInterval(); 189 } 190 if (compositeToPresentLatency != nullptr) { 191 *compositeToPresentLatency = 192 mFrameEventHistory->getCompositeToPresentLatency(); 193 } 194 return NO_ERROR; 195 } 196 197 static bool checkConsumerForUpdates( 198 const FrameEvents* e, const uint64_t lastFrameNumber, 199 const nsecs_t* outLatchTime, 200 const nsecs_t* outFirstRefreshStartTime, 201 const nsecs_t* outLastRefreshStartTime, 202 const nsecs_t* outGpuCompositionDoneTime, 203 const nsecs_t* outDisplayPresentTime, 204 const nsecs_t* outDequeueReadyTime, 205 const nsecs_t* outReleaseTime) { 206 bool checkForLatch = (outLatchTime != nullptr) && !e->hasLatchInfo(); 207 bool checkForFirstRefreshStart = (outFirstRefreshStartTime != nullptr) && 208 !e->hasFirstRefreshStartInfo(); 209 bool checkForGpuCompositionDone = (outGpuCompositionDoneTime != nullptr) && 210 !e->hasGpuCompositionDoneInfo(); 211 bool checkForDisplayPresent = (outDisplayPresentTime != nullptr) && 212 !e->hasDisplayPresentInfo(); 213 214 // LastRefreshStart, DequeueReady, and Release are never available for the 215 // last frame. 216 bool checkForLastRefreshStart = (outLastRefreshStartTime != nullptr) && 217 !e->hasLastRefreshStartInfo() && 218 (e->frameNumber != lastFrameNumber); 219 bool checkForDequeueReady = (outDequeueReadyTime != nullptr) && 220 !e->hasDequeueReadyInfo() && (e->frameNumber != lastFrameNumber); 221 bool checkForRelease = (outReleaseTime != nullptr) && 222 !e->hasReleaseInfo() && (e->frameNumber != lastFrameNumber); 223 224 // RequestedPresent and Acquire info are always available producer-side. 225 return checkForLatch || checkForFirstRefreshStart || 226 checkForLastRefreshStart || checkForGpuCompositionDone || 227 checkForDisplayPresent || checkForDequeueReady || checkForRelease; 228 } 229 230 static void getFrameTimestamp(nsecs_t *dst, const nsecs_t& src) { 231 if (dst != nullptr) { 232 // We always get valid timestamps for these eventually. 233 *dst = (src == FrameEvents::TIMESTAMP_PENDING) ? 234 NATIVE_WINDOW_TIMESTAMP_PENDING : src; 235 } 236 } 237 238 static void getFrameTimestampFence(nsecs_t *dst, 239 const std::shared_ptr<FenceTime>& src, bool fenceShouldBeKnown) { 240 if (dst != nullptr) { 241 if (!fenceShouldBeKnown) { 242 *dst = NATIVE_WINDOW_TIMESTAMP_PENDING; 243 return; 244 } 245 246 nsecs_t signalTime = src->getSignalTime(); 247 *dst = (signalTime == Fence::SIGNAL_TIME_PENDING) ? 248 NATIVE_WINDOW_TIMESTAMP_PENDING : 249 (signalTime == Fence::SIGNAL_TIME_INVALID) ? 250 NATIVE_WINDOW_TIMESTAMP_INVALID : 251 signalTime; 252 } 253 } 254 255 status_t Surface::getFrameTimestamps(uint64_t frameNumber, 256 nsecs_t* outRequestedPresentTime, nsecs_t* outAcquireTime, 257 nsecs_t* outLatchTime, nsecs_t* outFirstRefreshStartTime, 258 nsecs_t* outLastRefreshStartTime, nsecs_t* outGpuCompositionDoneTime, 259 nsecs_t* outDisplayPresentTime, nsecs_t* outDequeueReadyTime, 260 nsecs_t* outReleaseTime) { 261 ATRACE_CALL(); 262 263 Mutex::Autolock lock(mMutex); 264 265 if (!mEnableFrameTimestamps) { 266 return INVALID_OPERATION; 267 } 268 269 // Verify the requested timestamps are supported. 270 querySupportedTimestampsLocked(); 271 if (outDisplayPresentTime != nullptr && !mFrameTimestampsSupportsPresent) { 272 return BAD_VALUE; 273 } 274 275 FrameEvents* events = mFrameEventHistory->getFrame(frameNumber); 276 if (events == nullptr) { 277 // If the entry isn't available in the producer, it's definitely not 278 // available in the consumer. 279 return NAME_NOT_FOUND; 280 } 281 282 // Update our cache of events if the requested events are not available. 283 if (checkConsumerForUpdates(events, mLastFrameNumber, 284 outLatchTime, outFirstRefreshStartTime, outLastRefreshStartTime, 285 outGpuCompositionDoneTime, outDisplayPresentTime, 286 outDequeueReadyTime, outReleaseTime)) { 287 FrameEventHistoryDelta delta; 288 mGraphicBufferProducer->getFrameTimestamps(&delta); 289 mFrameEventHistory->applyDelta(delta); 290 events = mFrameEventHistory->getFrame(frameNumber); 291 } 292 293 if (events == nullptr) { 294 // The entry was available before the update, but was overwritten 295 // after the update. Make sure not to send the wrong frame's data. 296 return NAME_NOT_FOUND; 297 } 298 299 getFrameTimestamp(outRequestedPresentTime, events->requestedPresentTime); 300 getFrameTimestamp(outLatchTime, events->latchTime); 301 getFrameTimestamp(outFirstRefreshStartTime, events->firstRefreshStartTime); 302 getFrameTimestamp(outLastRefreshStartTime, events->lastRefreshStartTime); 303 getFrameTimestamp(outDequeueReadyTime, events->dequeueReadyTime); 304 305 getFrameTimestampFence(outAcquireTime, events->acquireFence, 306 events->hasAcquireInfo()); 307 getFrameTimestampFence(outGpuCompositionDoneTime, 308 events->gpuCompositionDoneFence, 309 events->hasGpuCompositionDoneInfo()); 310 getFrameTimestampFence(outDisplayPresentTime, events->displayPresentFence, 311 events->hasDisplayPresentInfo()); 312 getFrameTimestampFence(outReleaseTime, events->releaseFence, 313 events->hasReleaseInfo()); 314 315 return NO_ERROR; 316 } 317 318 using namespace android::hardware::configstore; 319 using namespace android::hardware::configstore::V1_0; 320 321 status_t Surface::getWideColorSupport(bool* supported) { 322 ATRACE_CALL(); 323 324 sp<IBinder> display( 325 composerService()->getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain)); 326 Vector<android_color_mode_t> colorModes; 327 status_t err = 328 composerService()->getDisplayColorModes(display, &colorModes); 329 330 if (err) 331 return err; 332 333 bool wideColorBoardConfig = 334 getBool<ISurfaceFlingerConfigs, 335 &ISurfaceFlingerConfigs::hasWideColorDisplay>(false); 336 337 *supported = false; 338 for (android_color_mode_t colorMode : colorModes) { 339 switch (colorMode) { 340 case HAL_COLOR_MODE_DISPLAY_P3: 341 case HAL_COLOR_MODE_ADOBE_RGB: 342 case HAL_COLOR_MODE_DCI_P3: 343 if (wideColorBoardConfig) { 344 *supported = true; 345 } 346 break; 347 default: 348 break; 349 } 350 } 351 352 return NO_ERROR; 353 } 354 355 status_t Surface::getHdrSupport(bool* supported) { 356 ATRACE_CALL(); 357 358 sp<IBinder> display( 359 composerService()->getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain)); 360 HdrCapabilities hdrCapabilities; 361 status_t err = 362 composerService()->getHdrCapabilities(display, &hdrCapabilities); 363 364 if (err) 365 return err; 366 367 *supported = !hdrCapabilities.getSupportedHdrTypes().empty(); 368 369 return NO_ERROR; 370 } 371 372 int Surface::hook_setSwapInterval(ANativeWindow* window, int interval) { 373 Surface* c = getSelf(window); 374 return c->setSwapInterval(interval); 375 } 376 377 int Surface::hook_dequeueBuffer(ANativeWindow* window, 378 ANativeWindowBuffer** buffer, int* fenceFd) { 379 Surface* c = getSelf(window); 380 return c->dequeueBuffer(buffer, fenceFd); 381 } 382 383 int Surface::hook_cancelBuffer(ANativeWindow* window, 384 ANativeWindowBuffer* buffer, int fenceFd) { 385 Surface* c = getSelf(window); 386 return c->cancelBuffer(buffer, fenceFd); 387 } 388 389 int Surface::hook_queueBuffer(ANativeWindow* window, 390 ANativeWindowBuffer* buffer, int fenceFd) { 391 Surface* c = getSelf(window); 392 return c->queueBuffer(buffer, fenceFd); 393 } 394 395 int Surface::hook_dequeueBuffer_DEPRECATED(ANativeWindow* window, 396 ANativeWindowBuffer** buffer) { 397 Surface* c = getSelf(window); 398 ANativeWindowBuffer* buf; 399 int fenceFd = -1; 400 int result = c->dequeueBuffer(&buf, &fenceFd); 401 if (result != OK) { 402 return result; 403 } 404 sp<Fence> fence(new Fence(fenceFd)); 405 int waitResult = fence->waitForever("dequeueBuffer_DEPRECATED"); 406 if (waitResult != OK) { 407 ALOGE("dequeueBuffer_DEPRECATED: Fence::wait returned an error: %d", 408 waitResult); 409 c->cancelBuffer(buf, -1); 410 return waitResult; 411 } 412 *buffer = buf; 413 return result; 414 } 415 416 int Surface::hook_cancelBuffer_DEPRECATED(ANativeWindow* window, 417 ANativeWindowBuffer* buffer) { 418 Surface* c = getSelf(window); 419 return c->cancelBuffer(buffer, -1); 420 } 421 422 int Surface::hook_lockBuffer_DEPRECATED(ANativeWindow* window, 423 ANativeWindowBuffer* buffer) { 424 Surface* c = getSelf(window); 425 return c->lockBuffer_DEPRECATED(buffer); 426 } 427 428 int Surface::hook_queueBuffer_DEPRECATED(ANativeWindow* window, 429 ANativeWindowBuffer* buffer) { 430 Surface* c = getSelf(window); 431 return c->queueBuffer(buffer, -1); 432 } 433 434 int Surface::hook_query(const ANativeWindow* window, 435 int what, int* value) { 436 const Surface* c = getSelf(window); 437 return c->query(what, value); 438 } 439 440 int Surface::hook_perform(ANativeWindow* window, int operation, ...) { 441 va_list args; 442 va_start(args, operation); 443 Surface* c = getSelf(window); 444 int result = c->perform(operation, args); 445 va_end(args); 446 return result; 447 } 448 449 int Surface::setSwapInterval(int interval) { 450 ATRACE_CALL(); 451 // EGL specification states: 452 // interval is silently clamped to minimum and maximum implementation 453 // dependent values before being stored. 454 455 if (interval < minSwapInterval) 456 interval = minSwapInterval; 457 458 if (interval > maxSwapInterval) 459 interval = maxSwapInterval; 460 461 mSwapIntervalZero = (interval == 0); 462 mGraphicBufferProducer->setAsyncMode(mSwapIntervalZero); 463 464 return NO_ERROR; 465 } 466 467 int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) { 468 ATRACE_CALL(); 469 ALOGV("Surface::dequeueBuffer"); 470 471 uint32_t reqWidth; 472 uint32_t reqHeight; 473 PixelFormat reqFormat; 474 uint64_t reqUsage; 475 bool enableFrameTimestamps; 476 477 { 478 Mutex::Autolock lock(mMutex); 479 if (mReportRemovedBuffers) { 480 mRemovedBuffers.clear(); 481 } 482 483 reqWidth = mReqWidth ? mReqWidth : mUserWidth; 484 reqHeight = mReqHeight ? mReqHeight : mUserHeight; 485 486 reqFormat = mReqFormat; 487 reqUsage = mReqUsage; 488 489 enableFrameTimestamps = mEnableFrameTimestamps; 490 491 if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot != 492 BufferItem::INVALID_BUFFER_SLOT) { 493 sp<GraphicBuffer>& gbuf(mSlots[mSharedBufferSlot].buffer); 494 if (gbuf != NULL) { 495 *buffer = gbuf.get(); 496 *fenceFd = -1; 497 return OK; 498 } 499 } 500 } // Drop the lock so that we can still touch the Surface while blocking in IGBP::dequeueBuffer 501 502 int buf = -1; 503 sp<Fence> fence; 504 nsecs_t startTime = systemTime(); 505 506 FrameEventHistoryDelta frameTimestamps; 507 status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, reqWidth, reqHeight, 508 reqFormat, reqUsage, &mBufferAge, 509 enableFrameTimestamps ? &frameTimestamps 510 : nullptr); 511 mLastDequeueDuration = systemTime() - startTime; 512 513 if (result < 0) { 514 ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer" 515 "(%d, %d, %d, %#" PRIx64 ") failed: %d", 516 reqWidth, reqHeight, reqFormat, reqUsage, result); 517 return result; 518 } 519 520 if (buf < 0 || buf >= NUM_BUFFER_SLOTS) { 521 ALOGE("dequeueBuffer: IGraphicBufferProducer returned invalid slot number %d", buf); 522 android_errorWriteLog(0x534e4554, "36991414"); // SafetyNet logging 523 return FAILED_TRANSACTION; 524 } 525 526 Mutex::Autolock lock(mMutex); 527 528 // Write this while holding the mutex 529 mLastDequeueStartTime = startTime; 530 531 sp<GraphicBuffer>& gbuf(mSlots[buf].buffer); 532 533 // this should never happen 534 ALOGE_IF(fence == NULL, "Surface::dequeueBuffer: received null Fence! buf=%d", buf); 535 536 if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) { 537 freeAllBuffers(); 538 } 539 540 if (enableFrameTimestamps) { 541 mFrameEventHistory->applyDelta(frameTimestamps); 542 } 543 544 if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == nullptr) { 545 if (mReportRemovedBuffers && (gbuf != nullptr)) { 546 mRemovedBuffers.push_back(gbuf); 547 } 548 result = mGraphicBufferProducer->requestBuffer(buf, &gbuf); 549 if (result != NO_ERROR) { 550 ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result); 551 mGraphicBufferProducer->cancelBuffer(buf, fence); 552 return result; 553 } 554 } 555 556 if (fence->isValid()) { 557 *fenceFd = fence->dup(); 558 if (*fenceFd == -1) { 559 ALOGE("dequeueBuffer: error duping fence: %d", errno); 560 // dup() should never fail; something is badly wrong. Soldier on 561 // and hope for the best; the worst that should happen is some 562 // visible corruption that lasts until the next frame. 563 } 564 } else { 565 *fenceFd = -1; 566 } 567 568 *buffer = gbuf.get(); 569 570 if (mSharedBufferMode && mAutoRefresh) { 571 mSharedBufferSlot = buf; 572 mSharedBufferHasBeenQueued = false; 573 } else if (mSharedBufferSlot == buf) { 574 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT; 575 mSharedBufferHasBeenQueued = false; 576 } 577 578 return OK; 579 } 580 581 int Surface::cancelBuffer(android_native_buffer_t* buffer, 582 int fenceFd) { 583 ATRACE_CALL(); 584 ALOGV("Surface::cancelBuffer"); 585 Mutex::Autolock lock(mMutex); 586 int i = getSlotFromBufferLocked(buffer); 587 if (i < 0) { 588 if (fenceFd >= 0) { 589 close(fenceFd); 590 } 591 return i; 592 } 593 if (mSharedBufferSlot == i && mSharedBufferHasBeenQueued) { 594 if (fenceFd >= 0) { 595 close(fenceFd); 596 } 597 return OK; 598 } 599 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE); 600 mGraphicBufferProducer->cancelBuffer(i, fence); 601 602 if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot == i) { 603 mSharedBufferHasBeenQueued = true; 604 } 605 606 return OK; 607 } 608 609 int Surface::getSlotFromBufferLocked( 610 android_native_buffer_t* buffer) const { 611 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 612 if (mSlots[i].buffer != NULL && 613 mSlots[i].buffer->handle == buffer->handle) { 614 return i; 615 } 616 } 617 ALOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle); 618 return BAD_VALUE; 619 } 620 621 int Surface::lockBuffer_DEPRECATED(android_native_buffer_t* buffer __attribute__((unused))) { 622 ALOGV("Surface::lockBuffer"); 623 Mutex::Autolock lock(mMutex); 624 return OK; 625 } 626 627 int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) { 628 ATRACE_CALL(); 629 ALOGV("Surface::queueBuffer"); 630 Mutex::Autolock lock(mMutex); 631 int64_t timestamp; 632 bool isAutoTimestamp = false; 633 634 if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) { 635 timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 636 isAutoTimestamp = true; 637 ALOGV("Surface::queueBuffer making up timestamp: %.2f ms", 638 timestamp / 1000000.0); 639 } else { 640 timestamp = mTimestamp; 641 } 642 int i = getSlotFromBufferLocked(buffer); 643 if (i < 0) { 644 if (fenceFd >= 0) { 645 close(fenceFd); 646 } 647 return i; 648 } 649 if (mSharedBufferSlot == i && mSharedBufferHasBeenQueued) { 650 if (fenceFd >= 0) { 651 close(fenceFd); 652 } 653 return OK; 654 } 655 656 657 // Make sure the crop rectangle is entirely inside the buffer. 658 Rect crop(Rect::EMPTY_RECT); 659 mCrop.intersect(Rect(buffer->width, buffer->height), &crop); 660 661 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE); 662 IGraphicBufferProducer::QueueBufferOutput output; 663 IGraphicBufferProducer::QueueBufferInput input(timestamp, isAutoTimestamp, 664 mDataSpace, crop, mScalingMode, mTransform ^ mStickyTransform, 665 fence, mStickyTransform, mEnableFrameTimestamps); 666 667 if (mConnectedToCpu || mDirtyRegion.bounds() == Rect::INVALID_RECT) { 668 input.setSurfaceDamage(Region::INVALID_REGION); 669 } else { 670 // Here we do two things: 671 // 1) The surface damage was specified using the OpenGL ES convention of 672 // the origin being in the bottom-left corner. Here we flip to the 673 // convention that the rest of the system uses (top-left corner) by 674 // subtracting all top/bottom coordinates from the buffer height. 675 // 2) If the buffer is coming in rotated (for example, because the EGL 676 // implementation is reacting to the transform hint coming back from 677 // SurfaceFlinger), the surface damage needs to be rotated the 678 // opposite direction, since it was generated assuming an unrotated 679 // buffer (the app doesn't know that the EGL implementation is 680 // reacting to the transform hint behind its back). The 681 // transformations in the switch statement below apply those 682 // complementary rotations (e.g., if 90 degrees, rotate 270 degrees). 683 684 int width = buffer->width; 685 int height = buffer->height; 686 bool rotated90 = (mTransform ^ mStickyTransform) & 687 NATIVE_WINDOW_TRANSFORM_ROT_90; 688 if (rotated90) { 689 std::swap(width, height); 690 } 691 692 Region flippedRegion; 693 for (auto rect : mDirtyRegion) { 694 int left = rect.left; 695 int right = rect.right; 696 int top = height - rect.bottom; // Flip from OpenGL convention 697 int bottom = height - rect.top; // Flip from OpenGL convention 698 switch (mTransform ^ mStickyTransform) { 699 case NATIVE_WINDOW_TRANSFORM_ROT_90: { 700 // Rotate 270 degrees 701 Rect flippedRect{top, width - right, bottom, width - left}; 702 flippedRegion.orSelf(flippedRect); 703 break; 704 } 705 case NATIVE_WINDOW_TRANSFORM_ROT_180: { 706 // Rotate 180 degrees 707 Rect flippedRect{width - right, height - bottom, 708 width - left, height - top}; 709 flippedRegion.orSelf(flippedRect); 710 break; 711 } 712 case NATIVE_WINDOW_TRANSFORM_ROT_270: { 713 // Rotate 90 degrees 714 Rect flippedRect{height - bottom, left, 715 height - top, right}; 716 flippedRegion.orSelf(flippedRect); 717 break; 718 } 719 default: { 720 Rect flippedRect{left, top, right, bottom}; 721 flippedRegion.orSelf(flippedRect); 722 break; 723 } 724 } 725 } 726 727 input.setSurfaceDamage(flippedRegion); 728 } 729 730 nsecs_t now = systemTime(); 731 status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output); 732 mLastQueueDuration = systemTime() - now; 733 if (err != OK) { 734 ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err); 735 } 736 737 if (mEnableFrameTimestamps) { 738 mFrameEventHistory->applyDelta(output.frameTimestamps); 739 // Update timestamps with the local acquire fence. 740 // The consumer doesn't send it back to prevent us from having two 741 // file descriptors of the same fence. 742 mFrameEventHistory->updateAcquireFence(mNextFrameNumber, 743 std::make_shared<FenceTime>(std::move(fence))); 744 745 // Cache timestamps of signaled fences so we can close their file 746 // descriptors. 747 mFrameEventHistory->updateSignalTimes(); 748 } 749 750 mLastFrameNumber = mNextFrameNumber; 751 752 mDefaultWidth = output.width; 753 mDefaultHeight = output.height; 754 mNextFrameNumber = output.nextFrameNumber; 755 756 // Disable transform hint if sticky transform is set. 757 if (mStickyTransform == 0) { 758 mTransformHint = output.transformHint; 759 } 760 761 mConsumerRunningBehind = (output.numPendingBuffers >= 2); 762 763 if (!mConnectedToCpu) { 764 // Clear surface damage back to full-buffer 765 mDirtyRegion = Region::INVALID_REGION; 766 } 767 768 if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot == i) { 769 mSharedBufferHasBeenQueued = true; 770 } 771 772 mQueueBufferCondition.broadcast(); 773 774 return err; 775 } 776 777 void Surface::querySupportedTimestampsLocked() const { 778 // mMutex must be locked when calling this method. 779 780 if (mQueriedSupportedTimestamps) { 781 return; 782 } 783 mQueriedSupportedTimestamps = true; 784 785 std::vector<FrameEvent> supportedFrameTimestamps; 786 status_t err = composerService()->getSupportedFrameTimestamps( 787 &supportedFrameTimestamps); 788 789 if (err != NO_ERROR) { 790 return; 791 } 792 793 for (auto sft : supportedFrameTimestamps) { 794 if (sft == FrameEvent::DISPLAY_PRESENT) { 795 mFrameTimestampsSupportsPresent = true; 796 } 797 } 798 } 799 800 int Surface::query(int what, int* value) const { 801 ATRACE_CALL(); 802 ALOGV("Surface::query"); 803 { // scope for the lock 804 Mutex::Autolock lock(mMutex); 805 switch (what) { 806 case NATIVE_WINDOW_FORMAT: 807 if (mReqFormat) { 808 *value = static_cast<int>(mReqFormat); 809 return NO_ERROR; 810 } 811 break; 812 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: { 813 if (composerService()->authenticateSurfaceTexture( 814 mGraphicBufferProducer)) { 815 *value = 1; 816 } else { 817 *value = 0; 818 } 819 return NO_ERROR; 820 } 821 case NATIVE_WINDOW_CONCRETE_TYPE: 822 *value = NATIVE_WINDOW_SURFACE; 823 return NO_ERROR; 824 case NATIVE_WINDOW_DEFAULT_WIDTH: 825 *value = static_cast<int>( 826 mUserWidth ? mUserWidth : mDefaultWidth); 827 return NO_ERROR; 828 case NATIVE_WINDOW_DEFAULT_HEIGHT: 829 *value = static_cast<int>( 830 mUserHeight ? mUserHeight : mDefaultHeight); 831 return NO_ERROR; 832 case NATIVE_WINDOW_TRANSFORM_HINT: 833 *value = static_cast<int>(mTransformHint); 834 return NO_ERROR; 835 case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: { 836 status_t err = NO_ERROR; 837 if (!mConsumerRunningBehind) { 838 *value = 0; 839 } else { 840 err = mGraphicBufferProducer->query(what, value); 841 if (err == NO_ERROR) { 842 mConsumerRunningBehind = *value; 843 } 844 } 845 return err; 846 } 847 case NATIVE_WINDOW_BUFFER_AGE: { 848 if (mBufferAge > INT32_MAX) { 849 *value = 0; 850 } else { 851 *value = static_cast<int32_t>(mBufferAge); 852 } 853 return NO_ERROR; 854 } 855 case NATIVE_WINDOW_LAST_DEQUEUE_DURATION: { 856 int64_t durationUs = mLastDequeueDuration / 1000; 857 *value = durationUs > std::numeric_limits<int>::max() ? 858 std::numeric_limits<int>::max() : 859 static_cast<int>(durationUs); 860 return NO_ERROR; 861 } 862 case NATIVE_WINDOW_LAST_QUEUE_DURATION: { 863 int64_t durationUs = mLastQueueDuration / 1000; 864 *value = durationUs > std::numeric_limits<int>::max() ? 865 std::numeric_limits<int>::max() : 866 static_cast<int>(durationUs); 867 return NO_ERROR; 868 } 869 case NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT: { 870 querySupportedTimestampsLocked(); 871 *value = mFrameTimestampsSupportsPresent ? 1 : 0; 872 return NO_ERROR; 873 } 874 case NATIVE_WINDOW_IS_VALID: { 875 *value = mGraphicBufferProducer != nullptr ? 1 : 0; 876 return NO_ERROR; 877 } 878 } 879 } 880 return mGraphicBufferProducer->query(what, value); 881 } 882 883 int Surface::perform(int operation, va_list args) 884 { 885 int res = NO_ERROR; 886 switch (operation) { 887 case NATIVE_WINDOW_CONNECT: 888 // deprecated. must return NO_ERROR. 889 break; 890 case NATIVE_WINDOW_DISCONNECT: 891 // deprecated. must return NO_ERROR. 892 break; 893 case NATIVE_WINDOW_SET_USAGE: 894 res = dispatchSetUsage(args); 895 break; 896 case NATIVE_WINDOW_SET_CROP: 897 res = dispatchSetCrop(args); 898 break; 899 case NATIVE_WINDOW_SET_BUFFER_COUNT: 900 res = dispatchSetBufferCount(args); 901 break; 902 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY: 903 res = dispatchSetBuffersGeometry(args); 904 break; 905 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM: 906 res = dispatchSetBuffersTransform(args); 907 break; 908 case NATIVE_WINDOW_SET_BUFFERS_STICKY_TRANSFORM: 909 res = dispatchSetBuffersStickyTransform(args); 910 break; 911 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP: 912 res = dispatchSetBuffersTimestamp(args); 913 break; 914 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS: 915 res = dispatchSetBuffersDimensions(args); 916 break; 917 case NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS: 918 res = dispatchSetBuffersUserDimensions(args); 919 break; 920 case NATIVE_WINDOW_SET_BUFFERS_FORMAT: 921 res = dispatchSetBuffersFormat(args); 922 break; 923 case NATIVE_WINDOW_LOCK: 924 res = dispatchLock(args); 925 break; 926 case NATIVE_WINDOW_UNLOCK_AND_POST: 927 res = dispatchUnlockAndPost(args); 928 break; 929 case NATIVE_WINDOW_SET_SCALING_MODE: 930 res = dispatchSetScalingMode(args); 931 break; 932 case NATIVE_WINDOW_API_CONNECT: 933 res = dispatchConnect(args); 934 break; 935 case NATIVE_WINDOW_API_DISCONNECT: 936 res = dispatchDisconnect(args); 937 break; 938 case NATIVE_WINDOW_SET_SIDEBAND_STREAM: 939 res = dispatchSetSidebandStream(args); 940 break; 941 case NATIVE_WINDOW_SET_BUFFERS_DATASPACE: 942 res = dispatchSetBuffersDataSpace(args); 943 break; 944 case NATIVE_WINDOW_SET_SURFACE_DAMAGE: 945 res = dispatchSetSurfaceDamage(args); 946 break; 947 case NATIVE_WINDOW_SET_SHARED_BUFFER_MODE: 948 res = dispatchSetSharedBufferMode(args); 949 break; 950 case NATIVE_WINDOW_SET_AUTO_REFRESH: 951 res = dispatchSetAutoRefresh(args); 952 break; 953 case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION: 954 res = dispatchGetDisplayRefreshCycleDuration(args); 955 break; 956 case NATIVE_WINDOW_GET_NEXT_FRAME_ID: 957 res = dispatchGetNextFrameId(args); 958 break; 959 case NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS: 960 res = dispatchEnableFrameTimestamps(args); 961 break; 962 case NATIVE_WINDOW_GET_COMPOSITOR_TIMING: 963 res = dispatchGetCompositorTiming(args); 964 break; 965 case NATIVE_WINDOW_GET_FRAME_TIMESTAMPS: 966 res = dispatchGetFrameTimestamps(args); 967 break; 968 case NATIVE_WINDOW_GET_WIDE_COLOR_SUPPORT: 969 res = dispatchGetWideColorSupport(args); 970 break; 971 case NATIVE_WINDOW_GET_HDR_SUPPORT: 972 res = dispatchGetHdrSupport(args); 973 break; 974 case NATIVE_WINDOW_SET_USAGE64: 975 res = dispatchSetUsage64(args); 976 break; 977 case NATIVE_WINDOW_GET_CONSUMER_USAGE64: 978 res = dispatchGetConsumerUsage64(args); 979 break; 980 default: 981 res = NAME_NOT_FOUND; 982 break; 983 } 984 return res; 985 } 986 987 int Surface::dispatchConnect(va_list args) { 988 int api = va_arg(args, int); 989 return connect(api); 990 } 991 992 int Surface::dispatchDisconnect(va_list args) { 993 int api = va_arg(args, int); 994 return disconnect(api); 995 } 996 997 int Surface::dispatchSetUsage(va_list args) { 998 uint64_t usage = va_arg(args, uint32_t); 999 return setUsage(usage); 1000 } 1001 1002 int Surface::dispatchSetUsage64(va_list args) { 1003 uint64_t usage = va_arg(args, uint64_t); 1004 return setUsage(usage); 1005 } 1006 1007 int Surface::dispatchSetCrop(va_list args) { 1008 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*); 1009 return setCrop(reinterpret_cast<Rect const*>(rect)); 1010 } 1011 1012 int Surface::dispatchSetBufferCount(va_list args) { 1013 size_t bufferCount = va_arg(args, size_t); 1014 return setBufferCount(static_cast<int32_t>(bufferCount)); 1015 } 1016 1017 int Surface::dispatchSetBuffersGeometry(va_list args) { 1018 uint32_t width = va_arg(args, uint32_t); 1019 uint32_t height = va_arg(args, uint32_t); 1020 PixelFormat format = va_arg(args, PixelFormat); 1021 int err = setBuffersDimensions(width, height); 1022 if (err != 0) { 1023 return err; 1024 } 1025 return setBuffersFormat(format); 1026 } 1027 1028 int Surface::dispatchSetBuffersDimensions(va_list args) { 1029 uint32_t width = va_arg(args, uint32_t); 1030 uint32_t height = va_arg(args, uint32_t); 1031 return setBuffersDimensions(width, height); 1032 } 1033 1034 int Surface::dispatchSetBuffersUserDimensions(va_list args) { 1035 uint32_t width = va_arg(args, uint32_t); 1036 uint32_t height = va_arg(args, uint32_t); 1037 return setBuffersUserDimensions(width, height); 1038 } 1039 1040 int Surface::dispatchSetBuffersFormat(va_list args) { 1041 PixelFormat format = va_arg(args, PixelFormat); 1042 return setBuffersFormat(format); 1043 } 1044 1045 int Surface::dispatchSetScalingMode(va_list args) { 1046 int mode = va_arg(args, int); 1047 return setScalingMode(mode); 1048 } 1049 1050 int Surface::dispatchSetBuffersTransform(va_list args) { 1051 uint32_t transform = va_arg(args, uint32_t); 1052 return setBuffersTransform(transform); 1053 } 1054 1055 int Surface::dispatchSetBuffersStickyTransform(va_list args) { 1056 uint32_t transform = va_arg(args, uint32_t); 1057 return setBuffersStickyTransform(transform); 1058 } 1059 1060 int Surface::dispatchSetBuffersTimestamp(va_list args) { 1061 int64_t timestamp = va_arg(args, int64_t); 1062 return setBuffersTimestamp(timestamp); 1063 } 1064 1065 int Surface::dispatchLock(va_list args) { 1066 ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*); 1067 ARect* inOutDirtyBounds = va_arg(args, ARect*); 1068 return lock(outBuffer, inOutDirtyBounds); 1069 } 1070 1071 int Surface::dispatchUnlockAndPost(va_list args __attribute__((unused))) { 1072 return unlockAndPost(); 1073 } 1074 1075 int Surface::dispatchSetSidebandStream(va_list args) { 1076 native_handle_t* sH = va_arg(args, native_handle_t*); 1077 sp<NativeHandle> sidebandHandle = NativeHandle::create(sH, false); 1078 setSidebandStream(sidebandHandle); 1079 return OK; 1080 } 1081 1082 int Surface::dispatchSetBuffersDataSpace(va_list args) { 1083 android_dataspace dataspace = 1084 static_cast<android_dataspace>(va_arg(args, int)); 1085 return setBuffersDataSpace(dataspace); 1086 } 1087 1088 int Surface::dispatchSetSurfaceDamage(va_list args) { 1089 android_native_rect_t* rects = va_arg(args, android_native_rect_t*); 1090 size_t numRects = va_arg(args, size_t); 1091 setSurfaceDamage(rects, numRects); 1092 return NO_ERROR; 1093 } 1094 1095 int Surface::dispatchSetSharedBufferMode(va_list args) { 1096 bool sharedBufferMode = va_arg(args, int); 1097 return setSharedBufferMode(sharedBufferMode); 1098 } 1099 1100 int Surface::dispatchSetAutoRefresh(va_list args) { 1101 bool autoRefresh = va_arg(args, int); 1102 return setAutoRefresh(autoRefresh); 1103 } 1104 1105 int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) { 1106 nsecs_t* outRefreshDuration = va_arg(args, int64_t*); 1107 return getDisplayRefreshCycleDuration(outRefreshDuration); 1108 } 1109 1110 int Surface::dispatchGetNextFrameId(va_list args) { 1111 uint64_t* nextFrameId = va_arg(args, uint64_t*); 1112 *nextFrameId = getNextFrameNumber(); 1113 return NO_ERROR; 1114 } 1115 1116 int Surface::dispatchEnableFrameTimestamps(va_list args) { 1117 bool enable = va_arg(args, int); 1118 enableFrameTimestamps(enable); 1119 return NO_ERROR; 1120 } 1121 1122 int Surface::dispatchGetCompositorTiming(va_list args) { 1123 nsecs_t* compositeDeadline = va_arg(args, int64_t*); 1124 nsecs_t* compositeInterval = va_arg(args, int64_t*); 1125 nsecs_t* compositeToPresentLatency = va_arg(args, int64_t*); 1126 return getCompositorTiming(compositeDeadline, compositeInterval, 1127 compositeToPresentLatency); 1128 } 1129 1130 int Surface::dispatchGetFrameTimestamps(va_list args) { 1131 uint64_t frameId = va_arg(args, uint64_t); 1132 nsecs_t* outRequestedPresentTime = va_arg(args, int64_t*); 1133 nsecs_t* outAcquireTime = va_arg(args, int64_t*); 1134 nsecs_t* outLatchTime = va_arg(args, int64_t*); 1135 nsecs_t* outFirstRefreshStartTime = va_arg(args, int64_t*); 1136 nsecs_t* outLastRefreshStartTime = va_arg(args, int64_t*); 1137 nsecs_t* outGpuCompositionDoneTime = va_arg(args, int64_t*); 1138 nsecs_t* outDisplayPresentTime = va_arg(args, int64_t*); 1139 nsecs_t* outDequeueReadyTime = va_arg(args, int64_t*); 1140 nsecs_t* outReleaseTime = va_arg(args, int64_t*); 1141 return getFrameTimestamps(frameId, 1142 outRequestedPresentTime, outAcquireTime, outLatchTime, 1143 outFirstRefreshStartTime, outLastRefreshStartTime, 1144 outGpuCompositionDoneTime, outDisplayPresentTime, 1145 outDequeueReadyTime, outReleaseTime); 1146 } 1147 1148 int Surface::dispatchGetWideColorSupport(va_list args) { 1149 bool* outSupport = va_arg(args, bool*); 1150 return getWideColorSupport(outSupport); 1151 } 1152 1153 int Surface::dispatchGetHdrSupport(va_list args) { 1154 bool* outSupport = va_arg(args, bool*); 1155 return getHdrSupport(outSupport); 1156 } 1157 1158 int Surface::dispatchGetConsumerUsage64(va_list args) { 1159 uint64_t* usage = va_arg(args, uint64_t*); 1160 return getConsumerUsage(usage); 1161 } 1162 1163 int Surface::connect(int api) { 1164 static sp<IProducerListener> listener = new DummyProducerListener(); 1165 return connect(api, listener); 1166 } 1167 1168 int Surface::connect(int api, const sp<IProducerListener>& listener) { 1169 return connect(api, listener, false); 1170 } 1171 1172 int Surface::connect( 1173 int api, const sp<IProducerListener>& listener, bool reportBufferRemoval) { 1174 ATRACE_CALL(); 1175 ALOGV("Surface::connect"); 1176 Mutex::Autolock lock(mMutex); 1177 IGraphicBufferProducer::QueueBufferOutput output; 1178 mReportRemovedBuffers = reportBufferRemoval; 1179 int err = mGraphicBufferProducer->connect(listener, api, mProducerControlledByApp, &output); 1180 if (err == NO_ERROR) { 1181 mDefaultWidth = output.width; 1182 mDefaultHeight = output.height; 1183 mNextFrameNumber = output.nextFrameNumber; 1184 1185 // Disable transform hint if sticky transform is set. 1186 if (mStickyTransform == 0) { 1187 mTransformHint = output.transformHint; 1188 } 1189 1190 mConsumerRunningBehind = (output.numPendingBuffers >= 2); 1191 } 1192 if (!err && api == NATIVE_WINDOW_API_CPU) { 1193 mConnectedToCpu = true; 1194 // Clear the dirty region in case we're switching from a non-CPU API 1195 mDirtyRegion.clear(); 1196 } else if (!err) { 1197 // Initialize the dirty region for tracking surface damage 1198 mDirtyRegion = Region::INVALID_REGION; 1199 } 1200 1201 return err; 1202 } 1203 1204 1205 int Surface::disconnect(int api, IGraphicBufferProducer::DisconnectMode mode) { 1206 ATRACE_CALL(); 1207 ALOGV("Surface::disconnect"); 1208 Mutex::Autolock lock(mMutex); 1209 mRemovedBuffers.clear(); 1210 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT; 1211 mSharedBufferHasBeenQueued = false; 1212 freeAllBuffers(); 1213 int err = mGraphicBufferProducer->disconnect(api, mode); 1214 if (!err) { 1215 mReqFormat = 0; 1216 mReqWidth = 0; 1217 mReqHeight = 0; 1218 mReqUsage = 0; 1219 mCrop.clear(); 1220 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE; 1221 mTransform = 0; 1222 mStickyTransform = 0; 1223 1224 if (api == NATIVE_WINDOW_API_CPU) { 1225 mConnectedToCpu = false; 1226 } 1227 } 1228 return err; 1229 } 1230 1231 int Surface::detachNextBuffer(sp<GraphicBuffer>* outBuffer, 1232 sp<Fence>* outFence) { 1233 ATRACE_CALL(); 1234 ALOGV("Surface::detachNextBuffer"); 1235 1236 if (outBuffer == NULL || outFence == NULL) { 1237 return BAD_VALUE; 1238 } 1239 1240 Mutex::Autolock lock(mMutex); 1241 if (mReportRemovedBuffers) { 1242 mRemovedBuffers.clear(); 1243 } 1244 1245 sp<GraphicBuffer> buffer(NULL); 1246 sp<Fence> fence(NULL); 1247 status_t result = mGraphicBufferProducer->detachNextBuffer( 1248 &buffer, &fence); 1249 if (result != NO_ERROR) { 1250 return result; 1251 } 1252 1253 *outBuffer = buffer; 1254 if (fence != NULL && fence->isValid()) { 1255 *outFence = fence; 1256 } else { 1257 *outFence = Fence::NO_FENCE; 1258 } 1259 1260 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 1261 if (mSlots[i].buffer != NULL && 1262 mSlots[i].buffer->getId() == buffer->getId()) { 1263 if (mReportRemovedBuffers) { 1264 mRemovedBuffers.push_back(mSlots[i].buffer); 1265 } 1266 mSlots[i].buffer = NULL; 1267 } 1268 } 1269 1270 return NO_ERROR; 1271 } 1272 1273 int Surface::attachBuffer(ANativeWindowBuffer* buffer) 1274 { 1275 ATRACE_CALL(); 1276 ALOGV("Surface::attachBuffer"); 1277 1278 Mutex::Autolock lock(mMutex); 1279 if (mReportRemovedBuffers) { 1280 mRemovedBuffers.clear(); 1281 } 1282 1283 sp<GraphicBuffer> graphicBuffer(static_cast<GraphicBuffer*>(buffer)); 1284 uint32_t priorGeneration = graphicBuffer->mGenerationNumber; 1285 graphicBuffer->mGenerationNumber = mGenerationNumber; 1286 int32_t attachedSlot = -1; 1287 status_t result = mGraphicBufferProducer->attachBuffer(&attachedSlot, graphicBuffer); 1288 if (result != NO_ERROR) { 1289 ALOGE("attachBuffer: IGraphicBufferProducer call failed (%d)", result); 1290 graphicBuffer->mGenerationNumber = priorGeneration; 1291 return result; 1292 } 1293 if (mReportRemovedBuffers && (mSlots[attachedSlot].buffer != nullptr)) { 1294 mRemovedBuffers.push_back(mSlots[attachedSlot].buffer); 1295 } 1296 mSlots[attachedSlot].buffer = graphicBuffer; 1297 1298 return NO_ERROR; 1299 } 1300 1301 int Surface::setUsage(uint64_t reqUsage) 1302 { 1303 ALOGV("Surface::setUsage"); 1304 Mutex::Autolock lock(mMutex); 1305 if (reqUsage != mReqUsage) { 1306 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT; 1307 } 1308 mReqUsage = reqUsage; 1309 return OK; 1310 } 1311 1312 int Surface::setCrop(Rect const* rect) 1313 { 1314 ATRACE_CALL(); 1315 1316 Rect realRect(Rect::EMPTY_RECT); 1317 if (rect == NULL || rect->isEmpty()) { 1318 realRect.clear(); 1319 } else { 1320 realRect = *rect; 1321 } 1322 1323 ALOGV("Surface::setCrop rect=[%d %d %d %d]", 1324 realRect.left, realRect.top, realRect.right, realRect.bottom); 1325 1326 Mutex::Autolock lock(mMutex); 1327 mCrop = realRect; 1328 return NO_ERROR; 1329 } 1330 1331 int Surface::setBufferCount(int bufferCount) 1332 { 1333 ATRACE_CALL(); 1334 ALOGV("Surface::setBufferCount"); 1335 Mutex::Autolock lock(mMutex); 1336 1337 status_t err = NO_ERROR; 1338 if (bufferCount == 0) { 1339 err = mGraphicBufferProducer->setMaxDequeuedBufferCount(1); 1340 } else { 1341 int minUndequeuedBuffers = 0; 1342 err = mGraphicBufferProducer->query( 1343 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBuffers); 1344 if (err == NO_ERROR) { 1345 err = mGraphicBufferProducer->setMaxDequeuedBufferCount( 1346 bufferCount - minUndequeuedBuffers); 1347 } 1348 } 1349 1350 ALOGE_IF(err, "IGraphicBufferProducer::setBufferCount(%d) returned %s", 1351 bufferCount, strerror(-err)); 1352 1353 return err; 1354 } 1355 1356 int Surface::setMaxDequeuedBufferCount(int maxDequeuedBuffers) { 1357 ATRACE_CALL(); 1358 ALOGV("Surface::setMaxDequeuedBufferCount"); 1359 Mutex::Autolock lock(mMutex); 1360 1361 status_t err = mGraphicBufferProducer->setMaxDequeuedBufferCount( 1362 maxDequeuedBuffers); 1363 ALOGE_IF(err, "IGraphicBufferProducer::setMaxDequeuedBufferCount(%d) " 1364 "returned %s", maxDequeuedBuffers, strerror(-err)); 1365 1366 return err; 1367 } 1368 1369 int Surface::setAsyncMode(bool async) { 1370 ATRACE_CALL(); 1371 ALOGV("Surface::setAsyncMode"); 1372 Mutex::Autolock lock(mMutex); 1373 1374 status_t err = mGraphicBufferProducer->setAsyncMode(async); 1375 ALOGE_IF(err, "IGraphicBufferProducer::setAsyncMode(%d) returned %s", 1376 async, strerror(-err)); 1377 1378 return err; 1379 } 1380 1381 int Surface::setSharedBufferMode(bool sharedBufferMode) { 1382 ATRACE_CALL(); 1383 ALOGV("Surface::setSharedBufferMode (%d)", sharedBufferMode); 1384 Mutex::Autolock lock(mMutex); 1385 1386 status_t err = mGraphicBufferProducer->setSharedBufferMode( 1387 sharedBufferMode); 1388 if (err == NO_ERROR) { 1389 mSharedBufferMode = sharedBufferMode; 1390 } 1391 ALOGE_IF(err, "IGraphicBufferProducer::setSharedBufferMode(%d) returned" 1392 "%s", sharedBufferMode, strerror(-err)); 1393 1394 return err; 1395 } 1396 1397 int Surface::setAutoRefresh(bool autoRefresh) { 1398 ATRACE_CALL(); 1399 ALOGV("Surface::setAutoRefresh (%d)", autoRefresh); 1400 Mutex::Autolock lock(mMutex); 1401 1402 status_t err = mGraphicBufferProducer->setAutoRefresh(autoRefresh); 1403 if (err == NO_ERROR) { 1404 mAutoRefresh = autoRefresh; 1405 } 1406 ALOGE_IF(err, "IGraphicBufferProducer::setAutoRefresh(%d) returned %s", 1407 autoRefresh, strerror(-err)); 1408 return err; 1409 } 1410 1411 int Surface::setBuffersDimensions(uint32_t width, uint32_t height) 1412 { 1413 ATRACE_CALL(); 1414 ALOGV("Surface::setBuffersDimensions"); 1415 1416 if ((width && !height) || (!width && height)) 1417 return BAD_VALUE; 1418 1419 Mutex::Autolock lock(mMutex); 1420 if (width != mReqWidth || height != mReqHeight) { 1421 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT; 1422 } 1423 mReqWidth = width; 1424 mReqHeight = height; 1425 return NO_ERROR; 1426 } 1427 1428 int Surface::setBuffersUserDimensions(uint32_t width, uint32_t height) 1429 { 1430 ATRACE_CALL(); 1431 ALOGV("Surface::setBuffersUserDimensions"); 1432 1433 if ((width && !height) || (!width && height)) 1434 return BAD_VALUE; 1435 1436 Mutex::Autolock lock(mMutex); 1437 if (width != mUserWidth || height != mUserHeight) { 1438 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT; 1439 } 1440 mUserWidth = width; 1441 mUserHeight = height; 1442 return NO_ERROR; 1443 } 1444 1445 int Surface::setBuffersFormat(PixelFormat format) 1446 { 1447 ALOGV("Surface::setBuffersFormat"); 1448 1449 Mutex::Autolock lock(mMutex); 1450 if (format != mReqFormat) { 1451 mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT; 1452 } 1453 mReqFormat = format; 1454 return NO_ERROR; 1455 } 1456 1457 int Surface::setScalingMode(int mode) 1458 { 1459 ATRACE_CALL(); 1460 ALOGV("Surface::setScalingMode(%d)", mode); 1461 1462 switch (mode) { 1463 case NATIVE_WINDOW_SCALING_MODE_FREEZE: 1464 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW: 1465 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP: 1466 case NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP: 1467 break; 1468 default: 1469 ALOGE("unknown scaling mode: %d", mode); 1470 return BAD_VALUE; 1471 } 1472 1473 Mutex::Autolock lock(mMutex); 1474 mScalingMode = mode; 1475 return NO_ERROR; 1476 } 1477 1478 int Surface::setBuffersTransform(uint32_t transform) 1479 { 1480 ATRACE_CALL(); 1481 ALOGV("Surface::setBuffersTransform"); 1482 Mutex::Autolock lock(mMutex); 1483 mTransform = transform; 1484 return NO_ERROR; 1485 } 1486 1487 int Surface::setBuffersStickyTransform(uint32_t transform) 1488 { 1489 ATRACE_CALL(); 1490 ALOGV("Surface::setBuffersStickyTransform"); 1491 Mutex::Autolock lock(mMutex); 1492 mStickyTransform = transform; 1493 return NO_ERROR; 1494 } 1495 1496 int Surface::setBuffersTimestamp(int64_t timestamp) 1497 { 1498 ALOGV("Surface::setBuffersTimestamp"); 1499 Mutex::Autolock lock(mMutex); 1500 mTimestamp = timestamp; 1501 return NO_ERROR; 1502 } 1503 1504 int Surface::setBuffersDataSpace(android_dataspace dataSpace) 1505 { 1506 ALOGV("Surface::setBuffersDataSpace"); 1507 Mutex::Autolock lock(mMutex); 1508 mDataSpace = dataSpace; 1509 return NO_ERROR; 1510 } 1511 1512 void Surface::freeAllBuffers() { 1513 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) { 1514 mSlots[i].buffer = 0; 1515 } 1516 } 1517 1518 void Surface::setSurfaceDamage(android_native_rect_t* rects, size_t numRects) { 1519 ATRACE_CALL(); 1520 ALOGV("Surface::setSurfaceDamage"); 1521 Mutex::Autolock lock(mMutex); 1522 1523 if (mConnectedToCpu || numRects == 0) { 1524 mDirtyRegion = Region::INVALID_REGION; 1525 return; 1526 } 1527 1528 mDirtyRegion.clear(); 1529 for (size_t r = 0; r < numRects; ++r) { 1530 // We intentionally flip top and bottom here, since because they're 1531 // specified with a bottom-left origin, top > bottom, which fails 1532 // validation in the Region class. We will fix this up when we flip to a 1533 // top-left origin in queueBuffer. 1534 Rect rect(rects[r].left, rects[r].bottom, rects[r].right, rects[r].top); 1535 mDirtyRegion.orSelf(rect); 1536 } 1537 } 1538 1539 // ---------------------------------------------------------------------- 1540 // the lock/unlock APIs must be used from the same thread 1541 1542 static status_t copyBlt( 1543 const sp<GraphicBuffer>& dst, 1544 const sp<GraphicBuffer>& src, 1545 const Region& reg, 1546 int *dstFenceFd) 1547 { 1548 if (dst->getId() == src->getId()) 1549 return OK; 1550 1551 // src and dst with, height and format must be identical. no verification 1552 // is done here. 1553 status_t err; 1554 uint8_t* src_bits = NULL; 1555 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), 1556 reinterpret_cast<void**>(&src_bits)); 1557 ALOGE_IF(err, "error locking src buffer %s", strerror(-err)); 1558 1559 uint8_t* dst_bits = NULL; 1560 err = dst->lockAsync(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), 1561 reinterpret_cast<void**>(&dst_bits), *dstFenceFd); 1562 ALOGE_IF(err, "error locking dst buffer %s", strerror(-err)); 1563 *dstFenceFd = -1; 1564 1565 Region::const_iterator head(reg.begin()); 1566 Region::const_iterator tail(reg.end()); 1567 if (head != tail && src_bits && dst_bits) { 1568 const size_t bpp = bytesPerPixel(src->format); 1569 const size_t dbpr = static_cast<uint32_t>(dst->stride) * bpp; 1570 const size_t sbpr = static_cast<uint32_t>(src->stride) * bpp; 1571 1572 while (head != tail) { 1573 const Rect& r(*head++); 1574 int32_t h = r.height(); 1575 if (h <= 0) continue; 1576 size_t size = static_cast<uint32_t>(r.width()) * bpp; 1577 uint8_t const * s = src_bits + 1578 static_cast<uint32_t>(r.left + src->stride * r.top) * bpp; 1579 uint8_t * d = dst_bits + 1580 static_cast<uint32_t>(r.left + dst->stride * r.top) * bpp; 1581 if (dbpr==sbpr && size==sbpr) { 1582 size *= static_cast<size_t>(h); 1583 h = 1; 1584 } 1585 do { 1586 memcpy(d, s, size); 1587 d += dbpr; 1588 s += sbpr; 1589 } while (--h > 0); 1590 } 1591 } 1592 1593 if (src_bits) 1594 src->unlock(); 1595 1596 if (dst_bits) 1597 dst->unlockAsync(dstFenceFd); 1598 1599 return err; 1600 } 1601 1602 // ---------------------------------------------------------------------------- 1603 1604 status_t Surface::lock( 1605 ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds) 1606 { 1607 if (mLockedBuffer != 0) { 1608 ALOGE("Surface::lock failed, already locked"); 1609 return INVALID_OPERATION; 1610 } 1611 1612 if (!mConnectedToCpu) { 1613 int err = Surface::connect(NATIVE_WINDOW_API_CPU); 1614 if (err) { 1615 return err; 1616 } 1617 // we're intending to do software rendering from this point 1618 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN); 1619 } 1620 1621 ANativeWindowBuffer* out; 1622 int fenceFd = -1; 1623 status_t err = dequeueBuffer(&out, &fenceFd); 1624 ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err)); 1625 if (err == NO_ERROR) { 1626 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out)); 1627 const Rect bounds(backBuffer->width, backBuffer->height); 1628 1629 Region newDirtyRegion; 1630 if (inOutDirtyBounds) { 1631 newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds)); 1632 newDirtyRegion.andSelf(bounds); 1633 } else { 1634 newDirtyRegion.set(bounds); 1635 } 1636 1637 // figure out if we can copy the frontbuffer back 1638 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer); 1639 const bool canCopyBack = (frontBuffer != 0 && 1640 backBuffer->width == frontBuffer->width && 1641 backBuffer->height == frontBuffer->height && 1642 backBuffer->format == frontBuffer->format); 1643 1644 if (canCopyBack) { 1645 // copy the area that is invalid and not repainted this round 1646 const Region copyback(mDirtyRegion.subtract(newDirtyRegion)); 1647 if (!copyback.isEmpty()) { 1648 copyBlt(backBuffer, frontBuffer, copyback, &fenceFd); 1649 } 1650 } else { 1651 // if we can't copy-back anything, modify the user's dirty 1652 // region to make sure they redraw the whole buffer 1653 newDirtyRegion.set(bounds); 1654 mDirtyRegion.clear(); 1655 Mutex::Autolock lock(mMutex); 1656 for (size_t i=0 ; i<NUM_BUFFER_SLOTS ; i++) { 1657 mSlots[i].dirtyRegion.clear(); 1658 } 1659 } 1660 1661 1662 { // scope for the lock 1663 Mutex::Autolock lock(mMutex); 1664 int backBufferSlot(getSlotFromBufferLocked(backBuffer.get())); 1665 if (backBufferSlot >= 0) { 1666 Region& dirtyRegion(mSlots[backBufferSlot].dirtyRegion); 1667 mDirtyRegion.subtract(dirtyRegion); 1668 dirtyRegion = newDirtyRegion; 1669 } 1670 } 1671 1672 mDirtyRegion.orSelf(newDirtyRegion); 1673 if (inOutDirtyBounds) { 1674 *inOutDirtyBounds = newDirtyRegion.getBounds(); 1675 } 1676 1677 void* vaddr; 1678 status_t res = backBuffer->lockAsync( 1679 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN, 1680 newDirtyRegion.bounds(), &vaddr, fenceFd); 1681 1682 ALOGW_IF(res, "failed locking buffer (handle = %p)", 1683 backBuffer->handle); 1684 1685 if (res != 0) { 1686 err = INVALID_OPERATION; 1687 } else { 1688 mLockedBuffer = backBuffer; 1689 outBuffer->width = backBuffer->width; 1690 outBuffer->height = backBuffer->height; 1691 outBuffer->stride = backBuffer->stride; 1692 outBuffer->format = backBuffer->format; 1693 outBuffer->bits = vaddr; 1694 } 1695 } 1696 return err; 1697 } 1698 1699 status_t Surface::unlockAndPost() 1700 { 1701 if (mLockedBuffer == 0) { 1702 ALOGE("Surface::unlockAndPost failed, no locked buffer"); 1703 return INVALID_OPERATION; 1704 } 1705 1706 int fd = -1; 1707 status_t err = mLockedBuffer->unlockAsync(&fd); 1708 ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle); 1709 1710 err = queueBuffer(mLockedBuffer.get(), fd); 1711 ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)", 1712 mLockedBuffer->handle, strerror(-err)); 1713 1714 mPostedBuffer = mLockedBuffer; 1715 mLockedBuffer = 0; 1716 return err; 1717 } 1718 1719 bool Surface::waitForNextFrame(uint64_t lastFrame, nsecs_t timeout) { 1720 Mutex::Autolock lock(mMutex); 1721 if (mNextFrameNumber > lastFrame) { 1722 return true; 1723 } 1724 return mQueueBufferCondition.waitRelative(mMutex, timeout) == OK; 1725 } 1726 1727 status_t Surface::getUniqueId(uint64_t* outId) const { 1728 Mutex::Autolock lock(mMutex); 1729 return mGraphicBufferProducer->getUniqueId(outId); 1730 } 1731 1732 int Surface::getConsumerUsage(uint64_t* outUsage) const { 1733 Mutex::Autolock lock(mMutex); 1734 return mGraphicBufferProducer->getConsumerUsage(outUsage); 1735 } 1736 1737 nsecs_t Surface::getLastDequeueStartTime() const { 1738 Mutex::Autolock lock(mMutex); 1739 return mLastDequeueStartTime; 1740 } 1741 1742 status_t Surface::getAndFlushRemovedBuffers(std::vector<sp<GraphicBuffer>>* out) { 1743 if (out == nullptr) { 1744 ALOGE("%s: out must not be null!", __FUNCTION__); 1745 return BAD_VALUE; 1746 } 1747 1748 Mutex::Autolock lock(mMutex); 1749 *out = mRemovedBuffers; 1750 mRemovedBuffers.clear(); 1751 return OK; 1752 } 1753 1754 }; // namespace android 1755
