b64d875152
Update the screenshot code and add correct return values to surface flinger's
capturescreenshot function.
Buf: 18138368
Change-Id: Ieb42d289088589f941502fbd69da7aa939265e07
(cherry picked from commit 5a16a62950)
253 lines
9.0 KiB
C++
253 lines
9.0 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);
|
|
}
|
|
}
|
|
|
|
}
|