bd41ea359f
If a single transaction has both positional and size changes, ensure we don't draw any frames using the incorrect buffer size using the updated position. Wait for the correct buffer size and then proceed. Change-Id: I8e25f21f17e0936e66bb5053f85f8336c8464c7b
299 lines
11 KiB
C++
299 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2011 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.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <android/native_window.h>
|
|
|
|
#include <binder/IMemory.h>
|
|
|
|
#include <gui/ISurfaceComposer.h>
|
|
#include <gui/Surface.h>
|
|
#include <gui/SurfaceComposerClient.h>
|
|
#include <private/gui/ComposerService.h>
|
|
|
|
#include <utils/String8.h>
|
|
#include <ui/DisplayInfo.h>
|
|
|
|
namespace android {
|
|
|
|
// Fill an RGBA_8888 formatted surface with a single color.
|
|
static void fillSurfaceRGBA8(const sp<SurfaceControl>& sc,
|
|
uint8_t r, uint8_t g, uint8_t b) {
|
|
ANativeWindow_Buffer outBuffer;
|
|
sp<Surface> s = sc->getSurface();
|
|
ASSERT_TRUE(s != NULL);
|
|
ASSERT_EQ(NO_ERROR, s->lock(&outBuffer, NULL));
|
|
uint8_t* img = reinterpret_cast<uint8_t*>(outBuffer.bits);
|
|
for (uint32_t y = 0; y < outBuffer.height; y++) {
|
|
for (uint32_t x = 0; x < outBuffer.width; x++) {
|
|
uint8_t* pixel = img + (4 * (y*outBuffer.stride + x));
|
|
pixel[0] = r;
|
|
pixel[1] = g;
|
|
pixel[2] = b;
|
|
pixel[3] = 255;
|
|
}
|
|
}
|
|
ASSERT_EQ(NO_ERROR, s->unlockAndPost());
|
|
}
|
|
|
|
// A ScreenCapture is a screenshot from SurfaceFlinger that can be used to check
|
|
// individual pixel values for testing purposes.
|
|
class ScreenCapture : public RefBase {
|
|
public:
|
|
static void captureScreen(sp<ScreenCapture>* sc) {
|
|
sp<IGraphicBufferProducer> producer;
|
|
sp<IGraphicBufferConsumer> consumer;
|
|
BufferQueue::createBufferQueue(&producer, &consumer);
|
|
IGraphicBufferProducer::QueueBufferOutput bufferOutput;
|
|
sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
|
|
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
|
|
sp<IBinder> display(sf->getBuiltInDisplay(
|
|
ISurfaceComposer::eDisplayIdMain));
|
|
ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(), 0, 0,
|
|
0, INT_MAX, false));
|
|
*sc = new ScreenCapture(cpuConsumer);
|
|
}
|
|
|
|
void checkPixel(uint32_t x, uint32_t y, uint8_t r, uint8_t g, uint8_t b) {
|
|
ASSERT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, mBuf.format);
|
|
const uint8_t* img = static_cast<const uint8_t*>(mBuf.data);
|
|
const uint8_t* pixel = img + (4 * (y * mBuf.stride + x));
|
|
if (r != pixel[0] || g != pixel[1] || b != pixel[2]) {
|
|
String8 err(String8::format("pixel @ (%3d, %3d): "
|
|
"expected [%3d, %3d, %3d], got [%3d, %3d, %3d]",
|
|
x, y, r, g, b, pixel[0], pixel[1], pixel[2]));
|
|
EXPECT_EQ(String8(), err);
|
|
}
|
|
}
|
|
|
|
private:
|
|
ScreenCapture(const sp<CpuConsumer>& cc) :
|
|
mCC(cc) {
|
|
EXPECT_EQ(NO_ERROR, mCC->lockNextBuffer(&mBuf));
|
|
}
|
|
|
|
~ScreenCapture() {
|
|
mCC->unlockBuffer(mBuf);
|
|
}
|
|
|
|
sp<CpuConsumer> mCC;
|
|
CpuConsumer::LockedBuffer mBuf;
|
|
};
|
|
|
|
class LayerUpdateTest : public ::testing::Test {
|
|
protected:
|
|
virtual void SetUp() {
|
|
mComposerClient = new SurfaceComposerClient;
|
|
ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
|
|
|
|
sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(
|
|
ISurfaceComposer::eDisplayIdMain));
|
|
DisplayInfo info;
|
|
SurfaceComposerClient::getDisplayInfo(display, &info);
|
|
|
|
ssize_t displayWidth = info.w;
|
|
ssize_t displayHeight = info.h;
|
|
|
|
// Background surface
|
|
mBGSurfaceControl = mComposerClient->createSurface(
|
|
String8("BG Test Surface"), displayWidth, displayHeight,
|
|
PIXEL_FORMAT_RGBA_8888, 0);
|
|
ASSERT_TRUE(mBGSurfaceControl != NULL);
|
|
ASSERT_TRUE(mBGSurfaceControl->isValid());
|
|
fillSurfaceRGBA8(mBGSurfaceControl, 63, 63, 195);
|
|
|
|
// Foreground surface
|
|
mFGSurfaceControl = mComposerClient->createSurface(
|
|
String8("FG Test Surface"), 64, 64, PIXEL_FORMAT_RGBA_8888, 0);
|
|
ASSERT_TRUE(mFGSurfaceControl != NULL);
|
|
ASSERT_TRUE(mFGSurfaceControl->isValid());
|
|
|
|
fillSurfaceRGBA8(mFGSurfaceControl, 195, 63, 63);
|
|
|
|
// Synchronization surface
|
|
mSyncSurfaceControl = mComposerClient->createSurface(
|
|
String8("Sync Test Surface"), 1, 1, PIXEL_FORMAT_RGBA_8888, 0);
|
|
ASSERT_TRUE(mSyncSurfaceControl != NULL);
|
|
ASSERT_TRUE(mSyncSurfaceControl->isValid());
|
|
|
|
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
|
|
|
|
SurfaceComposerClient::openGlobalTransaction();
|
|
|
|
ASSERT_EQ(NO_ERROR, mBGSurfaceControl->setLayer(INT_MAX-2));
|
|
ASSERT_EQ(NO_ERROR, mBGSurfaceControl->show());
|
|
|
|
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayer(INT_MAX-1));
|
|
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(64, 64));
|
|
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->show());
|
|
|
|
ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->setLayer(INT_MAX-1));
|
|
ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->setPosition(displayWidth-2,
|
|
displayHeight-2));
|
|
ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->show());
|
|
|
|
SurfaceComposerClient::closeGlobalTransaction(true);
|
|
}
|
|
|
|
virtual void TearDown() {
|
|
mComposerClient->dispose();
|
|
mBGSurfaceControl = 0;
|
|
mFGSurfaceControl = 0;
|
|
mSyncSurfaceControl = 0;
|
|
mComposerClient = 0;
|
|
}
|
|
|
|
void waitForPostedBuffers() {
|
|
// Since the sync surface is in synchronous mode (i.e. double buffered)
|
|
// posting three buffers to it should ensure that at least two
|
|
// SurfaceFlinger::handlePageFlip calls have been made, which should
|
|
// guaranteed that a buffer posted to another Surface has been retired.
|
|
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
|
|
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
|
|
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
|
|
}
|
|
|
|
sp<SurfaceComposerClient> mComposerClient;
|
|
sp<SurfaceControl> mBGSurfaceControl;
|
|
sp<SurfaceControl> mFGSurfaceControl;
|
|
|
|
// This surface is used to ensure that the buffers posted to
|
|
// mFGSurfaceControl have been picked up by SurfaceFlinger.
|
|
sp<SurfaceControl> mSyncSurfaceControl;
|
|
};
|
|
|
|
TEST_F(LayerUpdateTest, LayerMoveWorks) {
|
|
sp<ScreenCapture> sc;
|
|
{
|
|
SCOPED_TRACE("before move");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 0, 12, 63, 63, 195);
|
|
sc->checkPixel( 75, 75, 195, 63, 63);
|
|
sc->checkPixel(145, 145, 63, 63, 195);
|
|
}
|
|
|
|
SurfaceComposerClient::openGlobalTransaction();
|
|
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(128, 128));
|
|
SurfaceComposerClient::closeGlobalTransaction(true);
|
|
{
|
|
// This should reflect the new position, but not the new color.
|
|
SCOPED_TRACE("after move, before redraw");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 24, 24, 63, 63, 195);
|
|
sc->checkPixel( 75, 75, 63, 63, 195);
|
|
sc->checkPixel(145, 145, 195, 63, 63);
|
|
}
|
|
|
|
fillSurfaceRGBA8(mFGSurfaceControl, 63, 195, 63);
|
|
waitForPostedBuffers();
|
|
{
|
|
// This should reflect the new position and the new color.
|
|
SCOPED_TRACE("after redraw");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 24, 24, 63, 63, 195);
|
|
sc->checkPixel( 75, 75, 63, 63, 195);
|
|
sc->checkPixel(145, 145, 63, 195, 63);
|
|
}
|
|
}
|
|
|
|
TEST_F(LayerUpdateTest, LayerResizeWorks) {
|
|
sp<ScreenCapture> sc;
|
|
{
|
|
SCOPED_TRACE("before resize");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 0, 12, 63, 63, 195);
|
|
sc->checkPixel( 75, 75, 195, 63, 63);
|
|
sc->checkPixel(145, 145, 63, 63, 195);
|
|
}
|
|
|
|
ALOGD("resizing");
|
|
SurfaceComposerClient::openGlobalTransaction();
|
|
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setSize(128, 128));
|
|
SurfaceComposerClient::closeGlobalTransaction(true);
|
|
ALOGD("resized");
|
|
{
|
|
// This should not reflect the new size or color because SurfaceFlinger
|
|
// has not yet received a buffer of the correct size.
|
|
SCOPED_TRACE("after resize, before redraw");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 0, 12, 63, 63, 195);
|
|
sc->checkPixel( 75, 75, 195, 63, 63);
|
|
sc->checkPixel(145, 145, 63, 63, 195);
|
|
}
|
|
|
|
ALOGD("drawing");
|
|
fillSurfaceRGBA8(mFGSurfaceControl, 63, 195, 63);
|
|
waitForPostedBuffers();
|
|
ALOGD("drawn");
|
|
{
|
|
// This should reflect the new size and the new color.
|
|
SCOPED_TRACE("after redraw");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 24, 24, 63, 63, 195);
|
|
sc->checkPixel( 75, 75, 63, 195, 63);
|
|
sc->checkPixel(145, 145, 63, 195, 63);
|
|
}
|
|
}
|
|
|
|
// Ensure that if we move and resize a surface in the same
|
|
// transaction, we don't reposition the surface and draw
|
|
// using the incorrect buffer size
|
|
TEST_F(LayerUpdateTest, LayerMoveAndResizeWorks) {
|
|
sp<ScreenCapture> sc;
|
|
{
|
|
SCOPED_TRACE("before resize and reposition");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 0, 12, 63, 63, 195);
|
|
sc->checkPixel( 75, 75, 195, 63, 63);
|
|
sc->checkPixel(145, 145, 63, 63, 195);
|
|
}
|
|
|
|
ALOGD("resizing and repositioning");
|
|
SurfaceComposerClient::openGlobalTransaction();
|
|
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(64, 0));
|
|
ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setSize(64, 128));
|
|
SurfaceComposerClient::closeGlobalTransaction(true);
|
|
|
|
ALOGD("resized and repositioned");
|
|
{
|
|
// This should not reflect the new size, position or color because SurfaceFlinger
|
|
// has not yet received a buffer of the correct size.
|
|
SCOPED_TRACE("after resize, before redraw");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 0, 12, 63, 63, 195);
|
|
sc->checkPixel( 75, 75, 195, 63, 63);
|
|
sc->checkPixel(145, 145, 63, 63, 195);
|
|
}
|
|
|
|
ALOGD("drawing");
|
|
fillSurfaceRGBA8(mFGSurfaceControl, 63, 195, 63);
|
|
waitForPostedBuffers();
|
|
ALOGD("drawn");
|
|
{
|
|
// This should reflect the new size, position and the new color.
|
|
SCOPED_TRACE("after redraw");
|
|
ScreenCapture::captureScreen(&sc);
|
|
sc->checkPixel( 64, 0, 63, 195, 63);
|
|
// This should pass to imply that we didn't have a frame where the
|
|
// surface was moved but not yet resized even though the operations
|
|
// were part of the same transaction
|
|
sc->checkPixel( 64, 75, 63, 195, 63);
|
|
sc->checkPixel(145, 145, 63, 63, 195);
|
|
}
|
|
}
|
|
}
|