libs/gui/Surface.cpp

   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 <android/native_window.h>
  24
  25 #include <utils/Log.h>
  26 #include <utils/Trace.h>
  27 #include <utils/NativeHandle.h>
  28
  29 #include <ui/DisplayStatInfo.h>
  30 #include <ui/Fence.h>
  31 #include <ui/HdrCapabilities.h>
  32 #include <ui/Region.h>
  33
  34 #include <gui/BufferItem.h>
  35 #include <gui/IProducerListener.h>
  36
  37 #include <gui/ISurfaceComposer.h>
  38 #include <private/gui/ComposerService.h>
  39
  40 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
  41 #include <configstore/Utils.h>
  42
  43 namespace android {
  44
  45 Surface::Surface(
  46         const sp<IGraphicBufferProducer>& bufferProducer,
  47         bool controlledByApp)
  48     : mGraphicBufferProducer(bufferProducer),
  49       mCrop(Rect::EMPTY_RECT),
  50       mGenerationNumber(0),
  51       mSharedBufferMode(false),
  52       mAutoRefresh(false),
  53       mSharedBufferSlot(BufferItem::INVALID_BUFFER_SLOT),
  54       mSharedBufferHasBeenQueued(false),
  55       mQueriedSupportedTimestamps(false),
  56       mFrameTimestampsSupportsPresent(false),
  57       mEnableFrameTimestamps(false),
  58       mFrameEventHistory(std::make_unique<ProducerFrameEventHistory>())
  59 {
  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     uint32_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 now = systemTime();
 505
 506     FrameEventHistoryDelta frameTimestamps;
 507     status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence,
 508             reqWidth, reqHeight, reqFormat, reqUsage,
 509             enableFrameTimestamps ? &frameTimestamps : nullptr);
 510     mLastDequeueDuration = systemTime() - now;
 511
 512     if (result < 0) {
 513         ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer"
 514                 "(%d, %d, %d, %d) failed: %d", reqWidth, reqHeight, reqFormat,
 515                 reqUsage, result);
 516         return result;
 517     }
 518
 519     if (buf < 0 || buf >= NUM_BUFFER_SLOTS) {
 520         ALOGE("dequeueBuffer: IGraphicBufferProducer returned invalid slot number %d", buf);
 521         android_errorWriteLog(0x534e4554, "36991414"); // SafetyNet logging
 522         return FAILED_TRANSACTION;
 523     }
 524
 525     Mutex::Autolock lock(mMutex);
 526
 527     sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
 528
 529     // this should never happen
 530     ALOGE_IF(fence == NULL, "Surface::dequeueBuffer: received null Fence! buf=%d", buf);
 531
 532     if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) {
 533         freeAllBuffers();
 534     }
 535
 536     if (enableFrameTimestamps) {
 537          mFrameEventHistory->applyDelta(frameTimestamps);
 538     }
 539
 540     if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == nullptr) {
 541         if (mReportRemovedBuffers && (gbuf != nullptr)) {
 542             mRemovedBuffers.push_back(gbuf);
 543         }
 544         result = mGraphicBufferProducer->requestBuffer(buf, &gbuf);
 545         if (result != NO_ERROR) {
 546             ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result);
 547             mGraphicBufferProducer->cancelBuffer(buf, fence);
 548             return result;
 549         }
 550     }
 551
 552     if (fence->isValid()) {
 553         *fenceFd = fence->dup();
 554         if (*fenceFd == -1) {
 555             ALOGE("dequeueBuffer: error duping fence: %d", errno);
 556             // dup() should never fail; something is badly wrong. Soldier on
 557             // and hope for the best; the worst that should happen is some
 558             // visible corruption that lasts until the next frame.
 559         }
 560     } else {
 561         *fenceFd = -1;
 562     }
 563
 564     *buffer = gbuf.get();
 565
 566     if (mSharedBufferMode && mAutoRefresh) {
 567         mSharedBufferSlot = buf;
 568         mSharedBufferHasBeenQueued = false;
 569     } else if (mSharedBufferSlot == buf) {
 570         mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
 571         mSharedBufferHasBeenQueued = false;
 572     }
 573
 574     return OK;
 575 }
 576
 577 int Surface::cancelBuffer(android_native_buffer_t* buffer,
 578         int fenceFd) {
 579     ATRACE_CALL();
 580     ALOGV("Surface::cancelBuffer");
 581     Mutex::Autolock lock(mMutex);
 582     int i = getSlotFromBufferLocked(buffer);
 583     if (i < 0) {
 584         if (fenceFd >= 0) {
 585             close(fenceFd);
 586         }
 587         return i;
 588     }
 589     if (mSharedBufferSlot == i && mSharedBufferHasBeenQueued) {
 590         if (fenceFd >= 0) {
 591             close(fenceFd);
 592         }
 593         return OK;
 594     }
 595     sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
 596     mGraphicBufferProducer->cancelBuffer(i, fence);
 597
 598     if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot == i) {
 599         mSharedBufferHasBeenQueued = true;
 600     }
 601
 602     return OK;
 603 }
 604
 605 int Surface::getSlotFromBufferLocked(
 606         android_native_buffer_t* buffer) const {
 607     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
 608         if (mSlots[i].buffer != NULL &&
 609                 mSlots[i].buffer->handle == buffer->handle) {
 610             return i;
 611         }
 612     }
 613     ALOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle);
 614     return BAD_VALUE;
 615 }
 616
 617 int Surface::lockBuffer_DEPRECATED(android_native_buffer_t* buffer __attribute__((unused))) {
 618     ALOGV("Surface::lockBuffer");
 619     Mutex::Autolock lock(mMutex);
 620     return OK;
 621 }
 622
 623 int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) {
 624     ATRACE_CALL();
 625     ALOGV("Surface::queueBuffer");
 626     Mutex::Autolock lock(mMutex);
 627     int64_t timestamp;
 628     bool isAutoTimestamp = false;
 629
 630     if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {
 631         timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
 632         isAutoTimestamp = true;
 633         ALOGV("Surface::queueBuffer making up timestamp: %.2f ms",
 634             timestamp / 1000000.0);
 635     } else {
 636         timestamp = mTimestamp;
 637     }
 638     int i = getSlotFromBufferLocked(buffer);
 639     if (i < 0) {
 640         if (fenceFd >= 0) {
 641             close(fenceFd);
 642         }
 643         return i;
 644     }
 645     if (mSharedBufferSlot == i && mSharedBufferHasBeenQueued) {
 646         if (fenceFd >= 0) {
 647             close(fenceFd);
 648         }
 649         return OK;
 650     }
 651
 652
 653     // Make sure the crop rectangle is entirely inside the buffer.
 654     Rect crop(Rect::EMPTY_RECT);
 655     mCrop.intersect(Rect(buffer->width, buffer->height), &crop);
 656
 657     sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
 658     IGraphicBufferProducer::QueueBufferOutput output;
 659     IGraphicBufferProducer::QueueBufferInput input(timestamp, isAutoTimestamp,
 660             mDataSpace, crop, mScalingMode, mTransform ^ mStickyTransform,
 661             fence, mStickyTransform, mEnableFrameTimestamps);
 662
 663     if (mConnectedToCpu || mDirtyRegion.bounds() == Rect::INVALID_RECT) {
 664         input.setSurfaceDamage(Region::INVALID_REGION);
 665     } else {
 666         // Here we do two things:
 667         // 1) The surface damage was specified using the OpenGL ES convention of
 668         //    the origin being in the bottom-left corner. Here we flip to the
 669         //    convention that the rest of the system uses (top-left corner) by
 670         //    subtracting all top/bottom coordinates from the buffer height.
 671         // 2) If the buffer is coming in rotated (for example, because the EGL
 672         //    implementation is reacting to the transform hint coming back from
 673         //    SurfaceFlinger), the surface damage needs to be rotated the
 674         //    opposite direction, since it was generated assuming an unrotated
 675         //    buffer (the app doesn't know that the EGL implementation is
 676         //    reacting to the transform hint behind its back). The
 677         //    transformations in the switch statement below apply those
 678         //    complementary rotations (e.g., if 90 degrees, rotate 270 degrees).
 679
 680         int width = buffer->width;
 681         int height = buffer->height;
 682         bool rotated90 = (mTransform ^ mStickyTransform) &
 683                 NATIVE_WINDOW_TRANSFORM_ROT_90;
 684         if (rotated90) {
 685             std::swap(width, height);
 686         }
 687
 688         Region flippedRegion;
 689         for (auto rect : mDirtyRegion) {
 690             int left = rect.left;
 691             int right = rect.right;
 692             int top = height - rect.bottom; // Flip from OpenGL convention
 693             int bottom = height - rect.top; // Flip from OpenGL convention
 694             switch (mTransform ^ mStickyTransform) {
 695                 case NATIVE_WINDOW_TRANSFORM_ROT_90: {
 696                     // Rotate 270 degrees
 697                     Rect flippedRect{top, width - right, bottom, width - left};
 698                     flippedRegion.orSelf(flippedRect);
 699                     break;
 700                 }
 701                 case NATIVE_WINDOW_TRANSFORM_ROT_180: {
 702                     // Rotate 180 degrees
 703                     Rect flippedRect{width - right, height - bottom,
 704                             width - left, height - top};
 705                     flippedRegion.orSelf(flippedRect);
 706                     break;
 707                 }
 708                 case NATIVE_WINDOW_TRANSFORM_ROT_270: {
 709                     // Rotate 90 degrees
 710                     Rect flippedRect{height - bottom, left,
 711                             height - top, right};
 712                     flippedRegion.orSelf(flippedRect);
 713                     break;
 714                 }
 715                 default: {
 716                     Rect flippedRect{left, top, right, bottom};
 717                     flippedRegion.orSelf(flippedRect);
 718                     break;
 719                 }
 720             }
 721         }
 722
 723         input.setSurfaceDamage(flippedRegion);
 724     }
 725
 726     nsecs_t now = systemTime();
 727     status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output);
 728     mLastQueueDuration = systemTime() - now;
 729     if (err != OK)  {
 730         ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err);
 731     }
 732
 733     if (mEnableFrameTimestamps) {
 734         mFrameEventHistory->applyDelta(output.frameTimestamps);
 735         // Update timestamps with the local acquire fence.
 736         // The consumer doesn't send it back to prevent us from having two
 737         // file descriptors of the same fence.
 738         mFrameEventHistory->updateAcquireFence(mNextFrameNumber,
 739                 std::make_shared<FenceTime>(std::move(fence)));
 740
 741         // Cache timestamps of signaled fences so we can close their file
 742         // descriptors.
 743         mFrameEventHistory->updateSignalTimes();
 744     }
 745
 746     mLastFrameNumber = mNextFrameNumber;
 747
 748     mDefaultWidth = output.width;
 749     mDefaultHeight = output.height;
 750     mNextFrameNumber = output.nextFrameNumber;
 751
 752     // Disable transform hint if sticky transform is set.
 753     if (mStickyTransform == 0) {
 754         mTransformHint = output.transformHint;
 755     }
 756
 757     mConsumerRunningBehind = (output.numPendingBuffers >= 2);
 758
 759     if (!mConnectedToCpu) {
 760         // Clear surface damage back to full-buffer
 761         mDirtyRegion = Region::INVALID_REGION;
 762     }
 763
 764     if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot == i) {
 765         mSharedBufferHasBeenQueued = true;
 766     }
 767
 768     mQueueBufferCondition.broadcast();
 769
 770     return err;
 771 }
 772
 773 void Surface::querySupportedTimestampsLocked() const {
 774     // mMutex must be locked when calling this method.
 775
 776     if (mQueriedSupportedTimestamps) {
 777         return;
 778     }
 779     mQueriedSupportedTimestamps = true;
 780
 781     std::vector<FrameEvent> supportedFrameTimestamps;
 782     status_t err = composerService()->getSupportedFrameTimestamps(
 783             &supportedFrameTimestamps);
 784
 785     if (err != NO_ERROR) {
 786         return;
 787     }
 788
 789     for (auto sft : supportedFrameTimestamps) {
 790         if (sft == FrameEvent::DISPLAY_PRESENT) {
 791             mFrameTimestampsSupportsPresent = true;
 792         }
 793     }
 794 }
 795
 796 int Surface::query(int what, int* value) const {
 797     ATRACE_CALL();
 798     ALOGV("Surface::query");
 799     { // scope for the lock
 800         Mutex::Autolock lock(mMutex);
 801         switch (what) {
 802             case NATIVE_WINDOW_FORMAT:
 803                 if (mReqFormat) {
 804                     *value = static_cast<int>(mReqFormat);
 805                     return NO_ERROR;
 806                 }
 807                 break;
 808             case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: {
 809                 if (composerService()->authenticateSurfaceTexture(
 810                         mGraphicBufferProducer)) {
 811                     *value = 1;
 812                 } else {
 813                     *value = 0;
 814                 }
 815                 return NO_ERROR;
 816             }
 817             case NATIVE_WINDOW_CONCRETE_TYPE:
 818                 *value = NATIVE_WINDOW_SURFACE;
 819                 return NO_ERROR;
 820             case NATIVE_WINDOW_DEFAULT_WIDTH:
 821                 *value = static_cast<int>(
 822                         mUserWidth ? mUserWidth : mDefaultWidth);
 823                 return NO_ERROR;
 824             case NATIVE_WINDOW_DEFAULT_HEIGHT:
 825                 *value = static_cast<int>(
 826                         mUserHeight ? mUserHeight : mDefaultHeight);
 827                 return NO_ERROR;
 828             case NATIVE_WINDOW_TRANSFORM_HINT:
 829                 *value = static_cast<int>(mTransformHint);
 830                 return NO_ERROR;
 831             case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: {
 832                 status_t err = NO_ERROR;
 833                 if (!mConsumerRunningBehind) {
 834                     *value = 0;
 835                 } else {
 836                     err = mGraphicBufferProducer->query(what, value);
 837                     if (err == NO_ERROR) {
 838                         mConsumerRunningBehind = *value;
 839                     }
 840                 }
 841                 return err;
 842             }
 843             case NATIVE_WINDOW_LAST_DEQUEUE_DURATION: {
 844                 int64_t durationUs = mLastDequeueDuration / 1000;
 845                 *value = durationUs > std::numeric_limits<int>::max() ?
 846                         std::numeric_limits<int>::max() :
 847                         static_cast<int>(durationUs);
 848                 return NO_ERROR;
 849             }
 850             case NATIVE_WINDOW_LAST_QUEUE_DURATION: {
 851                 int64_t durationUs = mLastQueueDuration / 1000;
 852                 *value = durationUs > std::numeric_limits<int>::max() ?
 853                         std::numeric_limits<int>::max() :
 854                         static_cast<int>(durationUs);
 855                 return NO_ERROR;
 856             }
 857             case NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT: {
 858                 querySupportedTimestampsLocked();
 859                 *value = mFrameTimestampsSupportsPresent ? 1 : 0;
 860                 return NO_ERROR;
 861             }
 862             case NATIVE_WINDOW_IS_VALID: {
 863                 *value = mGraphicBufferProducer != nullptr ? 1 : 0;
 864                 return NO_ERROR;
 865             }
 866         }
 867     }
 868     return mGraphicBufferProducer->query(what, value);
 869 }
 870
 871 int Surface::perform(int operation, va_list args)
 872 {
 873     int res = NO_ERROR;
 874     switch (operation) {
 875     case NATIVE_WINDOW_CONNECT:
 876         // deprecated. must return NO_ERROR.
 877         break;
 878     case NATIVE_WINDOW_DISCONNECT:
 879         // deprecated. must return NO_ERROR.
 880         break;
 881     case NATIVE_WINDOW_SET_USAGE:
 882         res = dispatchSetUsage(args);
 883         break;
 884     case NATIVE_WINDOW_SET_CROP:
 885         res = dispatchSetCrop(args);
 886         break;
 887     case NATIVE_WINDOW_SET_BUFFER_COUNT:
 888         res = dispatchSetBufferCount(args);
 889         break;
 890     case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
 891         res = dispatchSetBuffersGeometry(args);
 892         break;
 893     case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:
 894         res = dispatchSetBuffersTransform(args);
 895         break;
 896     case NATIVE_WINDOW_SET_BUFFERS_STICKY_TRANSFORM:
 897         res = dispatchSetBuffersStickyTransform(args);
 898         break;
 899     case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:
 900         res = dispatchSetBuffersTimestamp(args);
 901         break;
 902     case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS:
 903         res = dispatchSetBuffersDimensions(args);
 904         break;
 905     case NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS:
 906         res = dispatchSetBuffersUserDimensions(args);
 907         break;
 908     case NATIVE_WINDOW_SET_BUFFERS_FORMAT:
 909         res = dispatchSetBuffersFormat(args);
 910         break;
 911     case NATIVE_WINDOW_LOCK:
 912         res = dispatchLock(args);
 913         break;
 914     case NATIVE_WINDOW_UNLOCK_AND_POST:
 915         res = dispatchUnlockAndPost(args);
 916         break;
 917     case NATIVE_WINDOW_SET_SCALING_MODE:
 918         res = dispatchSetScalingMode(args);
 919         break;
 920     case NATIVE_WINDOW_API_CONNECT:
 921         res = dispatchConnect(args);
 922         break;
 923     case NATIVE_WINDOW_API_DISCONNECT:
 924         res = dispatchDisconnect(args);
 925         break;
 926     case NATIVE_WINDOW_SET_SIDEBAND_STREAM:
 927         res = dispatchSetSidebandStream(args);
 928         break;
 929     case NATIVE_WINDOW_SET_BUFFERS_DATASPACE:
 930         res = dispatchSetBuffersDataSpace(args);
 931         break;
 932     case NATIVE_WINDOW_SET_SURFACE_DAMAGE:
 933         res = dispatchSetSurfaceDamage(args);
 934         break;
 935     case NATIVE_WINDOW_SET_SHARED_BUFFER_MODE:
 936         res = dispatchSetSharedBufferMode(args);
 937         break;
 938     case NATIVE_WINDOW_SET_AUTO_REFRESH:
 939         res = dispatchSetAutoRefresh(args);
 940         break;
 941     case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
 942         res = dispatchGetDisplayRefreshCycleDuration(args);
 943         break;
 944     case NATIVE_WINDOW_GET_NEXT_FRAME_ID:
 945         res = dispatchGetNextFrameId(args);
 946         break;
 947     case NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS:
 948         res = dispatchEnableFrameTimestamps(args);
 949         break;
 950     case NATIVE_WINDOW_GET_COMPOSITOR_TIMING:
 951         res = dispatchGetCompositorTiming(args);
 952         break;
 953     case NATIVE_WINDOW_GET_FRAME_TIMESTAMPS:
 954         res = dispatchGetFrameTimestamps(args);
 955         break;
 956     case NATIVE_WINDOW_GET_WIDE_COLOR_SUPPORT:
 957         res = dispatchGetWideColorSupport(args);
 958         break;
 959     case NATIVE_WINDOW_GET_HDR_SUPPORT:
 960         res = dispatchGetHdrSupport(args);
 961         break;
 962     default:
 963         res = NAME_NOT_FOUND;
 964         break;
 965     }
 966     return res;
 967 }
 968
 969 int Surface::dispatchConnect(va_list args) {
 970     int api = va_arg(args, int);
 971     return connect(api);
 972 }
 973
 974 int Surface::dispatchDisconnect(va_list args) {
 975     int api = va_arg(args, int);
 976     return disconnect(api);
 977 }
 978
 979 int Surface::dispatchSetUsage(va_list args) {
 980     int usage = va_arg(args, int);
 981     return setUsage(static_cast<uint32_t>(usage));
 982 }
 983
 984 int Surface::dispatchSetCrop(va_list args) {
 985     android_native_rect_t const* rect = va_arg(args, android_native_rect_t*);
 986     return setCrop(reinterpret_cast<Rect const*>(rect));
 987 }
 988
 989 int Surface::dispatchSetBufferCount(va_list args) {
 990     size_t bufferCount = va_arg(args, size_t);
 991     return setBufferCount(static_cast<int32_t>(bufferCount));
 992 }
 993
 994 int Surface::dispatchSetBuffersGeometry(va_list args) {
 995     uint32_t width = va_arg(args, uint32_t);
 996     uint32_t height = va_arg(args, uint32_t);
 997     PixelFormat format = va_arg(args, PixelFormat);
 998     int err = setBuffersDimensions(width, height);
 999     if (err != 0) {
1000         return err;
1001     }
1002     return setBuffersFormat(format);
1003 }
1004
1005 int Surface::dispatchSetBuffersDimensions(va_list args) {
1006     uint32_t width = va_arg(args, uint32_t);
1007     uint32_t height = va_arg(args, uint32_t);
1008     return setBuffersDimensions(width, height);
1009 }
1010
1011 int Surface::dispatchSetBuffersUserDimensions(va_list args) {
1012     uint32_t width = va_arg(args, uint32_t);
1013     uint32_t height = va_arg(args, uint32_t);
1014     return setBuffersUserDimensions(width, height);
1015 }
1016
1017 int Surface::dispatchSetBuffersFormat(va_list args) {
1018     PixelFormat format = va_arg(args, PixelFormat);
1019     return setBuffersFormat(format);
1020 }
1021
1022 int Surface::dispatchSetScalingMode(va_list args) {
1023     int mode = va_arg(args, int);
1024     return setScalingMode(mode);
1025 }
1026
1027 int Surface::dispatchSetBuffersTransform(va_list args) {
1028     uint32_t transform = va_arg(args, uint32_t);
1029     return setBuffersTransform(transform);
1030 }
1031
1032 int Surface::dispatchSetBuffersStickyTransform(va_list args) {
1033     uint32_t transform = va_arg(args, uint32_t);
1034     return setBuffersStickyTransform(transform);
1035 }
1036
1037 int Surface::dispatchSetBuffersTimestamp(va_list args) {
1038     int64_t timestamp = va_arg(args, int64_t);
1039     return setBuffersTimestamp(timestamp);
1040 }
1041
1042 int Surface::dispatchLock(va_list args) {
1043     ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*);
1044     ARect* inOutDirtyBounds = va_arg(args, ARect*);
1045     return lock(outBuffer, inOutDirtyBounds);
1046 }
1047
1048 int Surface::dispatchUnlockAndPost(va_list args __attribute__((unused))) {
1049     return unlockAndPost();
1050 }
1051
1052 int Surface::dispatchSetSidebandStream(va_list args) {
1053     native_handle_t* sH = va_arg(args, native_handle_t*);
1054     sp<NativeHandle> sidebandHandle = NativeHandle::create(sH, false);
1055     setSidebandStream(sidebandHandle);
1056     return OK;
1057 }
1058
1059 int Surface::dispatchSetBuffersDataSpace(va_list args) {
1060     android_dataspace dataspace =
1061             static_cast<android_dataspace>(va_arg(args, int));
1062     return setBuffersDataSpace(dataspace);
1063 }
1064
1065 int Surface::dispatchSetSurfaceDamage(va_list args) {
1066     android_native_rect_t* rects = va_arg(args, android_native_rect_t*);
1067     size_t numRects = va_arg(args, size_t);
1068     setSurfaceDamage(rects, numRects);
1069     return NO_ERROR;
1070 }
1071
1072 int Surface::dispatchSetSharedBufferMode(va_list args) {
1073     bool sharedBufferMode = va_arg(args, int);
1074     return setSharedBufferMode(sharedBufferMode);
1075 }
1076
1077 int Surface::dispatchSetAutoRefresh(va_list args) {
1078     bool autoRefresh = va_arg(args, int);
1079     return setAutoRefresh(autoRefresh);
1080 }
1081
1082 int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
1083     nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
1084     return getDisplayRefreshCycleDuration(outRefreshDuration);
1085 }
1086
1087 int Surface::dispatchGetNextFrameId(va_list args) {
1088     uint64_t* nextFrameId = va_arg(args, uint64_t*);
1089     *nextFrameId = getNextFrameNumber();
1090     return NO_ERROR;
1091 }
1092
1093 int Surface::dispatchEnableFrameTimestamps(va_list args) {
1094     bool enable = va_arg(args, int);
1095     enableFrameTimestamps(enable);
1096     return NO_ERROR;
1097 }
1098
1099 int Surface::dispatchGetCompositorTiming(va_list args) {
1100     nsecs_t* compositeDeadline = va_arg(args, int64_t*);
1101     nsecs_t* compositeInterval = va_arg(args, int64_t*);
1102     nsecs_t* compositeToPresentLatency = va_arg(args, int64_t*);
1103     return getCompositorTiming(compositeDeadline, compositeInterval,
1104             compositeToPresentLatency);
1105 }
1106
1107 int Surface::dispatchGetFrameTimestamps(va_list args) {
1108     uint64_t frameId = va_arg(args, uint64_t);
1109     nsecs_t* outRequestedPresentTime = va_arg(args, int64_t*);
1110     nsecs_t* outAcquireTime = va_arg(args, int64_t*);
1111     nsecs_t* outLatchTime = va_arg(args, int64_t*);
1112     nsecs_t* outFirstRefreshStartTime = va_arg(args, int64_t*);
1113     nsecs_t* outLastRefreshStartTime = va_arg(args, int64_t*);
1114     nsecs_t* outGpuCompositionDoneTime = va_arg(args, int64_t*);
1115     nsecs_t* outDisplayPresentTime = va_arg(args, int64_t*);
1116     nsecs_t* outDequeueReadyTime = va_arg(args, int64_t*);
1117     nsecs_t* outReleaseTime = va_arg(args, int64_t*);
1118     return getFrameTimestamps(frameId,
1119             outRequestedPresentTime, outAcquireTime, outLatchTime,
1120             outFirstRefreshStartTime, outLastRefreshStartTime,
1121             outGpuCompositionDoneTime, outDisplayPresentTime,
1122             outDequeueReadyTime, outReleaseTime);
1123 }
1124
1125 int Surface::dispatchGetWideColorSupport(va_list args) {
1126     bool* outSupport = va_arg(args, bool*);
1127     return getWideColorSupport(outSupport);
1128 }
1129
1130 int Surface::dispatchGetHdrSupport(va_list args) {
1131     bool* outSupport = va_arg(args, bool*);
1132     return getHdrSupport(outSupport);
1133 }
1134
1135 int Surface::connect(int api) {
1136     static sp<IProducerListener> listener = new DummyProducerListener();
1137     return connect(api, listener);
1138 }
1139
1140 int Surface::connect(int api, const sp<IProducerListener>& listener) {
1141     return connect(api, listener, false);
1142 }
1143
1144 int Surface::connect(
1145         int api, const sp<IProducerListener>& listener, bool reportBufferRemoval) {
1146     ATRACE_CALL();
1147     ALOGV("Surface::connect");
1148     Mutex::Autolock lock(mMutex);
1149     IGraphicBufferProducer::QueueBufferOutput output;
1150     mReportRemovedBuffers = reportBufferRemoval;
1151     int err = mGraphicBufferProducer->connect(listener, api, mProducerControlledByApp, &output);
1152     if (err == NO_ERROR) {
1153         mDefaultWidth = output.width;
1154         mDefaultHeight = output.height;
1155         mNextFrameNumber = output.nextFrameNumber;
1156
1157         // Disable transform hint if sticky transform is set.
1158         if (mStickyTransform == 0) {
1159             mTransformHint = output.transformHint;
1160         }
1161
1162         mConsumerRunningBehind = (output.numPendingBuffers >= 2);
1163     }
1164     if (!err && api == NATIVE_WINDOW_API_CPU) {
1165         mConnectedToCpu = true;
1166         // Clear the dirty region in case we're switching from a non-CPU API
1167         mDirtyRegion.clear();
1168     } else if (!err) {
1169         // Initialize the dirty region for tracking surface damage
1170         mDirtyRegion = Region::INVALID_REGION;
1171     }
1172
1173     return err;
1174 }
1175
1176
1177 int Surface::disconnect(int api, IGraphicBufferProducer::DisconnectMode mode) {
1178     ATRACE_CALL();
1179     ALOGV("Surface::disconnect");
1180     Mutex::Autolock lock(mMutex);
1181     mRemovedBuffers.clear();
1182     mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
1183     mSharedBufferHasBeenQueued = false;
1184     freeAllBuffers();
1185     int err = mGraphicBufferProducer->disconnect(api, mode);
1186     if (!err) {
1187         mReqFormat = 0;
1188         mReqWidth = 0;
1189         mReqHeight = 0;
1190         mReqUsage = 0;
1191         mCrop.clear();
1192         mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
1193         mTransform = 0;
1194         mStickyTransform = 0;
1195
1196         if (api == NATIVE_WINDOW_API_CPU) {
1197             mConnectedToCpu = false;
1198         }
1199     }
1200     return err;
1201 }
1202
1203 int Surface::detachNextBuffer(sp<GraphicBuffer>* outBuffer,
1204         sp<Fence>* outFence) {
1205     ATRACE_CALL();
1206     ALOGV("Surface::detachNextBuffer");
1207
1208     if (outBuffer == NULL || outFence == NULL) {
1209         return BAD_VALUE;
1210     }
1211
1212     Mutex::Autolock lock(mMutex);
1213     if (mReportRemovedBuffers) {
1214         mRemovedBuffers.clear();
1215     }
1216
1217     sp<GraphicBuffer> buffer(NULL);
1218     sp<Fence> fence(NULL);
1219     status_t result = mGraphicBufferProducer->detachNextBuffer(
1220             &buffer, &fence);
1221     if (result != NO_ERROR) {
1222         return result;
1223     }
1224
1225     *outBuffer = buffer;
1226     if (fence != NULL && fence->isValid()) {
1227         *outFence = fence;
1228     } else {
1229         *outFence = Fence::NO_FENCE;
1230     }
1231
1232     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
1233         if (mSlots[i].buffer != NULL &&
1234                 mSlots[i].buffer->handle == buffer->handle) {
1235             if (mReportRemovedBuffers) {
1236                 mRemovedBuffers.push_back(mSlots[i].buffer);
1237             }
1238             mSlots[i].buffer = NULL;
1239         }
1240     }
1241
1242     return NO_ERROR;
1243 }
1244
1245 int Surface::attachBuffer(ANativeWindowBuffer* buffer)
1246 {
1247     ATRACE_CALL();
1248     ALOGV("Surface::attachBuffer");
1249
1250     Mutex::Autolock lock(mMutex);
1251     if (mReportRemovedBuffers) {
1252         mRemovedBuffers.clear();
1253     }
1254
1255     sp<GraphicBuffer> graphicBuffer(static_cast<GraphicBuffer*>(buffer));
1256     uint32_t priorGeneration = graphicBuffer->mGenerationNumber;
1257     graphicBuffer->mGenerationNumber = mGenerationNumber;
1258     int32_t attachedSlot = -1;
1259     status_t result = mGraphicBufferProducer->attachBuffer(
1260             &attachedSlot, graphicBuffer);
1261     if (result != NO_ERROR) {
1262         ALOGE("attachBuffer: IGraphicBufferProducer call failed (%d)", result);
1263         graphicBuffer->mGenerationNumber = priorGeneration;
1264         return result;
1265     }
1266     if (mReportRemovedBuffers && (mSlots[attachedSlot].buffer != nullptr)) {
1267         mRemovedBuffers.push_back(mSlots[attachedSlot].buffer);
1268     }
1269     mSlots[attachedSlot].buffer = graphicBuffer;
1270
1271     return NO_ERROR;
1272 }
1273
1274 int Surface::setUsage(uint32_t reqUsage)
1275 {
1276     ALOGV("Surface::setUsage");
1277     Mutex::Autolock lock(mMutex);
1278     if (reqUsage != mReqUsage) {
1279         mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
1280     }
1281     mReqUsage = reqUsage;
1282     return OK;
1283 }
1284
1285 int Surface::setCrop(Rect const* rect)
1286 {
1287     ATRACE_CALL();
1288
1289     Rect realRect(Rect::EMPTY_RECT);
1290     if (rect == NULL || rect->isEmpty()) {
1291         realRect.clear();
1292     } else {
1293         realRect = *rect;
1294     }
1295
1296     ALOGV("Surface::setCrop rect=[%d %d %d %d]",
1297             realRect.left, realRect.top, realRect.right, realRect.bottom);
1298
1299     Mutex::Autolock lock(mMutex);
1300     mCrop = realRect;
1301     return NO_ERROR;
1302 }
1303
1304 int Surface::setBufferCount(int bufferCount)
1305 {
1306     ATRACE_CALL();
1307     ALOGV("Surface::setBufferCount");
1308     Mutex::Autolock lock(mMutex);
1309
1310     status_t err = NO_ERROR;
1311     if (bufferCount == 0) {
1312         err = mGraphicBufferProducer->setMaxDequeuedBufferCount(1);
1313     } else {
1314         int minUndequeuedBuffers = 0;
1315         err = mGraphicBufferProducer->query(
1316                 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBuffers);
1317         if (err == NO_ERROR) {
1318             err = mGraphicBufferProducer->setMaxDequeuedBufferCount(
1319                     bufferCount - minUndequeuedBuffers);
1320         }
1321     }
1322
1323     ALOGE_IF(err, "IGraphicBufferProducer::setBufferCount(%d) returned %s",
1324              bufferCount, strerror(-err));
1325
1326     return err;
1327 }
1328
1329 int Surface::setMaxDequeuedBufferCount(int maxDequeuedBuffers) {
1330     ATRACE_CALL();
1331     ALOGV("Surface::setMaxDequeuedBufferCount");
1332     Mutex::Autolock lock(mMutex);
1333
1334     status_t err = mGraphicBufferProducer->setMaxDequeuedBufferCount(
1335             maxDequeuedBuffers);
1336     ALOGE_IF(err, "IGraphicBufferProducer::setMaxDequeuedBufferCount(%d) "
1337             "returned %s", maxDequeuedBuffers, strerror(-err));
1338
1339     return err;
1340 }
1341
1342 int Surface::setAsyncMode(bool async) {
1343     ATRACE_CALL();
1344     ALOGV("Surface::setAsyncMode");
1345     Mutex::Autolock lock(mMutex);
1346
1347     status_t err = mGraphicBufferProducer->setAsyncMode(async);
1348     ALOGE_IF(err, "IGraphicBufferProducer::setAsyncMode(%d) returned %s",
1349             async, strerror(-err));
1350
1351     return err;
1352 }
1353
1354 int Surface::setSharedBufferMode(bool sharedBufferMode) {
1355     ATRACE_CALL();
1356     ALOGV("Surface::setSharedBufferMode (%d)", sharedBufferMode);
1357     Mutex::Autolock lock(mMutex);
1358
1359     status_t err = mGraphicBufferProducer->setSharedBufferMode(
1360             sharedBufferMode);
1361     if (err == NO_ERROR) {
1362         mSharedBufferMode = sharedBufferMode;
1363     }
1364     ALOGE_IF(err, "IGraphicBufferProducer::setSharedBufferMode(%d) returned"
1365             "%s", sharedBufferMode, strerror(-err));
1366
1367     return err;
1368 }
1369
1370 int Surface::setAutoRefresh(bool autoRefresh) {
1371     ATRACE_CALL();
1372     ALOGV("Surface::setAutoRefresh (%d)", autoRefresh);
1373     Mutex::Autolock lock(mMutex);
1374
1375     status_t err = mGraphicBufferProducer->setAutoRefresh(autoRefresh);
1376     if (err == NO_ERROR) {
1377         mAutoRefresh = autoRefresh;
1378     }
1379     ALOGE_IF(err, "IGraphicBufferProducer::setAutoRefresh(%d) returned %s",
1380             autoRefresh, strerror(-err));
1381     return err;
1382 }
1383
1384 int Surface::setBuffersDimensions(uint32_t width, uint32_t height)
1385 {
1386     ATRACE_CALL();
1387     ALOGV("Surface::setBuffersDimensions");
1388
1389     if ((width && !height) || (!width && height))
1390         return BAD_VALUE;
1391
1392     Mutex::Autolock lock(mMutex);
1393     if (width != mReqWidth || height != mReqHeight) {
1394         mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
1395     }
1396     mReqWidth = width;
1397     mReqHeight = height;
1398     return NO_ERROR;
1399 }
1400
1401 int Surface::setBuffersUserDimensions(uint32_t width, uint32_t height)
1402 {
1403     ATRACE_CALL();
1404     ALOGV("Surface::setBuffersUserDimensions");
1405
1406     if ((width && !height) || (!width && height))
1407         return BAD_VALUE;
1408
1409     Mutex::Autolock lock(mMutex);
1410     if (width != mUserWidth || height != mUserHeight) {
1411         mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
1412     }
1413     mUserWidth = width;
1414     mUserHeight = height;
1415     return NO_ERROR;
1416 }
1417
1418 int Surface::setBuffersFormat(PixelFormat format)
1419 {
1420     ALOGV("Surface::setBuffersFormat");
1421
1422     Mutex::Autolock lock(mMutex);
1423     if (format != mReqFormat) {
1424         mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
1425     }
1426     mReqFormat = format;
1427     return NO_ERROR;
1428 }
1429
1430 int Surface::setScalingMode(int mode)
1431 {
1432     ATRACE_CALL();
1433     ALOGV("Surface::setScalingMode(%d)", mode);
1434
1435     switch (mode) {
1436         case NATIVE_WINDOW_SCALING_MODE_FREEZE:
1437         case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW:
1438         case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP:
1439         case NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP:
1440             break;
1441         default:
1442             ALOGE("unknown scaling mode: %d", mode);
1443             return BAD_VALUE;
1444     }
1445
1446     Mutex::Autolock lock(mMutex);
1447     mScalingMode = mode;
1448     return NO_ERROR;
1449 }
1450
1451 int Surface::setBuffersTransform(uint32_t transform)
1452 {
1453     ATRACE_CALL();
1454     ALOGV("Surface::setBuffersTransform");
1455     Mutex::Autolock lock(mMutex);
1456     mTransform = transform;
1457     return NO_ERROR;
1458 }
1459
1460 int Surface::setBuffersStickyTransform(uint32_t transform)
1461 {
1462     ATRACE_CALL();
1463     ALOGV("Surface::setBuffersStickyTransform");
1464     Mutex::Autolock lock(mMutex);
1465     mStickyTransform = transform;
1466     return NO_ERROR;
1467 }
1468
1469 int Surface::setBuffersTimestamp(int64_t timestamp)
1470 {
1471     ALOGV("Surface::setBuffersTimestamp");
1472     Mutex::Autolock lock(mMutex);
1473     mTimestamp = timestamp;
1474     return NO_ERROR;
1475 }
1476
1477 int Surface::setBuffersDataSpace(android_dataspace dataSpace)
1478 {
1479     ALOGV("Surface::setBuffersDataSpace");
1480     Mutex::Autolock lock(mMutex);
1481     mDataSpace = dataSpace;
1482     return NO_ERROR;
1483 }
1484
1485 void Surface::freeAllBuffers() {
1486     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
1487         mSlots[i].buffer = 0;
1488     }
1489 }
1490
1491 void Surface::setSurfaceDamage(android_native_rect_t* rects, size_t numRects) {
1492     ATRACE_CALL();
1493     ALOGV("Surface::setSurfaceDamage");
1494     Mutex::Autolock lock(mMutex);
1495
1496     if (mConnectedToCpu || numRects == 0) {
1497         mDirtyRegion = Region::INVALID_REGION;
1498         return;
1499     }
1500
1501     mDirtyRegion.clear();
1502     for (size_t r = 0; r < numRects; ++r) {
1503         // We intentionally flip top and bottom here, since because they're
1504         // specified with a bottom-left origin, top > bottom, which fails
1505         // validation in the Region class. We will fix this up when we flip to a
1506         // top-left origin in queueBuffer.
1507         Rect rect(rects[r].left, rects[r].bottom, rects[r].right, rects[r].top);
1508         mDirtyRegion.orSelf(rect);
1509     }
1510 }
1511
1512 // ----------------------------------------------------------------------
1513 // the lock/unlock APIs must be used from the same thread
1514
1515 static status_t copyBlt(
1516         const sp<GraphicBuffer>& dst,
1517         const sp<GraphicBuffer>& src,
1518         const Region& reg,
1519         int *dstFenceFd)
1520 {
1521     // src and dst with, height and format must be identical. no verification
1522     // is done here.
1523     status_t err;
1524     uint8_t* src_bits = NULL;
1525     err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(),
1526             reinterpret_cast<void**>(&src_bits));
1527     ALOGE_IF(err, "error locking src buffer %s", strerror(-err));
1528
1529     uint8_t* dst_bits = NULL;
1530     err = dst->lockAsync(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(),
1531             reinterpret_cast<void**>(&dst_bits), *dstFenceFd);
1532     ALOGE_IF(err, "error locking dst buffer %s", strerror(-err));
1533     *dstFenceFd = -1;
1534
1535     Region::const_iterator head(reg.begin());
1536     Region::const_iterator tail(reg.end());
1537     if (head != tail && src_bits && dst_bits) {
1538         const size_t bpp = bytesPerPixel(src->format);
1539         const size_t dbpr = static_cast<uint32_t>(dst->stride) * bpp;
1540         const size_t sbpr = static_cast<uint32_t>(src->stride) * bpp;
1541
1542         while (head != tail) {
1543             const Rect& r(*head++);
1544             int32_t h = r.height();
1545             if (h <= 0) continue;
1546             size_t size = static_cast<uint32_t>(r.width()) * bpp;
1547             uint8_t const * s = src_bits +
1548                     static_cast<uint32_t>(r.left + src->stride * r.top) * bpp;
1549             uint8_t       * d = dst_bits +
1550                     static_cast<uint32_t>(r.left + dst->stride * r.top) * bpp;
1551             if (dbpr==sbpr && size==sbpr) {
1552                 size *= static_cast<size_t>(h);
1553                 h = 1;
1554             }
1555             do {
1556                 memcpy(d, s, size);
1557                 d += dbpr;
1558                 s += sbpr;
1559             } while (--h > 0);
1560         }
1561     }
1562
1563     if (src_bits)
1564         src->unlock();
1565
1566     if (dst_bits)
1567         dst->unlockAsync(dstFenceFd);
1568
1569     return err;
1570 }
1571
1572 // ----------------------------------------------------------------------------
1573
1574 status_t Surface::lock(
1575         ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)
1576 {
1577     if (mLockedBuffer != 0) {
1578         ALOGE("Surface::lock failed, already locked");
1579         return INVALID_OPERATION;
1580     }
1581
1582     if (!mConnectedToCpu) {
1583         int err = Surface::connect(NATIVE_WINDOW_API_CPU);
1584         if (err) {
1585             return err;
1586         }
1587         // we're intending to do software rendering from this point
1588         setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
1589     }
1590
1591     ANativeWindowBuffer* out;
1592     int fenceFd = -1;
1593     status_t err = dequeueBuffer(&out, &fenceFd);
1594     ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));
1595     if (err == NO_ERROR) {
1596         sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));
1597         const Rect bounds(backBuffer->width, backBuffer->height);
1598
1599         Region newDirtyRegion;
1600         if (inOutDirtyBounds) {
1601             newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds));
1602             newDirtyRegion.andSelf(bounds);
1603         } else {
1604             newDirtyRegion.set(bounds);
1605         }
1606
1607         // figure out if we can copy the frontbuffer back
1608         const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);
1609         const bool canCopyBack = (frontBuffer != 0 &&
1610                 backBuffer->width  == frontBuffer->width &&
1611                 backBuffer->height == frontBuffer->height &&
1612                 backBuffer->format == frontBuffer->format);
1613
1614         if (canCopyBack) {
1615             // copy the area that is invalid and not repainted this round
1616             const Region copyback(mDirtyRegion.subtract(newDirtyRegion));
1617             if (!copyback.isEmpty()) {
1618                 copyBlt(backBuffer, frontBuffer, copyback, &fenceFd);
1619             }
1620         } else {
1621             // if we can't copy-back anything, modify the user's dirty
1622             // region to make sure they redraw the whole buffer
1623             newDirtyRegion.set(bounds);
1624             mDirtyRegion.clear();
1625             Mutex::Autolock lock(mMutex);
1626             for (size_t i=0 ; i<NUM_BUFFER_SLOTS ; i++) {
1627                 mSlots[i].dirtyRegion.clear();
1628             }
1629         }
1630
1631
1632         { // scope for the lock
1633             Mutex::Autolock lock(mMutex);
1634             int backBufferSlot(getSlotFromBufferLocked(backBuffer.get()));
1635             if (backBufferSlot >= 0) {
1636                 Region& dirtyRegion(mSlots[backBufferSlot].dirtyRegion);
1637                 mDirtyRegion.subtract(dirtyRegion);
1638                 dirtyRegion = newDirtyRegion;
1639             }
1640         }
1641
1642         mDirtyRegion.orSelf(newDirtyRegion);
1643         if (inOutDirtyBounds) {
1644             *inOutDirtyBounds = newDirtyRegion.getBounds();
1645         }
1646
1647         void* vaddr;
1648         status_t res = backBuffer->lockAsync(
1649                 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
1650                 newDirtyRegion.bounds(), &vaddr, fenceFd);
1651
1652         ALOGW_IF(res, "failed locking buffer (handle = %p)",
1653                 backBuffer->handle);
1654
1655         if (res != 0) {
1656             err = INVALID_OPERATION;
1657         } else {
1658             mLockedBuffer = backBuffer;
1659             outBuffer->width  = backBuffer->width;
1660             outBuffer->height = backBuffer->height;
1661             outBuffer->stride = backBuffer->stride;
1662             outBuffer->format = backBuffer->format;
1663             outBuffer->bits   = vaddr;
1664         }
1665     }
1666     return err;
1667 }
1668
1669 status_t Surface::unlockAndPost()
1670 {
1671     if (mLockedBuffer == 0) {
1672         ALOGE("Surface::unlockAndPost failed, no locked buffer");
1673         return INVALID_OPERATION;
1674     }
1675
1676     int fd = -1;
1677     status_t err = mLockedBuffer->unlockAsync(&fd);
1678     ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);
1679
1680     err = queueBuffer(mLockedBuffer.get(), fd);
1681     ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",
1682             mLockedBuffer->handle, strerror(-err));
1683
1684     mPostedBuffer = mLockedBuffer;
1685     mLockedBuffer = 0;
1686     return err;
1687 }
1688
1689 bool Surface::waitForNextFrame(uint64_t lastFrame, nsecs_t timeout) {
1690     Mutex::Autolock lock(mMutex);
1691     if (mNextFrameNumber > lastFrame) {
1692       return true;
1693     }
1694     return mQueueBufferCondition.waitRelative(mMutex, timeout) == OK;
1695 }
1696
1697 status_t Surface::getUniqueId(uint64_t* outId) const {
1698     Mutex::Autolock lock(mMutex);
1699     return mGraphicBufferProducer->getUniqueId(outId);
1700 }
1701
1702 status_t Surface::getAndFlushRemovedBuffers(std::vector<sp<GraphicBuffer>>* out) {
1703     if (out == nullptr) {
1704         ALOGE("%s: out must not be null!", __FUNCTION__);
1705         return BAD_VALUE;
1706     }
1707
1708     Mutex::Autolock lock(mMutex);
1709     *out = mRemovedBuffers;
1710     mRemovedBuffers.clear();
1711     return OK;
1712 }
1713
1714 }; // namespace android