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 <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