Revert^2 "Remove setFrame from BufferStateLayer"
1014c4bf14f5c250b78d7e917fb59aaa9b0d9b0a
Change-Id: I4c1cbc2b40e4f5f68bd5e6dcbe6c77405ad155b0
diff --git a/libs/gui/BLASTBufferQueue.cpp b/libs/gui/BLASTBufferQueue.cpp
index bcdd06b..e5afd40 100644
--- a/libs/gui/BLASTBufferQueue.cpp
+++ b/libs/gui/BLASTBufferQueue.cpp
@@ -204,13 +204,16 @@
if (mRequestedSize != newSize) {
mRequestedSize.set(newSize);
mBufferItemConsumer->setDefaultBufferSize(mRequestedSize.width, mRequestedSize.height);
- if (mLastBufferScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE) {
+ if (mLastBufferInfo.scalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE) {
// If the buffer supports scaling, update the frame immediately since the client may
// want to scale the existing buffer to the new size.
mSize = mRequestedSize;
- t.setFrame(mSurfaceControl,
- {0, 0, static_cast<int32_t>(mSize.width),
- static_cast<int32_t>(mSize.height)});
+ // We only need to update the scale if we've received at least one buffer. The reason
+ // for this is the scale is calculated based on the requested size and buffer size.
+ // If there's no buffer, the scale will always be 1.
+ if (mLastBufferInfo.hasBuffer) {
+ setMatrix(&t, mLastBufferInfo);
+ }
applyTransaction = true;
}
}
@@ -374,8 +377,10 @@
// Ensure BLASTBufferQueue stays alive until we receive the transaction complete callback.
incStrong((void*)transactionCallbackThunk);
- mLastBufferScalingMode = bufferItem.mScalingMode;
mLastAcquiredFrameNumber = bufferItem.mFrameNumber;
+ mLastBufferInfo.update(true /* hasBuffer */, bufferItem.mGraphicBuffer->getWidth(),
+ bufferItem.mGraphicBuffer->getHeight(), bufferItem.mTransform,
+ bufferItem.mScalingMode);
auto releaseBufferCallback =
std::bind(releaseBufferCallbackThunk, wp<BLASTBufferQueue>(this) /* callbackContext */,
@@ -388,8 +393,7 @@
bufferItem.mFence ? new Fence(bufferItem.mFence->dup()) : Fence::NO_FENCE);
t->addTransactionCompletedCallback(transactionCallbackThunk, static_cast<void*>(this));
- t->setFrame(mSurfaceControl,
- {0, 0, static_cast<int32_t>(mSize.width), static_cast<int32_t>(mSize.height)});
+ setMatrix(t, mLastBufferInfo);
t->setCrop(mSurfaceControl, computeCrop(bufferItem));
t->setTransform(mSurfaceControl, bufferItem.mTransform);
t->setTransformToDisplayInverse(mSurfaceControl, bufferItem.mTransformToDisplayInverse);
@@ -515,6 +519,17 @@
return mSize != bufferSize;
}
+void BLASTBufferQueue::setMatrix(SurfaceComposerClient::Transaction* t,
+ const BufferInfo& bufferInfo) {
+ uint32_t bufWidth = bufferInfo.width;
+ uint32_t bufHeight = bufferInfo.height;
+
+ float dsdx = mSize.width / static_cast<float>(bufWidth);
+ float dsdy = mSize.height / static_cast<float>(bufHeight);
+
+ t->setMatrix(mSurfaceControl, dsdx, 0, 0, dsdy);
+}
+
void BLASTBufferQueue::setTransactionCompleteCallback(
uint64_t frameNumber, std::function<void(int64_t)>&& transactionCompleteCallback) {
std::lock_guard _lock{mMutex};
diff --git a/libs/gui/LayerState.cpp b/libs/gui/LayerState.cpp
index 5b213ad..8094385 100644
--- a/libs/gui/LayerState.cpp
+++ b/libs/gui/LayerState.cpp
@@ -455,10 +455,6 @@
what |= eCropChanged;
crop = other.crop;
}
- if (other.what & eFrameChanged) {
- what |= eFrameChanged;
- orientedDisplaySpaceRect = other.orientedDisplaySpaceRect;
- }
if (other.what & eBufferChanged) {
what |= eBufferChanged;
buffer = other.buffer;
diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp
index e01a5ae..9ce094a 100644
--- a/libs/gui/SurfaceComposerClient.cpp
+++ b/libs/gui/SurfaceComposerClient.cpp
@@ -1232,20 +1232,6 @@
return *this;
}
-SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrame(
- const sp<SurfaceControl>& sc, const Rect& frame) {
- layer_state_t* s = getLayerState(sc);
- if (!s) {
- mStatus = BAD_INDEX;
- return *this;
- }
- s->what |= layer_state_t::eFrameChanged;
- s->orientedDisplaySpaceRect = frame;
-
- registerSurfaceControlForCallback(sc);
- return *this;
-}
-
SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBuffer(
const sp<SurfaceControl>& sc, const sp<GraphicBuffer>& buffer,
ReleaseBufferCallback callback) {
diff --git a/libs/gui/include/gui/BLASTBufferQueue.h b/libs/gui/include/gui/BLASTBufferQueue.h
index fbd16f4..a48f95a 100644
--- a/libs/gui/include/gui/BLASTBufferQueue.h
+++ b/libs/gui/include/gui/BLASTBufferQueue.h
@@ -142,6 +142,33 @@
ui::Size mRequestedSize GUARDED_BY(mMutex);
int32_t mFormat GUARDED_BY(mMutex);
+ struct BufferInfo {
+ bool hasBuffer = false;
+ uint32_t width;
+ uint32_t height;
+ uint32_t transform;
+ // This is used to check if we should update the blast layer size immediately or wait until
+ // we get the next buffer. This will support scenarios where the layer can change sizes
+ // and the buffer will scale to fit the new size.
+ uint32_t scalingMode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
+
+ void update(bool hasBuffer, uint32_t width, uint32_t height, uint32_t transform,
+ uint32_t scalingMode) {
+ this->hasBuffer = hasBuffer;
+ this->width = width;
+ this->height = height;
+ this->transform = transform;
+ this->scalingMode = scalingMode;
+ }
+ };
+
+ // Last acquired buffer's info. This is used to calculate the correct scale when size change is
+ // requested. We need to use the old buffer's info to determine what scale we need to apply to
+ // ensure the correct size.
+ BufferInfo mLastBufferInfo GUARDED_BY(mMutex);
+ void setMatrix(SurfaceComposerClient::Transaction* t, const BufferInfo& bufferInfo)
+ REQUIRES(mMutex);
+
uint32_t mTransformHint GUARDED_BY(mMutex);
sp<IGraphicBufferConsumer> mConsumer;
@@ -159,11 +186,6 @@
std::queue<FrameTimelineInfo> mNextFrameTimelineInfoQueue GUARDED_BY(mMutex);
- // Last acquired buffer's scaling mode. This is used to check if we should update the blast
- // layer size immediately or wait until we get the next buffer. This will support scenarios
- // where the layer can change sizes and the buffer will scale to fit the new size.
- uint32_t mLastBufferScalingMode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
-
// Tracks the last acquired frame number
uint64_t mLastAcquiredFrameNumber GUARDED_BY(mMutex) = 0;
diff --git a/libs/gui/include/gui/LayerState.h b/libs/gui/include/gui/LayerState.h
index 65d7710..41a022f 100644
--- a/libs/gui/include/gui/LayerState.h
+++ b/libs/gui/include/gui/LayerState.h
@@ -105,7 +105,7 @@
eHasListenerCallbacksChanged = 0x20000000,
eInputInfoChanged = 0x40000000,
eCornerRadiusChanged = 0x80000000,
- eFrameChanged = 0x1'00000000,
+ /* was eFrameChanged, now available 0x1'00000000, */
eCachedBufferChanged = 0x2'00000000,
eBackgroundColorChanged = 0x4'00000000,
eMetadataChanged = 0x8'00000000,
diff --git a/libs/gui/include/gui/SurfaceComposerClient.h b/libs/gui/include/gui/SurfaceComposerClient.h
index 2487961..1590b10 100644
--- a/libs/gui/include/gui/SurfaceComposerClient.h
+++ b/libs/gui/include/gui/SurfaceComposerClient.h
@@ -473,7 +473,6 @@
Transaction& setTransform(const sp<SurfaceControl>& sc, uint32_t transform);
Transaction& setTransformToDisplayInverse(const sp<SurfaceControl>& sc,
bool transformToDisplayInverse);
- Transaction& setFrame(const sp<SurfaceControl>& sc, const Rect& frame);
Transaction& setBuffer(const sp<SurfaceControl>& sc, const sp<GraphicBuffer>& buffer,
ReleaseBufferCallback callback = nullptr);
Transaction& setCachedBuffer(const sp<SurfaceControl>& sc, int32_t bufferId);
diff --git a/libs/gui/tests/BLASTBufferQueue_test.cpp b/libs/gui/tests/BLASTBufferQueue_test.cpp
index fe48d88..9b1f0db 100644
--- a/libs/gui/tests/BLASTBufferQueue_test.cpp
+++ b/libs/gui/tests/BLASTBufferQueue_test.cpp
@@ -140,7 +140,6 @@
/*parent*/ nullptr);
t.setLayerStack(mSurfaceControl, 0)
.setLayer(mSurfaceControl, std::numeric_limits<int32_t>::max())
- .setFrame(mSurfaceControl, Rect(resolution))
.show(mSurfaceControl)
.setDataspace(mSurfaceControl, ui::Dataspace::V0_SRGB)
.apply();
@@ -218,13 +217,13 @@
col >= region.left - border && col < region.right + border;
}
if (!outsideRegion && inRegion) {
- EXPECT_GE(epsilon, abs(r - *(pixel)));
- EXPECT_GE(epsilon, abs(g - *(pixel + 1)));
- EXPECT_GE(epsilon, abs(b - *(pixel + 2)));
+ ASSERT_GE(epsilon, abs(r - *(pixel)));
+ ASSERT_GE(epsilon, abs(g - *(pixel + 1)));
+ ASSERT_GE(epsilon, abs(b - *(pixel + 2)));
} else if (outsideRegion && !inRegion) {
- EXPECT_GE(epsilon, abs(r - *(pixel)));
- EXPECT_GE(epsilon, abs(g - *(pixel + 1)));
- EXPECT_GE(epsilon, abs(b - *(pixel + 2)));
+ ASSERT_GE(epsilon, abs(r - *(pixel)));
+ ASSERT_GE(epsilon, abs(g - *(pixel + 1)));
+ ASSERT_GE(epsilon, abs(b - *(pixel + 2)));
}
ASSERT_EQ(false, ::testing::Test::HasFailure());
}
@@ -466,7 +465,8 @@
ASSERT_EQ(NO_ERROR, captureDisplay(mCaptureArgs, mCaptureResults));
ASSERT_NO_FATAL_FAILURE(
- checkScreenCapture(r, g, b, {0, 0, (int32_t)mDisplayWidth, (int32_t)mDisplayHeight}));
+ checkScreenCapture(r, g, b,
+ {0, 0, (int32_t)mDisplayWidth, (int32_t)mDisplayHeight / 2}));
}
TEST_F(BLASTBufferQueueTest, SetCrop_ScalingModeScaleCrop) {
@@ -523,13 +523,15 @@
// capture screen and verify that it is red
ASSERT_EQ(NO_ERROR, captureDisplay(mCaptureArgs, mCaptureResults));
+ Rect bounds;
+ bounds.left = finalCropSideLength / 2;
+ bounds.top = 0;
+ bounds.right = bounds.left + finalCropSideLength;
+ bounds.bottom = finalCropSideLength;
+
+ ASSERT_NO_FATAL_FAILURE(checkScreenCapture(r, g, b, bounds));
ASSERT_NO_FATAL_FAILURE(
- checkScreenCapture(r, g, b,
- {0, 0, (int32_t)bufferSideLength, (int32_t)bufferSideLength}));
- ASSERT_NO_FATAL_FAILURE(
- checkScreenCapture(0, 0, 0,
- {0, 0, (int32_t)bufferSideLength, (int32_t)bufferSideLength},
- /*border*/ 0, /*outsideRegion*/ true));
+ checkScreenCapture(0, 0, 0, bounds, /*border*/ 0, /*outsideRegion*/ true));
}
class TestProducerListener : public BnProducerListener {
@@ -596,7 +598,6 @@
t.setLayerStack(bgSurface, 0)
.show(bgSurface)
.setDataspace(bgSurface, ui::Dataspace::V0_SRGB)
- .setFrame(bgSurface, Rect(0, 0, mDisplayWidth, mDisplayHeight))
.setLayer(bgSurface, std::numeric_limits<int32_t>::max() - 1)
.apply();
@@ -619,7 +620,8 @@
ASSERT_EQ(NO_ERROR, captureDisplay(mCaptureArgs, mCaptureResults));
ASSERT_NO_FATAL_FAILURE(
- checkScreenCapture(r, g, b, {0, 0, (int32_t)mDisplayWidth, (int32_t)mDisplayHeight}));
+ checkScreenCapture(r, g, b,
+ {0, 0, (int32_t)mDisplayWidth, (int32_t)mDisplayHeight / 2}));
}
class BLASTBufferQueueTransformTest : public BLASTBufferQueueTest {