Home | History | Annotate | Download | only in DisplayHardware 
      1 /*
      2  * Copyright 2013 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_NDEBUG 0
     18 #include "VirtualDisplaySurface.h"
     19 #include "HWComposer.h"
     20 
     21 #include <gui/BufferItem.h>
     22 #include <gui/IProducerListener.h>
     23 
     24 // ---------------------------------------------------------------------------
     25 namespace android {
     26 // ---------------------------------------------------------------------------
     27 
     28 #if defined(FORCE_HWC_COPY_FOR_VIRTUAL_DISPLAYS)
     29 static const bool sForceHwcCopy = true;
     30 #else
     31 static const bool sForceHwcCopy = false;
     32 #endif
     33 
     34 #define VDS_LOGE(msg, ...) ALOGE("[%s] " msg, \
     35         mDisplayName.string(), ##__VA_ARGS__)
     36 #define VDS_LOGW_IF(cond, msg, ...) ALOGW_IF(cond, "[%s] " msg, \
     37         mDisplayName.string(), ##__VA_ARGS__)
     38 #define VDS_LOGV(msg, ...) ALOGV("[%s] " msg, \
     39         mDisplayName.string(), ##__VA_ARGS__)
     40 
     41 static const char* dbgCompositionTypeStr(DisplaySurface::CompositionType type) {
     42     switch (type) {
     43         case DisplaySurface::COMPOSITION_UNKNOWN: return "UNKNOWN";
     44         case DisplaySurface::COMPOSITION_GLES:    return "GLES";
     45         case DisplaySurface::COMPOSITION_HWC:     return "HWC";
     46         case DisplaySurface::COMPOSITION_MIXED:   return "MIXED";
     47         default:                                  return "<INVALID>";
     48     }
     49 }
     50 
     51 VirtualDisplaySurface::VirtualDisplaySurface(HWComposer& hwc, int32_t dispId,
     52         const sp<IGraphicBufferProducer>& sink,
     53         const sp<IGraphicBufferProducer>& bqProducer,
     54         const sp<IGraphicBufferConsumer>& bqConsumer,
     55         const String8& name)
     56 :   ConsumerBase(bqConsumer),
     57     mHwc(hwc),
     58     mDisplayId(dispId),
     59     mDisplayName(name),
     60     mSource{},
     61     mDefaultOutputFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
     62     mOutputFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
     63     mOutputUsage(GRALLOC_USAGE_HW_COMPOSER),
     64     mProducerSlotSource(0),
     65     mProducerBuffers(),
     66     mQueueBufferOutput(),
     67     mSinkBufferWidth(0),
     68     mSinkBufferHeight(0),
     69     mCompositionType(COMPOSITION_UNKNOWN),
     70     mFbFence(Fence::NO_FENCE),
     71     mOutputFence(Fence::NO_FENCE),
     72     mFbProducerSlot(BufferQueue::INVALID_BUFFER_SLOT),
     73     mOutputProducerSlot(BufferQueue::INVALID_BUFFER_SLOT),
     74     mDbgState(DBG_STATE_IDLE),
     75     mDbgLastCompositionType(COMPOSITION_UNKNOWN),
     76     mMustRecompose(false)
     77 {
     78     mSource[SOURCE_SINK] = sink;
     79     mSource[SOURCE_SCRATCH] = bqProducer;
     80 
     81     resetPerFrameState();
     82 
     83     int sinkWidth, sinkHeight;
     84     sink->query(NATIVE_WINDOW_WIDTH, &sinkWidth);
     85     sink->query(NATIVE_WINDOW_HEIGHT, &sinkHeight);
     86     mSinkBufferWidth = sinkWidth;
     87     mSinkBufferHeight = sinkHeight;
     88 
     89     // Pick the buffer format to request from the sink when not rendering to it
     90     // with GLES. If the consumer needs CPU access, use the default format
     91     // set by the consumer. Otherwise allow gralloc to decide the format based
     92     // on usage bits.
     93     int sinkUsage;
     94     sink->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS, &sinkUsage);
     95     if (sinkUsage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) {
     96         int sinkFormat;
     97         sink->query(NATIVE_WINDOW_FORMAT, &sinkFormat);
     98         mDefaultOutputFormat = sinkFormat;
     99     } else {
    100         mDefaultOutputFormat = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
    101     }
    102     mOutputFormat = mDefaultOutputFormat;
    103 
    104     ConsumerBase::mName = String8::format("VDS: %s", mDisplayName.string());
    105     mConsumer->setConsumerName(ConsumerBase::mName);
    106     mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_COMPOSER);
    107     mConsumer->setDefaultBufferSize(sinkWidth, sinkHeight);
    108     sink->setAsyncMode(true);
    109     IGraphicBufferProducer::QueueBufferOutput output;
    110     mSource[SOURCE_SCRATCH]->connect(NULL, NATIVE_WINDOW_API_EGL, false, &output);
    111 }
    112 
    113 VirtualDisplaySurface::~VirtualDisplaySurface() {
    114     mSource[SOURCE_SCRATCH]->disconnect(NATIVE_WINDOW_API_EGL);
    115 }
    116 
    117 status_t VirtualDisplaySurface::beginFrame(bool mustRecompose) {
    118     if (mDisplayId < 0)
    119         return NO_ERROR;
    120 
    121     mMustRecompose = mustRecompose;
    122 
    123     VDS_LOGW_IF(mDbgState != DBG_STATE_IDLE,
    124             "Unexpected beginFrame() in %s state", dbgStateStr());
    125     mDbgState = DBG_STATE_BEGUN;
    126 
    127     return refreshOutputBuffer();
    128 }
    129 
    130 status_t VirtualDisplaySurface::prepareFrame(CompositionType compositionType) {
    131     if (mDisplayId < 0)
    132         return NO_ERROR;
    133 
    134     VDS_LOGW_IF(mDbgState != DBG_STATE_BEGUN,
    135             "Unexpected prepareFrame() in %s state", dbgStateStr());
    136     mDbgState = DBG_STATE_PREPARED;
    137 
    138     mCompositionType = compositionType;
    139     if (sForceHwcCopy && mCompositionType == COMPOSITION_GLES) {
    140         // Some hardware can do RGB->YUV conversion more efficiently in hardware
    141         // controlled by HWC than in hardware controlled by the video encoder.
    142         // Forcing GLES-composed frames to go through an extra copy by the HWC
    143         // allows the format conversion to happen there, rather than passing RGB
    144         // directly to the consumer.
    145         //
    146         // On the other hand, when the consumer prefers RGB or can consume RGB
    147         // inexpensively, this forces an unnecessary copy.
    148         mCompositionType = COMPOSITION_MIXED;
    149     }
    150 
    151     if (mCompositionType != mDbgLastCompositionType) {
    152         VDS_LOGV("prepareFrame: composition type changed to %s",
    153                 dbgCompositionTypeStr(mCompositionType));
    154         mDbgLastCompositionType = mCompositionType;
    155     }
    156 
    157     if (mCompositionType != COMPOSITION_GLES &&
    158             (mOutputFormat != mDefaultOutputFormat ||
    159              mOutputUsage != GRALLOC_USAGE_HW_COMPOSER)) {
    160         // We must have just switched from GLES-only to MIXED or HWC
    161         // composition. Stop using the format and usage requested by the GLES
    162         // driver; they may be suboptimal when HWC is writing to the output
    163         // buffer. For example, if the output is going to a video encoder, and
    164         // HWC can write directly to YUV, some hardware can skip a
    165         // memory-to-memory RGB-to-YUV conversion step.
    166         //
    167         // If we just switched *to* GLES-only mode, we'll change the
    168         // format/usage and get a new buffer when the GLES driver calls
    169         // dequeueBuffer().
    170         mOutputFormat = mDefaultOutputFormat;
    171         mOutputUsage = GRALLOC_USAGE_HW_COMPOSER;
    172         refreshOutputBuffer();
    173     }
    174 
    175     return NO_ERROR;
    176 }
    177 
    178 #ifndef USE_HWC2
    179 status_t VirtualDisplaySurface::compositionComplete() {
    180     return NO_ERROR;
    181 }
    182 #endif
    183 
    184 status_t VirtualDisplaySurface::advanceFrame() {
    185     if (mDisplayId < 0)
    186         return NO_ERROR;
    187 
    188     if (mCompositionType == COMPOSITION_HWC) {
    189         VDS_LOGW_IF(mDbgState != DBG_STATE_PREPARED,
    190                 "Unexpected advanceFrame() in %s state on HWC frame",
    191                 dbgStateStr());
    192     } else {
    193         VDS_LOGW_IF(mDbgState != DBG_STATE_GLES_DONE,
    194                 "Unexpected advanceFrame() in %s state on GLES/MIXED frame",
    195                 dbgStateStr());
    196     }
    197     mDbgState = DBG_STATE_HWC;
    198 
    199     if (mOutputProducerSlot < 0 ||
    200             (mCompositionType != COMPOSITION_HWC && mFbProducerSlot < 0)) {
    201         // Last chance bailout if something bad happened earlier. For example,
    202         // in a GLES configuration, if the sink disappears then dequeueBuffer
    203         // will fail, the GLES driver won't queue a buffer, but SurfaceFlinger
    204         // will soldier on. So we end up here without a buffer. There should
    205         // be lots of scary messages in the log just before this.
    206         VDS_LOGE("advanceFrame: no buffer, bailing out");
    207         return NO_MEMORY;
    208     }
    209 
    210     sp<GraphicBuffer> fbBuffer = mFbProducerSlot >= 0 ?
    211             mProducerBuffers[mFbProducerSlot] : sp<GraphicBuffer>(NULL);
    212     sp<GraphicBuffer> outBuffer = mProducerBuffers[mOutputProducerSlot];
    213     VDS_LOGV("advanceFrame: fb=%d(%p) out=%d(%p)",
    214             mFbProducerSlot, fbBuffer.get(),
    215             mOutputProducerSlot, outBuffer.get());
    216 
    217     // At this point we know the output buffer acquire fence,
    218     // so update HWC state with it.
    219     mHwc.setOutputBuffer(mDisplayId, mOutputFence, outBuffer);
    220 
    221     status_t result = NO_ERROR;
    222     if (fbBuffer != NULL) {
    223 #ifdef USE_HWC2
    224         // TODO: Correctly propagate the dataspace from GL composition
    225         result = mHwc.setClientTarget(mDisplayId, mFbFence, fbBuffer,
    226                 HAL_DATASPACE_UNKNOWN);
    227 #else
    228         result = mHwc.fbPost(mDisplayId, mFbFence, fbBuffer);
    229 #endif
    230     }
    231 
    232     return result;
    233 }
    234 
    235 void VirtualDisplaySurface::onFrameCommitted() {
    236     if (mDisplayId < 0)
    237         return;
    238 
    239     VDS_LOGW_IF(mDbgState != DBG_STATE_HWC,
    240             "Unexpected onFrameCommitted() in %s state", dbgStateStr());
    241     mDbgState = DBG_STATE_IDLE;
    242 
    243 #ifdef USE_HWC2
    244     sp<Fence> retireFence = mHwc.getRetireFence(mDisplayId);
    245 #else
    246     sp<Fence> fbFence = mHwc.getAndResetReleaseFence(mDisplayId);
    247 #endif
    248     if (mCompositionType == COMPOSITION_MIXED && mFbProducerSlot >= 0) {
    249         // release the scratch buffer back to the pool
    250         Mutex::Autolock lock(mMutex);
    251         int sslot = mapProducer2SourceSlot(SOURCE_SCRATCH, mFbProducerSlot);
    252         VDS_LOGV("onFrameCommitted: release scratch sslot=%d", sslot);
    253 #ifdef USE_HWC2
    254         addReleaseFenceLocked(sslot, mProducerBuffers[mFbProducerSlot],
    255                 retireFence);
    256 #else
    257         addReleaseFenceLocked(sslot, mProducerBuffers[mFbProducerSlot], fbFence);
    258 #endif
    259         releaseBufferLocked(sslot, mProducerBuffers[mFbProducerSlot],
    260                 EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
    261     }
    262 
    263     if (mOutputProducerSlot >= 0) {
    264         int sslot = mapProducer2SourceSlot(SOURCE_SINK, mOutputProducerSlot);
    265         QueueBufferOutput qbo;
    266 #ifndef USE_HWC2
    267         sp<Fence> outFence = mHwc.getLastRetireFence(mDisplayId);
    268 #endif
    269         VDS_LOGV("onFrameCommitted: queue sink sslot=%d", sslot);
    270         if (mMustRecompose) {
    271             status_t result = mSource[SOURCE_SINK]->queueBuffer(sslot,
    272                     QueueBufferInput(
    273                         systemTime(), false /* isAutoTimestamp */,
    274                         HAL_DATASPACE_UNKNOWN,
    275                         Rect(mSinkBufferWidth, mSinkBufferHeight),
    276                         NATIVE_WINDOW_SCALING_MODE_FREEZE, 0 /* transform */,
    277 #ifdef USE_HWC2
    278                         retireFence),
    279 #else
    280                         outFence),
    281 #endif
    282                     &qbo);
    283             if (result == NO_ERROR) {
    284                 updateQueueBufferOutput(qbo);
    285             }
    286         } else {
    287             // If the surface hadn't actually been updated, then we only went
    288             // through the motions of updating the display to keep our state
    289             // machine happy. We cancel the buffer to avoid triggering another
    290             // re-composition and causing an infinite loop.
    291 #ifdef USE_HWC2
    292             mSource[SOURCE_SINK]->cancelBuffer(sslot, retireFence);
    293 #else
    294             mSource[SOURCE_SINK]->cancelBuffer(sslot, outFence);
    295 #endif
    296         }
    297     }
    298 
    299     resetPerFrameState();
    300 }
    301 
    302 void VirtualDisplaySurface::dumpAsString(String8& /* result */) const {
    303 }
    304 
    305 void VirtualDisplaySurface::resizeBuffers(const uint32_t w, const uint32_t h) {
    306     uint32_t tmpW, tmpH, transformHint, numPendingBuffers;
    307     uint64_t nextFrameNumber;
    308     mQueueBufferOutput.deflate(&tmpW, &tmpH, &transformHint, &numPendingBuffers,
    309             &nextFrameNumber);
    310     mQueueBufferOutput.inflate(w, h, transformHint, numPendingBuffers,
    311             nextFrameNumber);
    312 
    313     mSinkBufferWidth = w;
    314     mSinkBufferHeight = h;
    315 }
    316 
    317 const sp<Fence>& VirtualDisplaySurface::getClientTargetAcquireFence() const {
    318     return mFbFence;
    319 }
    320 
    321 status_t VirtualDisplaySurface::requestBuffer(int pslot,
    322         sp<GraphicBuffer>* outBuf) {
    323     if (mDisplayId < 0)
    324         return mSource[SOURCE_SINK]->requestBuffer(pslot, outBuf);
    325 
    326     VDS_LOGW_IF(mDbgState != DBG_STATE_GLES,
    327             "Unexpected requestBuffer pslot=%d in %s state",
    328             pslot, dbgStateStr());
    329 
    330     *outBuf = mProducerBuffers[pslot];
    331     return NO_ERROR;
    332 }
    333 
    334 status_t VirtualDisplaySurface::setMaxDequeuedBufferCount(
    335         int maxDequeuedBuffers) {
    336     return mSource[SOURCE_SINK]->setMaxDequeuedBufferCount(maxDequeuedBuffers);
    337 }
    338 
    339 status_t VirtualDisplaySurface::setAsyncMode(bool async) {
    340     return mSource[SOURCE_SINK]->setAsyncMode(async);
    341 }
    342 
    343 status_t VirtualDisplaySurface::dequeueBuffer(Source source,
    344         PixelFormat format, uint32_t usage, int* sslot, sp<Fence>* fence) {
    345     LOG_FATAL_IF(mDisplayId < 0, "mDisplayId=%d but should not be < 0.", mDisplayId);
    346 
    347     status_t result = mSource[source]->dequeueBuffer(sslot, fence,
    348             mSinkBufferWidth, mSinkBufferHeight, format, usage);
    349     if (result < 0)
    350         return result;
    351     int pslot = mapSource2ProducerSlot(source, *sslot);
    352     VDS_LOGV("dequeueBuffer(%s): sslot=%d pslot=%d result=%d",
    353             dbgSourceStr(source), *sslot, pslot, result);
    354     uint64_t sourceBit = static_cast<uint64_t>(source) << pslot;
    355 
    356     if ((mProducerSlotSource & (1ULL << pslot)) != sourceBit) {
    357         // This slot was previously dequeued from the other source; must
    358         // re-request the buffer.
    359         result |= BUFFER_NEEDS_REALLOCATION;
    360         mProducerSlotSource &= ~(1ULL << pslot);
    361         mProducerSlotSource |= sourceBit;
    362     }
    363 
    364     if (result & RELEASE_ALL_BUFFERS) {
    365         for (uint32_t i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
    366             if ((mProducerSlotSource & (1ULL << i)) == sourceBit)
    367                 mProducerBuffers[i].clear();
    368         }
    369     }
    370     if (result & BUFFER_NEEDS_REALLOCATION) {
    371         result = mSource[source]->requestBuffer(*sslot, &mProducerBuffers[pslot]);
    372         if (result < 0) {
    373             mProducerBuffers[pslot].clear();
    374             mSource[source]->cancelBuffer(*sslot, *fence);
    375             return result;
    376         }
    377         VDS_LOGV("dequeueBuffer(%s): buffers[%d]=%p fmt=%d usage=%#x",
    378                 dbgSourceStr(source), pslot, mProducerBuffers[pslot].get(),
    379                 mProducerBuffers[pslot]->getPixelFormat(),
    380                 mProducerBuffers[pslot]->getUsage());
    381     }
    382 
    383     return result;
    384 }
    385 
    386 status_t VirtualDisplaySurface::dequeueBuffer(int* pslot, sp<Fence>* fence,
    387         uint32_t w, uint32_t h, PixelFormat format, uint32_t usage) {
    388     if (mDisplayId < 0)
    389         return mSource[SOURCE_SINK]->dequeueBuffer(pslot, fence, w, h, format, usage);
    390 
    391     VDS_LOGW_IF(mDbgState != DBG_STATE_PREPARED,
    392             "Unexpected dequeueBuffer() in %s state", dbgStateStr());
    393     mDbgState = DBG_STATE_GLES;
    394 
    395     VDS_LOGV("dequeueBuffer %dx%d fmt=%d usage=%#x", w, h, format, usage);
    396 
    397     status_t result = NO_ERROR;
    398     Source source = fbSourceForCompositionType(mCompositionType);
    399 
    400     if (source == SOURCE_SINK) {
    401 
    402         if (mOutputProducerSlot < 0) {
    403             // Last chance bailout if something bad happened earlier. For example,
    404             // in a GLES configuration, if the sink disappears then dequeueBuffer
    405             // will fail, the GLES driver won't queue a buffer, but SurfaceFlinger
    406             // will soldier on. So we end up here without a buffer. There should
    407             // be lots of scary messages in the log just before this.
    408             VDS_LOGE("dequeueBuffer: no buffer, bailing out");
    409             return NO_MEMORY;
    410         }
    411 
    412         // We already dequeued the output buffer. If the GLES driver wants
    413         // something incompatible, we have to cancel and get a new one. This
    414         // will mean that HWC will see a different output buffer between
    415         // prepare and set, but since we're in GLES-only mode already it
    416         // shouldn't matter.
    417 
    418         usage |= GRALLOC_USAGE_HW_COMPOSER;
    419         const sp<GraphicBuffer>& buf = mProducerBuffers[mOutputProducerSlot];
    420         if ((usage & ~buf->getUsage()) != 0 ||
    421                 (format != 0 && format != buf->getPixelFormat()) ||
    422                 (w != 0 && w != mSinkBufferWidth) ||
    423                 (h != 0 && h != mSinkBufferHeight)) {
    424             VDS_LOGV("dequeueBuffer: dequeueing new output buffer: "
    425                     "want %dx%d fmt=%d use=%#x, "
    426                     "have %dx%d fmt=%d use=%#x",
    427                     w, h, format, usage,
    428                     mSinkBufferWidth, mSinkBufferHeight,
    429                     buf->getPixelFormat(), buf->getUsage());
    430             mOutputFormat = format;
    431             mOutputUsage = usage;
    432             result = refreshOutputBuffer();
    433             if (result < 0)
    434                 return result;
    435         }
    436     }
    437 
    438     if (source == SOURCE_SINK) {
    439         *pslot = mOutputProducerSlot;
    440         *fence = mOutputFence;
    441     } else {
    442         int sslot;
    443         result = dequeueBuffer(source, format, usage, &sslot, fence);
    444         if (result >= 0) {
    445             *pslot = mapSource2ProducerSlot(source, sslot);
    446         }
    447     }
    448     return result;
    449 }
    450 
    451 status_t VirtualDisplaySurface::detachBuffer(int /* slot */) {
    452     VDS_LOGE("detachBuffer is not available for VirtualDisplaySurface");
    453     return INVALID_OPERATION;
    454 }
    455 
    456 status_t VirtualDisplaySurface::detachNextBuffer(
    457         sp<GraphicBuffer>* /* outBuffer */, sp<Fence>* /* outFence */) {
    458     VDS_LOGE("detachNextBuffer is not available for VirtualDisplaySurface");
    459     return INVALID_OPERATION;
    460 }
    461 
    462 status_t VirtualDisplaySurface::attachBuffer(int* /* outSlot */,
    463         const sp<GraphicBuffer>& /* buffer */) {
    464     VDS_LOGE("attachBuffer is not available for VirtualDisplaySurface");
    465     return INVALID_OPERATION;
    466 }
    467 
    468 status_t VirtualDisplaySurface::queueBuffer(int pslot,
    469         const QueueBufferInput& input, QueueBufferOutput* output) {
    470     if (mDisplayId < 0)
    471         return mSource[SOURCE_SINK]->queueBuffer(pslot, input, output);
    472 
    473     VDS_LOGW_IF(mDbgState != DBG_STATE_GLES,
    474             "Unexpected queueBuffer(pslot=%d) in %s state", pslot,
    475             dbgStateStr());
    476     mDbgState = DBG_STATE_GLES_DONE;
    477 
    478     VDS_LOGV("queueBuffer pslot=%d", pslot);
    479 
    480     status_t result;
    481     if (mCompositionType == COMPOSITION_MIXED) {
    482         // Queue the buffer back into the scratch pool
    483         QueueBufferOutput scratchQBO;
    484         int sslot = mapProducer2SourceSlot(SOURCE_SCRATCH, pslot);
    485         result = mSource[SOURCE_SCRATCH]->queueBuffer(sslot, input, &scratchQBO);
    486         if (result != NO_ERROR)
    487             return result;
    488 
    489         // Now acquire the buffer from the scratch pool -- should be the same
    490         // slot and fence as we just queued.
    491         Mutex::Autolock lock(mMutex);
    492         BufferItem item;
    493         result = acquireBufferLocked(&item, 0);
    494         if (result != NO_ERROR)
    495             return result;
    496         VDS_LOGW_IF(item.mSlot != sslot,
    497                 "queueBuffer: acquired sslot %d from SCRATCH after queueing sslot %d",
    498                 item.mSlot, sslot);
    499         mFbProducerSlot = mapSource2ProducerSlot(SOURCE_SCRATCH, item.mSlot);
    500         mFbFence = mSlots[item.mSlot].mFence;
    501 
    502     } else {
    503         LOG_FATAL_IF(mCompositionType != COMPOSITION_GLES,
    504                 "Unexpected queueBuffer in state %s for compositionType %s",
    505                 dbgStateStr(), dbgCompositionTypeStr(mCompositionType));
    506 
    507         // Extract the GLES release fence for HWC to acquire
    508         int64_t timestamp;
    509         bool isAutoTimestamp;
    510         android_dataspace dataSpace;
    511         Rect crop;
    512         int scalingMode;
    513         uint32_t transform;
    514         input.deflate(&timestamp, &isAutoTimestamp, &dataSpace, &crop,
    515                 &scalingMode, &transform, &mFbFence);
    516 
    517         mFbProducerSlot = pslot;
    518         mOutputFence = mFbFence;
    519     }
    520 
    521     *output = mQueueBufferOutput;
    522     return NO_ERROR;
    523 }
    524 
    525 status_t VirtualDisplaySurface::cancelBuffer(int pslot,
    526         const sp<Fence>& fence) {
    527     if (mDisplayId < 0)
    528         return mSource[SOURCE_SINK]->cancelBuffer(mapProducer2SourceSlot(SOURCE_SINK, pslot), fence);
    529 
    530     VDS_LOGW_IF(mDbgState != DBG_STATE_GLES,
    531             "Unexpected cancelBuffer(pslot=%d) in %s state", pslot,
    532             dbgStateStr());
    533     VDS_LOGV("cancelBuffer pslot=%d", pslot);
    534     Source source = fbSourceForCompositionType(mCompositionType);
    535     return mSource[source]->cancelBuffer(
    536             mapProducer2SourceSlot(source, pslot), fence);
    537 }
    538 
    539 int VirtualDisplaySurface::query(int what, int* value) {
    540     switch (what) {
    541         case NATIVE_WINDOW_WIDTH:
    542             *value = mSinkBufferWidth;
    543             break;
    544         case NATIVE_WINDOW_HEIGHT:
    545             *value = mSinkBufferHeight;
    546             break;
    547         default:
    548             return mSource[SOURCE_SINK]->query(what, value);
    549     }
    550     return NO_ERROR;
    551 }
    552 
    553 status_t VirtualDisplaySurface::connect(const sp<IProducerListener>& listener,
    554         int api, bool producerControlledByApp,
    555         QueueBufferOutput* output) {
    556     QueueBufferOutput qbo;
    557     status_t result = mSource[SOURCE_SINK]->connect(listener, api,
    558             producerControlledByApp, &qbo);
    559     if (result == NO_ERROR) {
    560         updateQueueBufferOutput(qbo);
    561         *output = mQueueBufferOutput;
    562     }
    563     return result;
    564 }
    565 
    566 status_t VirtualDisplaySurface::disconnect(int api) {
    567     return mSource[SOURCE_SINK]->disconnect(api);
    568 }
    569 
    570 status_t VirtualDisplaySurface::setSidebandStream(const sp<NativeHandle>& /*stream*/) {
    571     return INVALID_OPERATION;
    572 }
    573 
    574 void VirtualDisplaySurface::allocateBuffers(uint32_t /* width */,
    575         uint32_t /* height */, PixelFormat /* format */, uint32_t /* usage */) {
    576     // TODO: Should we actually allocate buffers for a virtual display?
    577 }
    578 
    579 status_t VirtualDisplaySurface::allowAllocation(bool /* allow */) {
    580     return INVALID_OPERATION;
    581 }
    582 
    583 status_t VirtualDisplaySurface::setGenerationNumber(uint32_t /* generation */) {
    584     ALOGE("setGenerationNumber not supported on VirtualDisplaySurface");
    585     return INVALID_OPERATION;
    586 }
    587 
    588 String8 VirtualDisplaySurface::getConsumerName() const {
    589     return String8("VirtualDisplaySurface");
    590 }
    591 
    592 status_t VirtualDisplaySurface::setSharedBufferMode(bool /*sharedBufferMode*/) {
    593     ALOGE("setSharedBufferMode not supported on VirtualDisplaySurface");
    594     return INVALID_OPERATION;
    595 }
    596 
    597 status_t VirtualDisplaySurface::setAutoRefresh(bool /*autoRefresh*/) {
    598     ALOGE("setAutoRefresh not supported on VirtualDisplaySurface");
    599     return INVALID_OPERATION;
    600 }
    601 
    602 status_t VirtualDisplaySurface::setDequeueTimeout(nsecs_t /* timeout */) {
    603     ALOGE("setDequeueTimeout not supported on VirtualDisplaySurface");
    604     return INVALID_OPERATION;
    605 }
    606 
    607 status_t VirtualDisplaySurface::getLastQueuedBuffer(
    608         sp<GraphicBuffer>* /*outBuffer*/, sp<Fence>* /*outFence*/,
    609         float[16] /* outTransformMatrix*/) {
    610     ALOGE("getLastQueuedBuffer not supported on VirtualDisplaySurface");
    611     return INVALID_OPERATION;
    612 }
    613 
    614 status_t VirtualDisplaySurface::getUniqueId(uint64_t* /*outId*/) const {
    615     ALOGE("getUniqueId not supported on VirtualDisplaySurface");
    616     return INVALID_OPERATION;
    617 }
    618 
    619 void VirtualDisplaySurface::updateQueueBufferOutput(
    620         const QueueBufferOutput& qbo) {
    621     uint32_t w, h, transformHint, numPendingBuffers;
    622     uint64_t nextFrameNumber;
    623     qbo.deflate(&w, &h, &transformHint, &numPendingBuffers, &nextFrameNumber);
    624     mQueueBufferOutput.inflate(w, h, 0, numPendingBuffers, nextFrameNumber);
    625 }
    626 
    627 void VirtualDisplaySurface::resetPerFrameState() {
    628     mCompositionType = COMPOSITION_UNKNOWN;
    629     mFbFence = Fence::NO_FENCE;
    630     mOutputFence = Fence::NO_FENCE;
    631     mOutputProducerSlot = -1;
    632     mFbProducerSlot = -1;
    633 }
    634 
    635 status_t VirtualDisplaySurface::refreshOutputBuffer() {
    636     if (mOutputProducerSlot >= 0) {
    637         mSource[SOURCE_SINK]->cancelBuffer(
    638                 mapProducer2SourceSlot(SOURCE_SINK, mOutputProducerSlot),
    639                 mOutputFence);
    640     }
    641 
    642     int sslot;
    643     status_t result = dequeueBuffer(SOURCE_SINK, mOutputFormat, mOutputUsage,
    644             &sslot, &mOutputFence);
    645     if (result < 0)
    646         return result;
    647     mOutputProducerSlot = mapSource2ProducerSlot(SOURCE_SINK, sslot);
    648 
    649     // On GLES-only frames, we don't have the right output buffer acquire fence
    650     // until after GLES calls queueBuffer(). So here we just set the buffer
    651     // (for use in HWC prepare) but not the fence; we'll call this again with
    652     // the proper fence once we have it.
    653     result = mHwc.setOutputBuffer(mDisplayId, Fence::NO_FENCE,
    654             mProducerBuffers[mOutputProducerSlot]);
    655 
    656     return result;
    657 }
    658 
    659 // This slot mapping function is its own inverse, so two copies are unnecessary.
    660 // Both are kept to make the intent clear where the function is called, and for
    661 // the (unlikely) chance that we switch to a different mapping function.
    662 int VirtualDisplaySurface::mapSource2ProducerSlot(Source source, int sslot) {
    663     if (source == SOURCE_SCRATCH) {
    664         return BufferQueue::NUM_BUFFER_SLOTS - sslot - 1;
    665     } else {
    666         return sslot;
    667     }
    668 }
    669 int VirtualDisplaySurface::mapProducer2SourceSlot(Source source, int pslot) {
    670     return mapSource2ProducerSlot(source, pslot);
    671 }
    672 
    673 VirtualDisplaySurface::Source
    674 VirtualDisplaySurface::fbSourceForCompositionType(CompositionType type) {
    675     return type == COMPOSITION_MIXED ? SOURCE_SCRATCH : SOURCE_SINK;
    676 }
    677 
    678 const char* VirtualDisplaySurface::dbgStateStr() const {
    679     switch (mDbgState) {
    680         case DBG_STATE_IDLE:      return "IDLE";
    681         case DBG_STATE_PREPARED:  return "PREPARED";
    682         case DBG_STATE_GLES:      return "GLES";
    683         case DBG_STATE_GLES_DONE: return "GLES_DONE";
    684         case DBG_STATE_HWC:       return "HWC";
    685         default:                  return "INVALID";
    686     }
    687 }
    688 
    689 const char* VirtualDisplaySurface::dbgSourceStr(Source s) {
    690     switch (s) {
    691         case SOURCE_SINK:    return "SINK";
    692         case SOURCE_SCRATCH: return "SCRATCH";
    693         default:             return "INVALID";
    694     }
    695 }
    696 
    697 // ---------------------------------------------------------------------------
    698 } // namespace android
    699 // ---------------------------------------------------------------------------
    700