SurfaceFlinger: Remove BufferQueueLayer
Fixes: 200285148
Test: builds
Change-Id: I218bfb8110b5aef7a292e805e8508a278b07b684
diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp
index 000a2cb..1ddf2de 100644
--- a/services/surfaceflinger/Android.bp
+++ b/services/surfaceflinger/Android.bp
@@ -143,7 +143,6 @@
"BackgroundExecutor.cpp",
"BufferLayer.cpp",
"BufferLayerConsumer.cpp",
- "BufferQueueLayer.cpp",
"BufferStateLayer.cpp",
"ClientCache.cpp",
"Client.cpp",
diff --git a/services/surfaceflinger/BufferQueueLayer.cpp b/services/surfaceflinger/BufferQueueLayer.cpp
deleted file mode 100644
index bee4de3..0000000
--- a/services/surfaceflinger/BufferQueueLayer.cpp
+++ /dev/null
@@ -1,575 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wconversion"
-
-#undef LOG_TAG
-#define LOG_TAG "BufferQueueLayer"
-#define ATRACE_TAG ATRACE_TAG_GRAPHICS
-#include "BufferQueueLayer.h"
-
-#include <compositionengine/LayerFECompositionState.h>
-#include <gui/BufferQueueConsumer.h>
-#include <system/window.h>
-
-#include "LayerRejecter.h"
-#include "SurfaceInterceptor.h"
-
-#include "FrameTracer/FrameTracer.h"
-#include "Scheduler/LayerHistory.h"
-#include "TimeStats/TimeStats.h"
-
-namespace android {
-using PresentState = frametimeline::SurfaceFrame::PresentState;
-
-BufferQueueLayer::BufferQueueLayer(const LayerCreationArgs& args) : BufferLayer(args) {}
-
-BufferQueueLayer::~BufferQueueLayer() {
- mContentsChangedListener->abandon();
- mConsumer->abandon();
-}
-
-// -----------------------------------------------------------------------
-// Interface implementation for Layer
-// -----------------------------------------------------------------------
-
-void BufferQueueLayer::onLayerDisplayed(ftl::SharedFuture<FenceResult> futureFenceResult) {
- const sp<Fence> releaseFence = futureFenceResult.get().value_or(Fence::NO_FENCE);
- mConsumer->setReleaseFence(releaseFence);
-
- // Prevent tracing the same release multiple times.
- if (mPreviousFrameNumber != mPreviousReleasedFrameNumber) {
- mFlinger->mFrameTracer->traceFence(getSequence(), mPreviousBufferId, mPreviousFrameNumber,
- std::make_shared<FenceTime>(releaseFence),
- FrameTracer::FrameEvent::RELEASE_FENCE);
- mPreviousReleasedFrameNumber = mPreviousFrameNumber;
- }
-}
-
-void BufferQueueLayer::setTransformHint(ui::Transform::RotationFlags displayTransformHint) {
- BufferLayer::setTransformHint(displayTransformHint);
- mConsumer->setTransformHint(mTransformHint);
-}
-
-void BufferQueueLayer::releasePendingBuffer(nsecs_t) {
- if (!mConsumer->releasePendingBuffer()) {
- return;
- }
-}
-
-void BufferQueueLayer::setDefaultBufferSize(uint32_t w, uint32_t h) {
- mConsumer->setDefaultBufferSize(w, h);
-}
-
-int32_t BufferQueueLayer::getQueuedFrameCount() const {
- return mQueuedFrames;
-}
-
-bool BufferQueueLayer::isBufferDue(nsecs_t expectedPresentTime) const {
- Mutex::Autolock lock(mQueueItemLock);
-
- const int64_t addedTime = mQueueItems[0].item.mTimestamp;
-
- // Ignore timestamps more than a second in the future
- const bool isPlausible = addedTime < (expectedPresentTime + s2ns(1));
- ALOGW_IF(!isPlausible,
- "[%s] Timestamp %" PRId64 " seems implausible "
- "relative to expectedPresent %" PRId64,
- getDebugName(), addedTime, expectedPresentTime);
-
- if (!isPlausible) {
- mFlinger->mTimeStats->incrementBadDesiredPresent(getSequence());
- }
-
- const bool isDue = addedTime < expectedPresentTime;
- return isDue || !isPlausible;
-}
-
-// -----------------------------------------------------------------------
-// Interface implementation for BufferLayer
-// -----------------------------------------------------------------------
-
-bool BufferQueueLayer::fenceHasSignaled() const {
- Mutex::Autolock lock(mQueueItemLock);
-
- if (SurfaceFlinger::enableLatchUnsignaledConfig != LatchUnsignaledConfig::Disabled) {
- return true;
- }
-
- if (!hasFrameUpdate()) {
- return true;
- }
-
- if (mQueueItems[0].item.mIsDroppable) {
- // Even though this buffer's fence may not have signaled yet, it could
- // be replaced by another buffer before it has a chance to, which means
- // that it's possible to get into a situation where a buffer is never
- // able to be latched. To avoid this, grab this buffer anyway.
- return true;
- }
- const bool fenceSignaled =
- mQueueItems[0].item.mFenceTime->getSignalTime() != Fence::SIGNAL_TIME_PENDING;
- if (!fenceSignaled) {
- mFlinger->mTimeStats->incrementLatchSkipped(getSequence(),
- TimeStats::LatchSkipReason::LateAcquire);
- }
-
- return fenceSignaled;
-}
-
-bool BufferQueueLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const {
- Mutex::Autolock lock(mQueueItemLock);
-
- if (!hasFrameUpdate() || isRemovedFromCurrentState()) {
- return true;
- }
-
- return mQueueItems[0].item.mTimestamp <= expectedPresentTime;
-}
-
-bool BufferQueueLayer::latchSidebandStream(bool& recomputeVisibleRegions) {
- // We need to update the sideband stream if the layer has both a buffer and a sideband stream.
- editCompositionState()->sidebandStreamHasFrame = hasFrameUpdate() && mSidebandStream.get();
-
- bool sidebandStreamChanged = true;
- if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, false)) {
- // mSidebandStreamChanged was changed to false
- mSidebandStream = mConsumer->getSidebandStream();
- auto* layerCompositionState = editCompositionState();
- layerCompositionState->sidebandStream = mSidebandStream;
- if (layerCompositionState->sidebandStream != nullptr) {
- setTransactionFlags(eTransactionNeeded);
- mFlinger->setTransactionFlags(eTraversalNeeded);
- }
- recomputeVisibleRegions = true;
-
- return true;
- }
- return false;
-}
-
-bool BufferQueueLayer::hasFrameUpdate() const {
- return mQueuedFrames > 0;
-}
-
-status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
- nsecs_t expectedPresentTime) {
- // This boolean is used to make sure that SurfaceFlinger's shadow copy
- // of the buffer queue isn't modified when the buffer queue is returning
- // BufferItem's that weren't actually queued. This can happen in shared
- // buffer mode.
- bool queuedBuffer = false;
- const int32_t layerId = getSequence();
- LayerRejecter r(mDrawingState, getDrawingState(), recomputeVisibleRegions,
- getProducerStickyTransform() != 0, mName,
- getTransformToDisplayInverse());
-
- if (isRemovedFromCurrentState()) {
- expectedPresentTime = 0;
- }
-
- // updateTexImage() below might drop the some buffers at the head of the queue if there is a
- // buffer behind them which is timely to be presented. However this buffer may not be signaled
- // yet. The code below makes sure that this wouldn't happen by setting maxFrameNumber to the
- // last buffer that was signaled.
- uint64_t lastSignaledFrameNumber = mLastFrameNumberReceived;
- {
- Mutex::Autolock lock(mQueueItemLock);
- for (size_t i = 0; i < mQueueItems.size(); i++) {
- bool fenceSignaled =
- mQueueItems[i].item.mFenceTime->getSignalTime() != Fence::SIGNAL_TIME_PENDING;
- if (!fenceSignaled) {
- break;
- }
- lastSignaledFrameNumber = mQueueItems[i].item.mFrameNumber;
- }
- }
- const uint64_t maxFrameNumberToAcquire =
- std::min(mLastFrameNumberReceived.load(), lastSignaledFrameNumber);
-
- bool autoRefresh;
- status_t updateResult = mConsumer->updateTexImage(&r, expectedPresentTime, &autoRefresh,
- &queuedBuffer, maxFrameNumberToAcquire);
- mDrawingState.autoRefresh = autoRefresh;
- if (updateResult == BufferQueue::PRESENT_LATER) {
- // Producer doesn't want buffer to be displayed yet. Signal a
- // layer update so we check again at the next opportunity.
- mFlinger->onLayerUpdate();
- return BAD_VALUE;
- } else if (updateResult == BufferLayerConsumer::BUFFER_REJECTED) {
- // If the buffer has been rejected, remove it from the shadow queue
- // and return early
- if (queuedBuffer) {
- Mutex::Autolock lock(mQueueItemLock);
- if (mQueuedFrames > 0) {
- mConsumer->mergeSurfaceDamage(mQueueItems[0].item.mSurfaceDamage);
- mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].item.mFrameNumber);
- if (mQueueItems[0].surfaceFrame) {
- addSurfaceFrameDroppedForBuffer(mQueueItems[0].surfaceFrame);
- }
- mQueueItems.erase(mQueueItems.begin());
- mQueuedFrames--;
- }
- }
- return BAD_VALUE;
- } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) {
- // This can occur if something goes wrong when trying to create the
- // EGLImage for this buffer. If this happens, the buffer has already
- // been released, so we need to clean up the queue and bug out
- // early.
- if (queuedBuffer) {
- Mutex::Autolock lock(mQueueItemLock);
- for (auto& [item, surfaceFrame] : mQueueItems) {
- if (surfaceFrame) {
- addSurfaceFrameDroppedForBuffer(surfaceFrame);
- }
- }
- mQueueItems.clear();
- mQueuedFrames = 0;
- mFlinger->mTimeStats->onDestroy(layerId);
- mFlinger->mFrameTracer->onDestroy(layerId);
- }
-
- // Once we have hit this state, the shadow queue may no longer
- // correctly reflect the incoming BufferQueue's contents, so even if
- // updateTexImage starts working, the only safe course of action is
- // to continue to ignore updates.
- mUpdateTexImageFailed = true;
-
- return BAD_VALUE;
- }
-
- bool more_frames_pending = false;
- if (queuedBuffer) {
- // Autolock scope
- auto currentFrameNumber = mConsumer->getFrameNumber();
-
- Mutex::Autolock lock(mQueueItemLock);
-
- // Remove any stale buffers that have been dropped during
- // updateTexImage
- while (mQueuedFrames > 0 && mQueueItems[0].item.mFrameNumber != currentFrameNumber) {
- mConsumer->mergeSurfaceDamage(mQueueItems[0].item.mSurfaceDamage);
- mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].item.mFrameNumber);
- if (mQueueItems[0].surfaceFrame) {
- addSurfaceFrameDroppedForBuffer(mQueueItems[0].surfaceFrame);
- }
- mQueueItems.erase(mQueueItems.begin());
- mQueuedFrames--;
- }
-
- uint64_t bufferID = mQueueItems[0].item.mGraphicBuffer->getId();
- mFlinger->mTimeStats->setLatchTime(layerId, currentFrameNumber, latchTime);
- mFlinger->mFrameTracer->traceTimestamp(layerId, bufferID, currentFrameNumber, latchTime,
- FrameTracer::FrameEvent::LATCH);
-
- if (mQueueItems[0].surfaceFrame) {
- addSurfaceFramePresentedForBuffer(mQueueItems[0].surfaceFrame,
- mQueueItems[0].item.mFenceTime->getSignalTime(),
- latchTime);
- }
- mQueueItems.erase(mQueueItems.begin());
- more_frames_pending = (mQueuedFrames.fetch_sub(1) > 1);
- }
-
- // Decrement the queued-frames count. Signal another event if we
- // have more frames pending.
- if ((queuedBuffer && more_frames_pending) || mDrawingState.autoRefresh) {
- mFlinger->onLayerUpdate();
- }
-
- return NO_ERROR;
-}
-
-status_t BufferQueueLayer::updateActiveBuffer() {
- // update the active buffer
- mPreviousBufferId = getCurrentBufferId();
- mBufferInfo.mBuffer =
- mConsumer->getCurrentBuffer(&mBufferInfo.mBufferSlot, &mBufferInfo.mFence);
-
- if (mBufferInfo.mBuffer == nullptr) {
- // this can only happen if the very first buffer was rejected.
- return BAD_VALUE;
- }
- return NO_ERROR;
-}
-
-status_t BufferQueueLayer::updateFrameNumber() {
- mPreviousFrameNumber = mCurrentFrameNumber;
- mCurrentFrameNumber = mConsumer->getFrameNumber();
- return NO_ERROR;
-}
-
-void BufferQueueLayer::setFrameTimelineInfoForBuffer(const FrameTimelineInfo& frameTimelineInfo) {
- mFrameTimelineInfo = frameTimelineInfo;
-}
-
-// -----------------------------------------------------------------------
-// Interface implementation for BufferLayerConsumer::ContentsChangedListener
-// -----------------------------------------------------------------------
-
-void BufferQueueLayer::onFrameDequeued(const uint64_t bufferId) {
- const int32_t layerId = getSequence();
- mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());
- mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,
- systemTime(), FrameTracer::FrameEvent::DEQUEUE);
-}
-
-void BufferQueueLayer::onFrameDetached(const uint64_t bufferId) {
- const int32_t layerId = getSequence();
- mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());
- mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,
- systemTime(), FrameTracer::FrameEvent::DETACH);
-}
-
-void BufferQueueLayer::onFrameCancelled(const uint64_t bufferId) {
- const int32_t layerId = getSequence();
- mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,
- systemTime(), FrameTracer::FrameEvent::CANCEL);
-}
-
-void BufferQueueLayer::onFrameAvailable(const BufferItem& item) {
- const int32_t layerId = getSequence();
- const uint64_t bufferId = item.mGraphicBuffer->getId();
- mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, item.mFrameNumber, systemTime(),
- FrameTracer::FrameEvent::QUEUE);
- mFlinger->mFrameTracer->traceFence(layerId, bufferId, item.mFrameNumber,
- std::make_shared<FenceTime>(item.mFence),
- FrameTracer::FrameEvent::ACQUIRE_FENCE);
-
- ATRACE_CALL();
- // Add this buffer from our internal queue tracker
- { // Autolock scope
- const nsecs_t presentTime = item.mIsAutoTimestamp ? 0 : item.mTimestamp;
-
- using LayerUpdateType = scheduler::LayerHistory::LayerUpdateType;
- mFlinger->mScheduler->recordLayerHistory(this, presentTime, LayerUpdateType::Buffer);
-
- Mutex::Autolock lock(mQueueItemLock);
- // Reset the frame number tracker when we receive the first buffer after
- // a frame number reset
- if (item.mFrameNumber == 1) {
- mLastFrameNumberReceived = 0;
- }
-
- // Ensure that callbacks are handled in order
- while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
- status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500));
- if (result != NO_ERROR) {
- ALOGE("[%s] Timed out waiting on callback", getDebugName());
- break;
- }
- }
-
- auto surfaceFrame = createSurfaceFrameForBuffer(mFrameTimelineInfo, systemTime(), mName);
-
- mQueueItems.push_back({item, surfaceFrame});
- mQueuedFrames++;
-
- // Wake up any pending callbacks
- mLastFrameNumberReceived = item.mFrameNumber;
- mQueueItemCondition.broadcast();
- }
-
- mFlinger->mInterceptor->saveBufferUpdate(layerId, item.mGraphicBuffer->getWidth(),
- item.mGraphicBuffer->getHeight(), item.mFrameNumber);
-
- mFlinger->onLayerUpdate();
- mConsumer->onBufferAvailable(item);
-}
-
-void BufferQueueLayer::onFrameReplaced(const BufferItem& item) {
- ATRACE_CALL();
- { // Autolock scope
- Mutex::Autolock lock(mQueueItemLock);
-
- // Ensure that callbacks are handled in order
- while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
- status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500));
- if (result != NO_ERROR) {
- ALOGE("[%s] Timed out waiting on callback", getDebugName());
- break;
- }
- }
-
- if (!hasFrameUpdate()) {
- ALOGE("Can't replace a frame on an empty queue");
- return;
- }
-
- auto surfaceFrame = createSurfaceFrameForBuffer(mFrameTimelineInfo, systemTime(), mName);
- mQueueItems[mQueueItems.size() - 1].item = item;
- mQueueItems[mQueueItems.size() - 1].surfaceFrame = std::move(surfaceFrame);
-
- // Wake up any pending callbacks
- mLastFrameNumberReceived = item.mFrameNumber;
- mQueueItemCondition.broadcast();
- }
-
- const int32_t layerId = getSequence();
- const uint64_t bufferId = item.mGraphicBuffer->getId();
- mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, item.mFrameNumber, systemTime(),
- FrameTracer::FrameEvent::QUEUE);
- mFlinger->mFrameTracer->traceFence(layerId, bufferId, item.mFrameNumber,
- std::make_shared<FenceTime>(item.mFence),
- FrameTracer::FrameEvent::ACQUIRE_FENCE);
- mConsumer->onBufferAvailable(item);
-}
-
-void BufferQueueLayer::onSidebandStreamChanged() {
- bool sidebandStreamChanged = false;
- if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, true)) {
- // mSidebandStreamChanged was changed to true
- mFlinger->onLayerUpdate();
- }
-}
-
-// -----------------------------------------------------------------------
-
-void BufferQueueLayer::onFirstRef() {
- BufferLayer::onFirstRef();
-
- // Creates a custom BufferQueue for SurfaceFlingerConsumer to use
- sp<IGraphicBufferProducer> producer;
- sp<IGraphicBufferConsumer> consumer;
- mFlinger->getFactory().createBufferQueue(&producer, &consumer, true);
- mProducer = mFlinger->getFactory().createMonitoredProducer(producer, mFlinger, this);
- mConsumer =
- mFlinger->getFactory().createBufferLayerConsumer(consumer, mFlinger->getRenderEngine(),
- mTextureName, this);
- mConsumer->setConsumerUsageBits(getEffectiveUsage(0));
-
- mContentsChangedListener = new ContentsChangedListener(this);
- mConsumer->setContentsChangedListener(mContentsChangedListener);
- mConsumer->setName(String8(mName.data(), mName.size()));
-
- mProducer->setMaxDequeuedBufferCount(2);
-}
-
-status_t BufferQueueLayer::setDefaultBufferProperties(uint32_t w, uint32_t h, PixelFormat format) {
- // never allow a surface larger than what our underlying GL implementation
- // can handle.
- if (mFlinger->exceedsMaxRenderTargetSize(w, h)) {
- ALOGE("dimensions too large %" PRIu32 " x %" PRIu32, w, h);
- return BAD_VALUE;
- }
-
- setDefaultBufferSize(w, h);
- mConsumer->setDefaultBufferFormat(format);
- mConsumer->setConsumerUsageBits(getEffectiveUsage(0));
-
- return NO_ERROR;
-}
-
-sp<IGraphicBufferProducer> BufferQueueLayer::getProducer() const {
- return mProducer;
-}
-
-uint32_t BufferQueueLayer::getProducerStickyTransform() const {
- int producerStickyTransform = 0;
- int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform);
- if (ret != OK) {
- ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__,
- strerror(-ret), ret);
- return 0;
- }
- return static_cast<uint32_t>(producerStickyTransform);
-}
-
-void BufferQueueLayer::gatherBufferInfo() {
- BufferLayer::gatherBufferInfo();
-
- mBufferInfo.mDesiredPresentTime = mConsumer->getTimestamp();
- mBufferInfo.mFenceTime = mConsumer->getCurrentFenceTime();
- mBufferInfo.mFence = mConsumer->getCurrentFence();
- mBufferInfo.mTransform = mConsumer->getCurrentTransform();
- mBufferInfo.mDataspace = translateDataspace(mConsumer->getCurrentDataSpace());
- mBufferInfo.mCrop = mConsumer->getCurrentCrop();
- mBufferInfo.mScaleMode = mConsumer->getCurrentScalingMode();
- mBufferInfo.mSurfaceDamage = mConsumer->getSurfaceDamage();
- mBufferInfo.mHdrMetadata = mConsumer->getCurrentHdrMetadata();
- mBufferInfo.mApi = mConsumer->getCurrentApi();
- mBufferInfo.mTransformToDisplayInverse = mConsumer->getTransformToDisplayInverse();
-}
-
-sp<Layer> BufferQueueLayer::createClone() {
- LayerCreationArgs args(mFlinger.get(), nullptr, mName + " (Mirror)", 0, LayerMetadata());
- args.textureName = mTextureName;
- sp<BufferQueueLayer> layer = mFlinger->getFactory().createBufferQueueLayer(args);
- layer->setInitialValuesForClone(this);
-
- return layer;
-}
-
-// -----------------------------------------------------------------------
-// Interface implementation for BufferLayerConsumer::ContentsChangedListener
-// -----------------------------------------------------------------------
-
-void BufferQueueLayer::ContentsChangedListener::onFrameAvailable(const BufferItem& item) {
- Mutex::Autolock lock(mMutex);
- if (mBufferQueueLayer != nullptr) {
- mBufferQueueLayer->onFrameAvailable(item);
- }
-}
-
-void BufferQueueLayer::ContentsChangedListener::onFrameReplaced(const BufferItem& item) {
- Mutex::Autolock lock(mMutex);
- if (mBufferQueueLayer != nullptr) {
- mBufferQueueLayer->onFrameReplaced(item);
- }
-}
-
-void BufferQueueLayer::ContentsChangedListener::onSidebandStreamChanged() {
- Mutex::Autolock lock(mMutex);
- if (mBufferQueueLayer != nullptr) {
- mBufferQueueLayer->onSidebandStreamChanged();
- }
-}
-
-void BufferQueueLayer::ContentsChangedListener::onFrameDequeued(const uint64_t bufferId) {
- Mutex::Autolock lock(mMutex);
- if (mBufferQueueLayer != nullptr) {
- mBufferQueueLayer->onFrameDequeued(bufferId);
- }
-}
-
-void BufferQueueLayer::ContentsChangedListener::onFrameDetached(const uint64_t bufferId) {
- Mutex::Autolock lock(mMutex);
- if (mBufferQueueLayer != nullptr) {
- mBufferQueueLayer->onFrameDetached(bufferId);
- }
-}
-
-void BufferQueueLayer::ContentsChangedListener::onFrameCancelled(const uint64_t bufferId) {
- Mutex::Autolock lock(mMutex);
- if (mBufferQueueLayer != nullptr) {
- mBufferQueueLayer->onFrameCancelled(bufferId);
- }
-}
-
-void BufferQueueLayer::ContentsChangedListener::abandon() {
- Mutex::Autolock lock(mMutex);
- mBufferQueueLayer = nullptr;
-}
-
-// -----------------------------------------------------------------------
-
-} // namespace android
-
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wconversion"
diff --git a/services/surfaceflinger/BufferQueueLayer.h b/services/surfaceflinger/BufferQueueLayer.h
deleted file mode 100644
index f7a4fd2..0000000
--- a/services/surfaceflinger/BufferQueueLayer.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "BufferLayer.h"
-
-#include <utils/String8.h>
-
-namespace android {
-
-namespace frametimeline {
-class SurfaceFrame;
-}
-
-/*
- * A new BufferQueue and a new BufferLayerConsumer are created when the
- * BufferLayer is first referenced.
- *
- * This also implements onFrameAvailable(), which notifies SurfaceFlinger
- * that new data has arrived.
- */
-class BufferQueueLayer : public BufferLayer {
-public:
- ~BufferQueueLayer() override;
-
- // Implements Layer.
- const char* getType() const override { return "BufferQueueLayer"; }
-
- void onLayerDisplayed(ftl::SharedFuture<FenceResult>) override;
-
- // If a buffer was replaced this frame, release the former buffer
- void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
-
- void setDefaultBufferSize(uint32_t w, uint32_t h) override;
-
- int32_t getQueuedFrameCount() const override;
-
- // Returns true if the next buffer should be presented at the expected present time
- bool isBufferDue(nsecs_t expectedPresentTime) const override;
-
- // Implements BufferLayer.
- bool fenceHasSignaled() const override;
- bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
-
- status_t setDefaultBufferProperties(uint32_t w, uint32_t h, PixelFormat format);
- sp<IGraphicBufferProducer> getProducer() const;
-
- void setSizeForTest(uint32_t w, uint32_t h) {
- mDrawingState.active_legacy.w = w;
- mDrawingState.active_legacy.h = h;
- }
-
-protected:
- void gatherBufferInfo() override;
-
- // -----------------------------------------------------------------------
- // Interface implementation for BufferLayerConsumer::ContentsChangedListener
- // -----------------------------------------------------------------------
- class ContentsChangedListener : public BufferLayerConsumer::ContentsChangedListener {
- public:
- ContentsChangedListener(BufferQueueLayer* bufferQueueLayer)
- : mBufferQueueLayer(bufferQueueLayer) {}
- void abandon();
-
- protected:
- void onFrameAvailable(const BufferItem& item) override;
- void onFrameReplaced(const BufferItem& item) override;
- void onSidebandStreamChanged() override;
- void onFrameDequeued(const uint64_t bufferId) override;
- void onFrameDetached(const uint64_t bufferId) override;
- void onFrameCancelled(const uint64_t bufferId) override;
-
- private:
- BufferQueueLayer* mBufferQueueLayer = nullptr;
- Mutex mMutex;
- };
-
-private:
- // Goodbye
- explicit BufferQueueLayer(const LayerCreationArgs&);
-
- bool latchSidebandStream(bool& recomputeVisibleRegions) override;
- void setTransformHint(ui::Transform::RotationFlags displayTransformHint) override;
-
- bool hasFrameUpdate() const override;
-
- status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
- nsecs_t expectedPresentTime) override;
-
- status_t updateActiveBuffer() override;
- status_t updateFrameNumber() override;
- void setFrameTimelineInfoForBuffer(const FrameTimelineInfo& frameTimelineInfo) override;
-
- sp<Layer> createClone() override;
-
- void onFirstRef() override;
-
- void onFrameAvailable(const BufferItem& item);
- void onFrameReplaced(const BufferItem& item);
- void onSidebandStreamChanged();
- void onFrameDequeued(const uint64_t bufferId);
- void onFrameDetached(const uint64_t bufferId);
- void onFrameCancelled(const uint64_t bufferId);
-
- // Temporary - Used only for LEGACY camera mode.
- uint32_t getProducerStickyTransform() const;
-
- sp<BufferLayerConsumer> mConsumer;
- sp<IGraphicBufferProducer> mProducer;
-
- bool mUpdateTexImageFailed{false};
-
- uint64_t mPreviousBufferId = 0;
- uint64_t mPreviousReleasedFrameNumber = 0;
-
- // Local copy of the queued contents of the incoming BufferQueue
- mutable Mutex mQueueItemLock;
- Condition mQueueItemCondition;
-
- struct BufferData {
- BufferData(BufferItem item, std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame)
- : item(item), surfaceFrame(surfaceFrame) {}
- BufferItem item;
- std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame;
- };
- std::vector<BufferData> mQueueItems;
- std::atomic<uint64_t> mLastFrameNumberReceived{0};
-
- // thread-safe
- std::atomic<int32_t> mQueuedFrames{0};
-
- sp<ContentsChangedListener> mContentsChangedListener;
-
- // The last vsync info received on this layer. This will be used when we get
- // a buffer to correlate the buffer with the vsync id. Can only be accessed
- // with the SF state lock held.
- FrameTimelineInfo mFrameTimelineInfo;
-};
-
-} // namespace android
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index a7438f2..9f4f0a2 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -106,7 +106,6 @@
#include <ui/DisplayIdentification.h>
#include "BackgroundExecutor.h"
#include "BufferLayer.h"
-#include "BufferQueueLayer.h"
#include "BufferStateLayer.h"
#include "Client.h"
#include "Colorizer.h"
@@ -4758,42 +4757,6 @@
return result;
}
-status_t SurfaceFlinger::createBufferQueueLayer(LayerCreationArgs& args, PixelFormat& format,
- sp<IBinder>* handle,
- sp<IGraphicBufferProducer>* gbp,
- sp<Layer>* outLayer) {
- // initialize the surfaces
- switch (format) {
- case PIXEL_FORMAT_TRANSPARENT:
- case PIXEL_FORMAT_TRANSLUCENT:
- format = PIXEL_FORMAT_RGBA_8888;
- break;
- case PIXEL_FORMAT_OPAQUE:
- format = PIXEL_FORMAT_RGBX_8888;
- break;
- }
-
- sp<BufferQueueLayer> layer;
- args.textureName = getNewTexture();
- {
- // Grab the SF state lock during this since it's the only safe way to access
- // RenderEngine when creating a BufferLayerConsumer
- // TODO: Check if this lock is still needed here
- Mutex::Autolock lock(mStateLock);
- layer = getFactory().createBufferQueueLayer(args);
- }
-
- status_t err = layer->setDefaultBufferProperties(0, 0, format);
- if (err == NO_ERROR) {
- *handle = layer->getHandle();
- *gbp = layer->getProducer();
- *outLayer = layer;
- }
-
- ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
- return err;
-}
-
status_t SurfaceFlinger::createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* handle,
sp<Layer>* outLayer) {
args.textureName = getNewTexture();
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 6c7ed00..5182ed8 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -373,7 +373,6 @@
private:
friend class BufferLayer;
- friend class BufferQueueLayer;
friend class BufferStateLayer;
friend class Client;
friend class FpsReporter;
@@ -823,10 +822,6 @@
const sp<Layer>& parentLayer = nullptr,
uint32_t* outTransformHint = nullptr);
- status_t createBufferQueueLayer(LayerCreationArgs& args, PixelFormat& format,
- sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
- sp<Layer>* outLayer);
-
status_t createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
sp<Layer>* outLayer);
diff --git a/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp b/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
index cf97643..39a5d0f 100644
--- a/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
+++ b/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
@@ -23,7 +23,6 @@
#include <ui/GraphicBuffer.h>
#include "BufferLayerConsumer.h"
-#include "BufferQueueLayer.h"
#include "BufferStateLayer.h"
#include "ContainerLayer.h"
#include "DisplayDevice.h"
@@ -109,10 +108,6 @@
return new ContainerLayer(args);
}
-sp<BufferQueueLayer> DefaultFactory::createBufferQueueLayer(const LayerCreationArgs&) {
- return nullptr;
-}
-
sp<BufferStateLayer> DefaultFactory::createBufferStateLayer(const LayerCreationArgs& args) {
return new BufferStateLayer(args);
}
diff --git a/services/surfaceflinger/SurfaceFlingerDefaultFactory.h b/services/surfaceflinger/SurfaceFlingerDefaultFactory.h
index 501629d..173ca81 100644
--- a/services/surfaceflinger/SurfaceFlingerDefaultFactory.h
+++ b/services/surfaceflinger/SurfaceFlingerDefaultFactory.h
@@ -47,7 +47,6 @@
std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
const sp<IGraphicBufferProducer>&) override;
std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override;
- sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs& args) override;
sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs& args) override;
sp<EffectLayer> createEffectLayer(const LayerCreationArgs& args) override;
sp<ContainerLayer> createContainerLayer(const LayerCreationArgs& args) override;
diff --git a/services/surfaceflinger/SurfaceFlingerFactory.h b/services/surfaceflinger/SurfaceFlingerFactory.h
index 6153e8e..e117e96 100644
--- a/services/surfaceflinger/SurfaceFlingerFactory.h
+++ b/services/surfaceflinger/SurfaceFlingerFactory.h
@@ -30,7 +30,6 @@
typedef int32_t PixelFormat;
-class BufferQueueLayer;
class BufferLayerConsumer;
class BufferStateLayer;
class ContainerLayer;
@@ -98,7 +97,6 @@
virtual std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() = 0;
- virtual sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs& args) = 0;
virtual sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs& args) = 0;
virtual sp<EffectLayer> createEffectLayer(const LayerCreationArgs& args) = 0;
virtual sp<ContainerLayer> createContainerLayer(const LayerCreationArgs& args) = 0;
diff --git a/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp b/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp
index e85b0bf..5e20b74 100644
--- a/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp
+++ b/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp
@@ -105,10 +105,6 @@
return new EffectLayer(args);
}
- sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs&) override {
- return nullptr;
- }
-
std::unique_ptr<FrameTracer> createFrameTracer() override {
return std::make_unique<testing::NiceMock<mock::FrameTracer>>();
}
diff --git a/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h b/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h
index 10a6b1f..456a498 100644
--- a/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h
+++ b/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h
@@ -30,7 +30,6 @@
#include <ui/DisplayStatInfo.h>
#include <ui/DynamicDisplayInfo.h>
-#include "BufferQueueLayer.h"
#include "BufferStateLayer.h"
#include "ContainerLayer.h"
#include "DisplayDevice.h"
@@ -356,10 +355,6 @@
return compositionengine::impl::createCompositionEngine();
}
- sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs &) override {
- return nullptr;
- }
-
sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs &) override {
return nullptr;
}
diff --git a/services/surfaceflinger/tests/unittests/FpsReporterTest.cpp b/services/surfaceflinger/tests/unittests/FpsReporterTest.cpp
index 9cac7c1..3a9b805 100644
--- a/services/surfaceflinger/tests/unittests/FpsReporterTest.cpp
+++ b/services/surfaceflinger/tests/unittests/FpsReporterTest.cpp
@@ -24,7 +24,6 @@
#include <gtest/gtest.h>
#include <gui/LayerMetadata.h>
-#include "BufferQueueLayer.h"
#include "BufferStateLayer.h"
#include "EffectLayer.h"
#include "FpsReporter.h"
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index a4164c0..3a05e2f 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -29,7 +29,6 @@
#include <compositionengine/mock/DisplaySurface.h>
#include <gui/ScreenCaptureResults.h>
-#include "BufferQueueLayer.h"
#include "BufferStateLayer.h"
#include "ContainerLayer.h"
#include "DisplayDevice.h"
@@ -134,10 +133,6 @@
return compositionengine::impl::createCompositionEngine();
}
- sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs&) override {
- return nullptr;
- }
-
sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
return nullptr;
}