Created bufferInfo to track buffer data in a single place (1/2)
This is in preparation for layer mirroring since mirrored buffer layers
should just copy the bufferInfo instead of the entire BufferQueue or
parts of BufferState
Test: go/wm-smoke
Change-Id: Iba1be05c4b038f0b678150deed8e673bf1e7710b
diff --git a/services/surfaceflinger/BufferLayer.cpp b/services/surfaceflinger/BufferLayer.cpp
index 90a02b3..bca15e6 100644
--- a/services/surfaceflinger/BufferLayer.cpp
+++ b/services/surfaceflinger/BufferLayer.cpp
@@ -81,7 +81,7 @@
if (mFlinger->mForceFullDamage) {
surfaceDamageRegion = Region::INVALID_REGION;
} else {
- surfaceDamageRegion = getDrawingSurfaceDamage();
+ surfaceDamageRegion = mBufferInfo.mSurfaceDamage;
}
}
@@ -187,7 +187,7 @@
// Query the texture matrix given our current filtering mode.
float textureMatrix[16];
setFilteringEnabled(useFiltering);
- getDrawingTransformMatrix(textureMatrix);
+ memcpy(textureMatrix, mBufferInfo.mTransformMatrix, sizeof(mBufferInfo.mTransformMatrix));
if (getTransformToDisplayInverse()) {
/*
@@ -254,8 +254,8 @@
bool BufferLayer::isHdrY410() const {
// pixel format is HDR Y410 masquerading as RGBA_1010102
- return (mCurrentDataSpace == ui::Dataspace::BT2020_ITU_PQ &&
- getDrawingApi() == NATIVE_WINDOW_API_MEDIA &&
+ return (mBufferInfo.mDataspace == ui::Dataspace::BT2020_ITU_PQ &&
+ mBufferInfo.mApi == NATIVE_WINDOW_API_MEDIA &&
mActiveBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);
}
@@ -268,7 +268,7 @@
compositionState.compositionType = Hwc2::IComposerClient::Composition::SIDEBAND;
} else {
// Normal buffer layers
- compositionState.hdrMetadata = getDrawingHdrMetadata();
+ compositionState.hdrMetadata = mBufferInfo.mHdrMetadata;
compositionState.compositionType = mPotentialCursor
? Hwc2::IComposerClient::Composition::CURSOR
: Hwc2::IComposerClient::Composition::DEVICE;
@@ -300,13 +300,13 @@
}
// Update mFrameTracker.
- nsecs_t desiredPresentTime = getDesiredPresentTime();
+ nsecs_t desiredPresentTime = mBufferInfo.mDesiredPresentTime;
mFrameTracker.setDesiredPresentTime(desiredPresentTime);
const int32_t layerID = getSequence();
mFlinger->mTimeStats->setDesiredTime(layerID, mCurrentFrameNumber, desiredPresentTime);
- std::shared_ptr<FenceTime> frameReadyFence = getCurrentFenceTime();
+ std::shared_ptr<FenceTime> frameReadyFence = mBufferInfo.mFenceTime;
if (frameReadyFence->isValid()) {
mFrameTracker.setFrameReadyFence(std::move(frameReadyFence));
} else {
@@ -394,6 +394,9 @@
return false;
}
+ BufferInfo oldBufferInfo = mBufferInfo;
+ gatherBufferInfo();
+
mRefreshPending = true;
mFrameLatencyNeeded = true;
if (oldBuffer == nullptr) {
@@ -402,43 +405,10 @@
recomputeVisibleRegions = true;
}
- ui::Dataspace dataSpace = getDrawingDataSpace();
- // translate legacy dataspaces to modern dataspaces
- switch (dataSpace) {
- case ui::Dataspace::SRGB:
- dataSpace = ui::Dataspace::V0_SRGB;
- break;
- case ui::Dataspace::SRGB_LINEAR:
- dataSpace = ui::Dataspace::V0_SRGB_LINEAR;
- break;
- case ui::Dataspace::JFIF:
- dataSpace = ui::Dataspace::V0_JFIF;
- break;
- case ui::Dataspace::BT601_625:
- dataSpace = ui::Dataspace::V0_BT601_625;
- break;
- case ui::Dataspace::BT601_525:
- dataSpace = ui::Dataspace::V0_BT601_525;
- break;
- case ui::Dataspace::BT709:
- dataSpace = ui::Dataspace::V0_BT709;
- break;
- default:
- break;
- }
- mCurrentDataSpace = dataSpace;
-
- Rect crop(getDrawingCrop());
- const uint32_t transform(getDrawingTransform());
- const uint32_t scalingMode(getDrawingScalingMode());
- const bool transformToDisplayInverse(getTransformToDisplayInverse());
- if ((crop != mCurrentCrop) || (transform != mCurrentTransform) ||
- (scalingMode != mCurrentScalingMode) ||
- (transformToDisplayInverse != mTransformToDisplayInverse)) {
- mCurrentCrop = crop;
- mCurrentTransform = transform;
- mCurrentScalingMode = scalingMode;
- mTransformToDisplayInverse = transformToDisplayInverse;
+ if ((mBufferInfo.mCrop != oldBufferInfo.mCrop) ||
+ (mBufferInfo.mTransform != oldBufferInfo.mTransform) ||
+ (mBufferInfo.mScaleMode != oldBufferInfo.mScaleMode) ||
+ (mBufferInfo.mTransformToDisplayInverse != oldBufferInfo.mTransformToDisplayInverse)) {
recomputeVisibleRegions = true;
}
@@ -510,7 +480,7 @@
return mOverrideScalingMode;
}
- return mCurrentScalingMode;
+ return mBufferInfo.mScaleMode;
}
bool BufferLayer::isProtected() const {
@@ -626,7 +596,7 @@
uint32_t bufHeight = mActiveBuffer->getHeight();
// Undo any transformations on the buffer and return the result.
- if (mCurrentTransform & ui::Transform::ROT_90) {
+ if (mBufferInfo.mTransform & ui::Transform::ROT_90) {
std::swap(bufWidth, bufHeight);
}
@@ -662,7 +632,7 @@
uint32_t bufHeight = mActiveBuffer->getHeight();
// Undo any transformations on the buffer and return the result.
- if (mCurrentTransform & ui::Transform::ROT_90) {
+ if (mBufferInfo.mTransform & ui::Transform::ROT_90) {
std::swap(bufWidth, bufHeight);
}
@@ -685,6 +655,66 @@
releasePendingBuffer(systemTime());
}
+PixelFormat BufferLayer::getPixelFormat() const {
+ return mBufferInfo.mPixelFormat;
+}
+
+bool BufferLayer::getTransformToDisplayInverse() const {
+ return mBufferInfo.mTransformToDisplayInverse;
+}
+
+Rect BufferLayer::getBufferCrop() const {
+ // this is the crop rectangle that applies to the buffer
+ // itself (as opposed to the window)
+ if (!mBufferInfo.mCrop.isEmpty()) {
+ // if the buffer crop is defined, we use that
+ return mBufferInfo.mCrop;
+ } else if (mActiveBuffer != nullptr) {
+ // otherwise we use the whole buffer
+ return mActiveBuffer->getBounds();
+ } else {
+ // if we don't have a buffer yet, we use an empty/invalid crop
+ return Rect();
+ }
+}
+
+uint32_t BufferLayer::getBufferTransform() const {
+ return mBufferInfo.mTransform;
+}
+
+ui::Dataspace BufferLayer::getDataSpace() const {
+ return mBufferInfo.mDataspace;
+}
+
+ui::Dataspace BufferLayer::translateDataspace(ui::Dataspace dataspace) {
+ ui::Dataspace updatedDataspace = dataspace;
+ // translate legacy dataspaces to modern dataspaces
+ switch (dataspace) {
+ case ui::Dataspace::SRGB:
+ updatedDataspace = ui::Dataspace::V0_SRGB;
+ break;
+ case ui::Dataspace::SRGB_LINEAR:
+ updatedDataspace = ui::Dataspace::V0_SRGB_LINEAR;
+ break;
+ case ui::Dataspace::JFIF:
+ updatedDataspace = ui::Dataspace::V0_JFIF;
+ break;
+ case ui::Dataspace::BT601_625:
+ updatedDataspace = ui::Dataspace::V0_BT601_625;
+ break;
+ case ui::Dataspace::BT601_525:
+ updatedDataspace = ui::Dataspace::V0_BT601_525;
+ break;
+ case ui::Dataspace::BT709:
+ updatedDataspace = ui::Dataspace::V0_BT709;
+ break;
+ default:
+ break;
+ }
+
+ return updatedDataspace;
+}
+
} // namespace android
#if defined(__gl_h_)
diff --git a/services/surfaceflinger/BufferLayer.h b/services/surfaceflinger/BufferLayer.h
index ee44cbe..e8838e8 100644
--- a/services/surfaceflinger/BufferLayer.h
+++ b/services/surfaceflinger/BufferLayer.h
@@ -106,6 +106,14 @@
// Should only be called on the main thread.
void latchAndReleaseBuffer() override;
+ bool getTransformToDisplayInverse() const override;
+
+ Rect getBufferCrop() const override;
+
+ uint32_t getBufferTransform() const override;
+
+ ui::Dataspace getDataSpace() const override;
+
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
@@ -115,18 +123,7 @@
virtual bool fenceHasSignaled() const = 0;
virtual bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const = 0;
- virtual nsecs_t getDesiredPresentTime() = 0;
- virtual std::shared_ptr<FenceTime> getCurrentFenceTime() const = 0;
-
- virtual void getDrawingTransformMatrix(float *matrix) = 0;
- virtual uint32_t getDrawingTransform() const = 0;
- virtual ui::Dataspace getDrawingDataSpace() const = 0;
- virtual Rect getDrawingCrop() const = 0;
- virtual uint32_t getDrawingScalingMode() const = 0;
- virtual Region getDrawingSurfaceDamage() const = 0;
- virtual const HdrMetadata& getDrawingHdrMetadata() const = 0;
- virtual int getDrawingApi() const = 0;
- virtual PixelFormat getPixelFormat() const = 0;
+ PixelFormat getPixelFormat() const;
virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;
@@ -148,6 +145,25 @@
virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;
protected:
+ struct BufferInfo {
+ nsecs_t mDesiredPresentTime;
+ std::shared_ptr<FenceTime> mFenceTime;
+ sp<Fence> mFence;
+ float mTransformMatrix[16];
+ uint32_t mTransform{0};
+ ui::Dataspace mDataspace;
+ Rect mCrop;
+ uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
+ Region mSurfaceDamage;
+ HdrMetadata mHdrMetadata;
+ int mApi;
+ PixelFormat mPixelFormat;
+ bool mTransformToDisplayInverse{false};
+ };
+
+ BufferInfo mBufferInfo;
+ virtual void gatherBufferInfo() = 0;
+
/*
* compositionengine::LayerFE overrides
*/
@@ -171,16 +187,14 @@
bool mRefreshPending{false};
+ ui::Dataspace translateDataspace(ui::Dataspace dataspace);
+
private:
// Returns true if this layer requires filtering
bool needsFiltering(const sp<const DisplayDevice>& displayDevice) const override;
uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;
- uint32_t mCurrentScalingMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
-
- bool mTransformToDisplayInverse{false};
-
// main thread.
bool mBufferLatched{false}; // TODO: Use mActiveBuffer?
diff --git a/services/surfaceflinger/BufferQueueLayer.cpp b/services/surfaceflinger/BufferQueueLayer.cpp
index 4da39e4..e9e8e6e 100644
--- a/services/surfaceflinger/BufferQueueLayer.cpp
+++ b/services/surfaceflinger/BufferQueueLayer.cpp
@@ -70,10 +70,6 @@
return history;
}
-bool BufferQueueLayer::getTransformToDisplayInverse() const {
- return mConsumer->getTransformToDisplayInverse();
-}
-
void BufferQueueLayer::releasePendingBuffer(nsecs_t dequeueReadyTime) {
if (!mConsumer->releasePendingBuffer()) {
return;
@@ -155,55 +151,12 @@
return mQueueItems[0].mTimestamp <= expectedPresentTime;
}
-nsecs_t BufferQueueLayer::getDesiredPresentTime() {
- return mConsumer->getTimestamp();
-}
-
-std::shared_ptr<FenceTime> BufferQueueLayer::getCurrentFenceTime() const {
- return mConsumer->getCurrentFenceTime();
-}
-
-void BufferQueueLayer::getDrawingTransformMatrix(float *matrix) {
- return mConsumer->getTransformMatrix(matrix);
-}
-
// NOTE: SurfaceFlinger's definitions of "Current" and "Drawing" do not neatly map to BufferQueue's
// These functions get the fields for the frame that is currently in SurfaceFlinger's Drawing state
// so the functions start with "getDrawing". The data is retrieved from the BufferQueueConsumer's
// current buffer so the consumer functions start with "getCurrent".
//
// This results in the rather confusing functions below.
-uint32_t BufferQueueLayer::getDrawingTransform() const {
- return mConsumer->getCurrentTransform();
-}
-
-ui::Dataspace BufferQueueLayer::getDrawingDataSpace() const {
- return mConsumer->getCurrentDataSpace();
-}
-
-Rect BufferQueueLayer::getDrawingCrop() const {
- return mConsumer->getCurrentCrop();
-}
-
-uint32_t BufferQueueLayer::getDrawingScalingMode() const {
- return mConsumer->getCurrentScalingMode();
-}
-
-Region BufferQueueLayer::getDrawingSurfaceDamage() const {
- return mConsumer->getSurfaceDamage();
-}
-
-const HdrMetadata& BufferQueueLayer::getDrawingHdrMetadata() const {
- return mConsumer->getCurrentHdrMetadata();
-}
-
-int BufferQueueLayer::getDrawingApi() const {
- return mConsumer->getCurrentApi();
-}
-
-PixelFormat BufferQueueLayer::getPixelFormat() const {
- return mFormat;
-}
uint64_t BufferQueueLayer::getFrameNumber(nsecs_t expectedPresentTime) const {
Mutex::Autolock lock(mQueueItemLock);
@@ -422,7 +375,7 @@
compositionState.buffer = mActiveBuffer;
compositionState.bufferSlot =
(mActiveBufferSlot == BufferQueue::INVALID_BUFFER_SLOT) ? 0 : mActiveBufferSlot;
- compositionState.acquireFence = mConsumer->getCurrentFence();
+ compositionState.acquireFence = mBufferInfo.mFence;
}
// -----------------------------------------------------------------------
@@ -573,4 +526,20 @@
return static_cast<uint32_t>(producerStickyTransform);
}
+void BufferQueueLayer::gatherBufferInfo() {
+ mBufferInfo.mDesiredPresentTime = mConsumer->getTimestamp();
+ mBufferInfo.mFenceTime = mConsumer->getCurrentFenceTime();
+ mBufferInfo.mFence = mConsumer->getCurrentFence();
+ mConsumer->getTransformMatrix(mBufferInfo.mTransformMatrix);
+ 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.mPixelFormat = mFormat;
+ mBufferInfo.mTransformToDisplayInverse = mConsumer->getTransformToDisplayInverse();
+}
+
} // namespace android
diff --git a/services/surfaceflinger/BufferQueueLayer.h b/services/surfaceflinger/BufferQueueLayer.h
index bf3f917..6cbafb3 100644
--- a/services/surfaceflinger/BufferQueueLayer.h
+++ b/services/surfaceflinger/BufferQueueLayer.h
@@ -46,7 +46,6 @@
std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) override;
- bool getTransformToDisplayInverse() const override;
// If a buffer was replaced this frame, release the former buffer
void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
@@ -66,18 +65,6 @@
bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
private:
- nsecs_t getDesiredPresentTime() override;
- std::shared_ptr<FenceTime> getCurrentFenceTime() const override;
-
- void getDrawingTransformMatrix(float *matrix) override;
- uint32_t getDrawingTransform() const override;
- ui::Dataspace getDrawingDataSpace() const override;
- Rect getDrawingCrop() const override;
- uint32_t getDrawingScalingMode() const override;
- Region getDrawingSurfaceDamage() const override;
- const HdrMetadata& getDrawingHdrMetadata() const override;
- int getDrawingApi() const override;
- PixelFormat getPixelFormat() const override;
uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;
@@ -103,6 +90,8 @@
// Interface implementation for BufferLayerConsumer::ContentsChangedListener
// -----------------------------------------------------------------------
protected:
+ void gatherBufferInfo() override;
+
void onFrameAvailable(const BufferItem& item) override;
void onFrameReplaced(const BufferItem& item) override;
void onSidebandStreamChanged() override;
diff --git a/services/surfaceflinger/BufferStateLayer.cpp b/services/surfaceflinger/BufferStateLayer.cpp
index e7d1b63..07a83b9 100644
--- a/services/surfaceflinger/BufferStateLayer.cpp
+++ b/services/surfaceflinger/BufferStateLayer.cpp
@@ -125,10 +125,6 @@
(mCurrentState.buffer != nullptr || mCurrentState.bgColorLayer != nullptr));
}
-bool BufferStateLayer::getTransformToDisplayInverse() const {
- return mCurrentState.transformToDisplayInverse;
-}
-
void BufferStateLayer::pushPendingState() {
if (!mCurrentState.modified) {
return;
@@ -400,75 +396,6 @@
return mCurrentState.desiredPresentTime <= expectedPresentTime;
}
-nsecs_t BufferStateLayer::getDesiredPresentTime() {
- return getDrawingState().desiredPresentTime;
-}
-
-std::shared_ptr<FenceTime> BufferStateLayer::getCurrentFenceTime() const {
- return std::make_shared<FenceTime>(getDrawingState().acquireFence);
-}
-
-void BufferStateLayer::getDrawingTransformMatrix(float *matrix) {
- std::copy(std::begin(mTransformMatrix), std::end(mTransformMatrix), matrix);
-}
-
-uint32_t BufferStateLayer::getDrawingTransform() const {
- return getDrawingState().transform;
-}
-
-ui::Dataspace BufferStateLayer::getDrawingDataSpace() const {
- return getDrawingState().dataspace;
-}
-
-// Crop that applies to the buffer
-Rect BufferStateLayer::getDrawingCrop() const {
- const State& s(getDrawingState());
-
- if (s.crop.isEmpty() && s.buffer) {
- return s.buffer->getBounds();
- } else if (s.buffer) {
- Rect crop = s.crop;
- crop.left = std::max(crop.left, 0);
- crop.top = std::max(crop.top, 0);
- uint32_t bufferWidth = s.buffer->getWidth();
- uint32_t bufferHeight = s.buffer->getHeight();
- if (bufferHeight <= std::numeric_limits<int32_t>::max() &&
- bufferWidth <= std::numeric_limits<int32_t>::max()) {
- crop.right = std::min(crop.right, static_cast<int32_t>(bufferWidth));
- crop.bottom = std::min(crop.bottom, static_cast<int32_t>(bufferHeight));
- }
- if (!crop.isValid()) {
- // Crop rect is out of bounds, return whole buffer
- return s.buffer->getBounds();
- }
- return crop;
- }
- return s.crop;
-}
-
-uint32_t BufferStateLayer::getDrawingScalingMode() const {
- return NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
-}
-
-Region BufferStateLayer::getDrawingSurfaceDamage() const {
- return getDrawingState().surfaceDamageRegion;
-}
-
-const HdrMetadata& BufferStateLayer::getDrawingHdrMetadata() const {
- return getDrawingState().hdrMetadata;
-}
-
-int BufferStateLayer::getDrawingApi() const {
- return getDrawingState().api;
-}
-
-PixelFormat BufferStateLayer::getPixelFormat() const {
- if (!mActiveBuffer) {
- return PIXEL_FORMAT_NONE;
- }
- return mActiveBuffer->format;
-}
-
uint64_t BufferStateLayer::getFrameNumber(nsecs_t /*expectedPresentTime*/) const {
return mFrameNumber;
}
@@ -506,8 +433,8 @@
}
void BufferStateLayer::setFilteringEnabled(bool enabled) {
- GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mActiveBuffer, mCurrentCrop,
- mCurrentTransform, enabled);
+ GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mActiveBuffer, mBufferInfo.mCrop,
+ mBufferInfo.mTransform, enabled);
}
status_t BufferStateLayer::bindTextureImage() {
@@ -576,8 +503,8 @@
}
const uint64_t bufferID = getCurrentBufferId();
- mFlinger->mTimeStats->setAcquireFence(layerID, mFrameNumber, getCurrentFenceTime());
- mFlinger->mFrameTracer->traceFence(layerID, bufferID, mFrameNumber, getCurrentFenceTime(),
+ mFlinger->mTimeStats->setAcquireFence(layerID, mFrameNumber, mBufferInfo.mFenceTime);
+ mFlinger->mFrameTracer->traceFence(layerID, bufferID, mFrameNumber, mBufferInfo.mFenceTime,
FrameTracer::FrameEvent::ACQUIRE_FENCE);
mFlinger->mTimeStats->setLatchTime(layerID, mFrameNumber, latchTime);
mFlinger->mFrameTracer->traceTimestamp(layerID, bufferID, mFrameNumber, latchTime,
@@ -622,7 +549,7 @@
compositionState.buffer = s.buffer;
compositionState.bufferSlot = mHwcSlotGenerator->getHwcCacheSlot(s.clientCacheId);
- compositionState.acquireFence = s.acquireFence;
+ compositionState.acquireFence = mBufferInfo.mFence;
mFrameNumber++;
}
@@ -707,4 +634,47 @@
mFreeHwcCacheSlots.push(hwcCacheSlot);
mCachedBuffers.erase(clientCacheId);
}
+
+void BufferStateLayer::gatherBufferInfo() {
+ const State& s(getDrawingState());
+
+ mBufferInfo.mDesiredPresentTime = s.desiredPresentTime;
+ mBufferInfo.mFenceTime = std::make_shared<FenceTime>(s.acquireFence);
+ mBufferInfo.mFence = s.acquireFence;
+ std::copy(std::begin(mTransformMatrix), std::end(mTransformMatrix),
+ mBufferInfo.mTransformMatrix);
+ mBufferInfo.mTransform = s.transform;
+ mBufferInfo.mDataspace = translateDataspace(s.dataspace);
+ mBufferInfo.mCrop = computeCrop(s);
+ mBufferInfo.mScaleMode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
+ mBufferInfo.mSurfaceDamage = s.surfaceDamageRegion;
+ mBufferInfo.mHdrMetadata = s.hdrMetadata;
+ mBufferInfo.mApi = s.api;
+ mBufferInfo.mPixelFormat = !mActiveBuffer ? PIXEL_FORMAT_NONE : mActiveBuffer->format;
+ mBufferInfo.mTransformToDisplayInverse = s.transformToDisplayInverse;
+}
+
+Rect BufferStateLayer::computeCrop(const State& s) {
+ if (s.crop.isEmpty() && s.buffer) {
+ return s.buffer->getBounds();
+ } else if (s.buffer) {
+ Rect crop = s.crop;
+ crop.left = std::max(crop.left, 0);
+ crop.top = std::max(crop.top, 0);
+ uint32_t bufferWidth = s.buffer->getWidth();
+ uint32_t bufferHeight = s.buffer->getHeight();
+ if (bufferHeight <= std::numeric_limits<int32_t>::max() &&
+ bufferWidth <= std::numeric_limits<int32_t>::max()) {
+ crop.right = std::min(crop.right, static_cast<int32_t>(bufferWidth));
+ crop.bottom = std::min(crop.bottom, static_cast<int32_t>(bufferHeight));
+ }
+ if (!crop.isValid()) {
+ // Crop rect is out of bounds, return whole buffer
+ return s.buffer->getBounds();
+ }
+ return crop;
+ }
+ return s.crop;
+}
+
} // namespace android
diff --git a/services/surfaceflinger/BufferStateLayer.h b/services/surfaceflinger/BufferStateLayer.h
index c060ca8..086fd0a 100644
--- a/services/surfaceflinger/BufferStateLayer.h
+++ b/services/surfaceflinger/BufferStateLayer.h
@@ -48,8 +48,6 @@
bool shouldPresentNow(nsecs_t expectedPresentTime) const override;
- bool getTransformToDisplayInverse() const override;
-
uint32_t doTransactionResize(uint32_t flags, Layer::State* /*stateToCommit*/) override {
return flags;
}
@@ -106,19 +104,10 @@
bool fenceHasSignaled() const override;
bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
-private:
- nsecs_t getDesiredPresentTime() override;
- std::shared_ptr<FenceTime> getCurrentFenceTime() const override;
+protected:
+ void gatherBufferInfo() override;
- void getDrawingTransformMatrix(float *matrix) override;
- uint32_t getDrawingTransform() const override;
- ui::Dataspace getDrawingDataSpace() const override;
- Rect getDrawingCrop() const override;
- uint32_t getDrawingScalingMode() const override;
- Region getDrawingSurfaceDamage() const override;
- const HdrMetadata& getDrawingHdrMetadata() const override;
- int getDrawingApi() const override;
- PixelFormat getPixelFormat() const override;
+private:
uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;
@@ -140,6 +129,9 @@
void latchPerFrameState(compositionengine::LayerFECompositionState&) const override;
+ // Crop that applies to the buffer
+ Rect computeCrop(const State& s);
+
private:
friend class SlotGenerationTest;
void onFirstRef() override;
diff --git a/services/surfaceflinger/ColorLayer.cpp b/services/surfaceflinger/ColorLayer.cpp
index 2ad7591..49b1810 100644
--- a/services/surfaceflinger/ColorLayer.cpp
+++ b/services/surfaceflinger/ColorLayer.cpp
@@ -99,11 +99,6 @@
compositionState.compositionType = Hwc2::IComposerClient::Composition::SOLID_COLOR;
}
-void ColorLayer::commitTransaction(const State& stateToCommit) {
- Layer::commitTransaction(stateToCommit);
- mCurrentDataSpace = mDrawingState.dataspace;
-}
-
std::shared_ptr<compositionengine::Layer> ColorLayer::getCompositionLayer() const {
return mCompositionLayer;
}
@@ -112,6 +107,10 @@
return (s.flags & layer_state_t::eLayerOpaque) != 0;
}
+ui::Dataspace ColorLayer::getDataSpace() const {
+ return mDrawingState.dataspace;
+}
+
// ---------------------------------------------------------------------------
}; // namespace android
diff --git a/services/surfaceflinger/ColorLayer.h b/services/surfaceflinger/ColorLayer.h
index 57c54c7..16921df 100644
--- a/services/surfaceflinger/ColorLayer.h
+++ b/services/surfaceflinger/ColorLayer.h
@@ -37,7 +37,7 @@
bool setDataspace(ui::Dataspace dataspace) override;
- void commitTransaction(const State& stateToCommit) override;
+ ui::Dataspace getDataSpace() const override;
bool isOpaque(const Layer::State& s) const override;
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index c916f74..f1a5175 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -78,7 +78,6 @@
mName(args.name),
mClientRef(args.client),
mWindowType(args.metadata.getInt32(METADATA_WINDOW_TYPE, 0)) {
- mCurrentCrop.makeInvalid();
uint32_t layerFlags = 0;
if (args.flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden;
@@ -259,23 +258,6 @@
// h/w composer set-up
// ---------------------------------------------------------------------------
-Rect Layer::getContentCrop() const {
- // this is the crop rectangle that applies to the buffer
- // itself (as opposed to the window)
- Rect crop;
- if (!mCurrentCrop.isEmpty()) {
- // if the buffer crop is defined, we use that
- crop = mCurrentCrop;
- } else if (mActiveBuffer != nullptr) {
- // otherwise we use the whole buffer
- crop = mActiveBuffer->getBounds();
- } else {
- // if we don't have a buffer yet, we use an empty/invalid crop
- crop.makeInvalid();
- }
- return crop;
-}
-
static Rect reduce(const Rect& win, const Region& exclude) {
if (CC_LIKELY(exclude.isEmpty())) {
return win;
@@ -335,7 +317,7 @@
int bufferWidth = mActiveBuffer->getWidth();
int bufferHeight = mActiveBuffer->getHeight();
- if (mCurrentTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
+ if (getBufferTransform() & NATIVE_WINDOW_TRANSFORM_ROT_90) {
std::swap(bufferWidth, bufferHeight);
}
@@ -442,9 +424,9 @@
compositionState.geomLayerTransform = getTransform();
compositionState.geomInverseLayerTransform = compositionState.geomLayerTransform.inverse();
compositionState.geomBufferSize = getBufferSize(drawingState);
- compositionState.geomContentCrop = getContentCrop();
+ compositionState.geomContentCrop = getBufferCrop();
compositionState.geomCrop = getCrop(drawingState);
- compositionState.geomBufferTransform = mCurrentTransform;
+ compositionState.geomBufferTransform = getBufferTransform();
compositionState.geomBufferUsesDisplayInverseTransform = getTransformToDisplayInverse();
compositionState.geomActiveTransparentRegion = getActiveTransparentRegion(drawingState);
compositionState.geomLayerBounds = mBounds;
@@ -466,7 +448,7 @@
compositionState.geomVisibleRegion = visibleRegion;
compositionState.isColorspaceAgnostic = isColorSpaceAgnostic();
- compositionState.dataspace = mCurrentDataSpace;
+ compositionState.dataspace = getDataSpace();
compositionState.colorTransform = getColorTransform();
compositionState.colorTransformIsIdentity = !hasColorTransform();
compositionState.surfaceDamage = surfaceDamageRegion;
@@ -543,7 +525,7 @@
layerSettings.geometry.roundedCornersCrop = roundedCornerState.cropRect;
layerSettings.alpha = alpha;
- layerSettings.sourceDataspace = mCurrentDataSpace;
+ layerSettings.sourceDataspace = getDataSpace();
return layerSettings;
}
@@ -726,7 +708,7 @@
" requested={ wh={%4u,%4u} }}\n"
" drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
" requested={ wh={%4u,%4u} }}\n",
- this, getName().string(), mCurrentTransform, getEffectiveScalingMode(),
+ this, getName().string(), getBufferTransform(), getEffectiveScalingMode(),
stateToCommit->active_legacy.w, stateToCommit->active_legacy.h,
stateToCommit->crop_legacy.left, stateToCommit->crop_legacy.top,
stateToCommit->crop_legacy.right, stateToCommit->crop_legacy.bottom,
@@ -1232,7 +1214,7 @@
info.mColor = ds.color;
info.mFlags = ds.flags;
info.mPixelFormat = getPixelFormat();
- info.mDataSpace = static_cast<android_dataspace>(mCurrentDataSpace);
+ info.mDataSpace = static_cast<android_dataspace>(getDataSpace());
info.mMatrix[0][0] = ds.active_legacy.transform[0][0];
info.mMatrix[0][1] = ds.active_legacy.transform[0][1];
info.mMatrix[1][0] = ds.active_legacy.transform[1][0];
@@ -1551,8 +1533,9 @@
bool Layer::isLegacyDataSpace() const {
// return true when no higher bits are set
- return !(mCurrentDataSpace & (ui::Dataspace::STANDARD_MASK |
- ui::Dataspace::TRANSFER_MASK | ui::Dataspace::RANGE_MASK));
+ return !(getDataSpace() &
+ (ui::Dataspace::STANDARD_MASK | ui::Dataspace::TRANSFER_MASK |
+ ui::Dataspace::RANGE_MASK));
}
void Layer::setParent(const sp<Layer>& layer) {
@@ -1834,13 +1817,12 @@
if (buffer != nullptr) {
LayerProtoHelper::writeToProto(buffer,
[&]() { return layerInfo->mutable_active_buffer(); });
- LayerProtoHelper::writeToProto(ui::Transform(mCurrentTransform),
+ LayerProtoHelper::writeToProto(ui::Transform(getBufferTransform()),
layerInfo->mutable_buffer_transform());
}
layerInfo->set_invalidate(contentDirty);
layerInfo->set_is_protected(isProtected());
- layerInfo->set_dataspace(
- dataspaceDetails(static_cast<android_dataspace>(mCurrentDataSpace)));
+ layerInfo->set_dataspace(dataspaceDetails(static_cast<android_dataspace>(getDataSpace())));
layerInfo->set_queued_frames(getQueuedFrameCount());
layerInfo->set_refresh_pending(isBufferLatched());
layerInfo->set_curr_frame(mCurrentFrameNumber);
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 23c1acd..ea5b844 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -330,7 +330,7 @@
virtual bool setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace);
virtual bool setColorSpaceAgnostic(const bool agnostic);
- ui::Dataspace getDataSpace() const { return mCurrentDataSpace; }
+ virtual ui::Dataspace getDataSpace() const { return ui::Dataspace::UNKNOWN; }
// Before color management is introduced, contents on Android have to be
// desaturated in order to match what they appears like visually.
@@ -587,7 +587,12 @@
* returns the rectangle that crops the content of the layer and scales it
* to the layer's size.
*/
- Rect getContentCrop() const;
+ virtual Rect getBufferCrop() const { return Rect(); }
+
+ /*
+ * Returns the transform applied to the buffer.
+ */
+ virtual uint32_t getBufferTransform() const { return 0; }
/*
* Returns if a frame is ready
@@ -846,9 +851,6 @@
// composition, true otherwise.
bool mIsActiveBufferUpdatedForGpu = true;
- ui::Dataspace mCurrentDataSpace = ui::Dataspace::UNKNOWN;
- Rect mCurrentCrop;
- uint32_t mCurrentTransform{0};
// We encode unset as -1.
int32_t mOverrideScalingMode{-1};
std::atomic<uint64_t> mCurrentFrameNumber{0};