1 /*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wconversion"
20
21 #include <common/FlagManager.h>
22 #include <gui/IConsumerListener.h>
23 #include <ui/DisplayState.h>
24
25 #include "LayerTransactionTest.h"
26 #include "gui/SurfaceComposerClient.h"
27 #include "ui/DisplayId.h"
28
29 namespace android {
30
31 using android::hardware::graphics::common::V1_1::BufferUsage;
32
33 ::testing::Environment* const binderEnv =
34 ::testing::AddGlobalTestEnvironment(new BinderEnvironment());
35
36 class MultiDisplayTest : public LayerTransactionTest {
37 protected:
SetUp()38 virtual void SetUp() {
39 LayerTransactionTest::SetUp();
40 ASSERT_EQ(NO_ERROR, mClient->initCheck());
41
42 const auto ids = SurfaceComposerClient::getPhysicalDisplayIds();
43 ASSERT_FALSE(ids.empty());
44 mMainDisplayId = ids.front();
45 mMainDisplay = SurfaceComposerClient::getPhysicalDisplayToken(mMainDisplayId);
46 SurfaceComposerClient::getDisplayState(mMainDisplay, &mMainDisplayState);
47 SurfaceComposerClient::getActiveDisplayMode(mMainDisplay, &mMainDisplayMode);
48
49 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
50 mConsumer->setConsumerName(String8("Virtual disp consumer (MultiDisplayLayerBounds)"));
51 mConsumer->setDefaultBufferSize(mMainDisplayMode.resolution.getWidth(),
52 mMainDisplayMode.resolution.getHeight());
53
54 class StubConsumerListener : public IConsumerListener {
55 virtual void onFrameAvailable(const BufferItem&) override {}
56 virtual void onBuffersReleased() override {}
57 virtual void onSidebandStreamChanged() override {}
58 };
59 mConsumer->consumerConnect(sp<StubConsumerListener>::make(), true);
60 }
61
TearDown()62 virtual void TearDown() {
63 EXPECT_EQ(NO_ERROR, SurfaceComposerClient::destroyVirtualDisplay(mVirtualDisplay));
64 LayerTransactionTest::TearDown();
65 mColorLayer = 0;
66 }
67
createDisplay(const ui::Size & layerStackSize,ui::LayerStack layerStack)68 void createDisplay(const ui::Size& layerStackSize, ui::LayerStack layerStack) {
69 static const std::string kDisplayName("VirtualDisplay");
70 mVirtualDisplay =
71 SurfaceComposerClient::createVirtualDisplay(kDisplayName, false /*isSecure*/);
72 asTransaction([&](Transaction& t) {
73 t.setDisplaySurface(mVirtualDisplay, mProducer);
74 t.setDisplayLayerStack(mVirtualDisplay, layerStack);
75 t.setDisplayProjection(mVirtualDisplay, mMainDisplayState.orientation,
76 Rect(layerStackSize), Rect(mMainDisplayMode.resolution));
77 });
78 }
79
createColorLayer(ui::LayerStack layerStack)80 void createColorLayer(ui::LayerStack layerStack) {
81 mColorLayer =
82 createSurface(mClient, "ColorLayer", 0 /* buffer width */, 0 /* buffer height */,
83 PIXEL_FORMAT_RGBA_8888, ISurfaceComposerClient::eFXSurfaceEffect);
84 ASSERT_TRUE(mColorLayer != nullptr);
85 ASSERT_TRUE(mColorLayer->isValid());
86 asTransaction([&](Transaction& t) {
87 t.setLayerStack(mColorLayer, layerStack);
88 t.setCrop(mColorLayer, Rect(0, 0, 30, 40));
89 t.setLayer(mColorLayer, INT32_MAX - 2);
90 t.setColor(mColorLayer,
91 half3{mExpectedColor.r / 255.0f, mExpectedColor.g / 255.0f,
92 mExpectedColor.b / 255.0f});
93 t.show(mColorLayer);
94 });
95 }
96
97 ui::DisplayState mMainDisplayState;
98 ui::DisplayMode mMainDisplayMode;
99 sp<IBinder> mMainDisplay;
100 PhysicalDisplayId mMainDisplayId;
101 sp<IBinder> mVirtualDisplay;
102 sp<IGraphicBufferConsumer> mConsumer;
103 sp<IGraphicBufferProducer> mProducer;
104 sp<SurfaceControl> mColorLayer;
105 Color mExpectedColor = {63, 63, 195, 255};
106 };
107
TEST_F(MultiDisplayTest,RenderLayerInVirtualDisplay)108 TEST_F(MultiDisplayTest, RenderLayerInVirtualDisplay) {
109 constexpr ui::LayerStack kLayerStack{1u};
110 createDisplay(mMainDisplayState.layerStackSpaceRect, kLayerStack);
111 createColorLayer(kLayerStack);
112
113 asTransaction([&](Transaction& t) { t.setPosition(mColorLayer, 10, 10); });
114
115 // Verify color layer does not render on main display.
116 std::unique_ptr<ScreenCapture> sc;
117 ScreenCapture::captureScreen(&sc, mMainDisplay);
118 sc->expectColor(Rect(10, 10, 40, 50), {0, 0, 0, 255});
119 sc->expectColor(Rect(0, 0, 9, 9), {0, 0, 0, 255});
120
121 // Verify color layer renders correctly on virtual display.
122 ScreenCapture::captureScreen(&sc, mVirtualDisplay);
123 sc->expectColor(Rect(10, 10, 40, 50), mExpectedColor);
124 sc->expectColor(Rect(1, 1, 9, 9), {0, 0, 0, 255});
125 }
126
TEST_F(MultiDisplayTest,RenderLayerInMirroredVirtualDisplay)127 TEST_F(MultiDisplayTest, RenderLayerInMirroredVirtualDisplay) {
128 // Create a display and set its layer stack to the main display's layer stack so
129 // the contents of the main display are mirrored on to the virtual display.
130
131 // Assumption here is that the new mirrored display has the same layer stack rect as the
132 // primary display that it is mirroring.
133 createDisplay(mMainDisplayState.layerStackSpaceRect, ui::DEFAULT_LAYER_STACK);
134 createColorLayer(ui::DEFAULT_LAYER_STACK);
135
136 sp<SurfaceControl> mirrorSc =
137 SurfaceComposerClient::getDefault()->mirrorDisplay(mMainDisplayId);
138
139 asTransaction([&](Transaction& t) { t.setPosition(mColorLayer, 10, 10); });
140
141 // Verify color layer renders correctly on main display and it is mirrored on the
142 // virtual display.
143 std::unique_ptr<ScreenCapture> sc;
144 ScreenCapture::captureScreen(&sc, mMainDisplay);
145 sc->expectColor(Rect(10, 10, 40, 50), mExpectedColor);
146 sc->expectColor(Rect(0, 0, 9, 9), {0, 0, 0, 255});
147
148 ScreenCapture::captureScreen(&sc, mVirtualDisplay);
149 sc->expectColor(Rect(10, 10, 40, 50), mExpectedColor);
150 sc->expectColor(Rect(0, 0, 9, 9), {0, 0, 0, 255});
151 }
152
TEST_F(MultiDisplayTest,RenderLayerWithPromisedFenceInMirroredVirtualDisplay)153 TEST_F(MultiDisplayTest, RenderLayerWithPromisedFenceInMirroredVirtualDisplay) {
154 // Create a display and use a unique layerstack ID for mirrorDisplay() so
155 // the contents of the main display are mirrored on to the virtual display.
156
157 // A unique layerstack ID must be used because sharing the same layerFE
158 // with more than one display is unsupported. A unique layerstack ensures
159 // that a different layerFE is used between displays.
160 constexpr ui::LayerStack layerStack{77687666}; // ASCII for MDLB (MultiDisplayLayerBounds)
161 createDisplay(mMainDisplayState.layerStackSpaceRect, layerStack);
162 createColorLayer(ui::DEFAULT_LAYER_STACK);
163
164 sp<SurfaceControl> mirrorSc =
165 SurfaceComposerClient::getDefault()->mirrorDisplay(mMainDisplayId);
166
167 asTransaction([&](Transaction& t) {
168 t.setPosition(mColorLayer, 10, 10);
169 t.setLayerStack(mirrorSc, layerStack);
170 });
171
172 // Verify color layer renders correctly on main display and it is mirrored on the
173 // virtual display.
174 std::unique_ptr<ScreenCapture> sc;
175 ScreenCapture::captureScreen(&sc, mMainDisplay);
176 sc->expectColor(Rect(10, 10, 40, 50), mExpectedColor);
177 sc->expectColor(Rect(0, 0, 9, 9), {0, 0, 0, 255});
178
179 ScreenCapture::captureScreen(&sc, mVirtualDisplay);
180 sc->expectColor(Rect(10, 10, 40, 50), mExpectedColor);
181 sc->expectColor(Rect(0, 0, 9, 9), {0, 0, 0, 255});
182 }
183
184 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
TEST_F(MultiDisplayTest,rejectDuplicateLayerStacks)185 TEST_F(MultiDisplayTest, rejectDuplicateLayerStacks) {
186 if (!FlagManager::getInstance().reject_dupe_layerstacks()) return;
187
188 // Setup
189 sp<CpuConsumer> cpuConsumer1 = sp<CpuConsumer>::make(static_cast<size_t>(1));
190 cpuConsumer1->setName(String8("consumer 1"));
191 cpuConsumer1->setDefaultBufferSize(100, 100);
192 sp<IGraphicBufferProducer> cpuProducer1 =
193 cpuConsumer1->getSurface()->getIGraphicBufferProducer();
194 CpuConsumer::LockedBuffer buffer1;
195
196 sp<CpuConsumer> cpuConsumer2 = sp<CpuConsumer>::make(static_cast<size_t>(1));
197 cpuConsumer2->setName(String8("consumer 2"));
198 cpuConsumer2->setDefaultBufferSize(100, 100);
199 sp<IGraphicBufferProducer> cpuProducer2 =
200 cpuConsumer2->getSurface()->getIGraphicBufferProducer();
201 CpuConsumer::LockedBuffer buffer2;
202
203 SurfaceComposerClient::Transaction t;
204 constexpr ui::LayerStack layerStack = {123u};
205 createColorLayer(layerStack);
206
207 static const std::string kDisplayName1("VirtualDisplay1 - rejectDuplicateLayerStacks");
208 sp<IBinder> virtualDisplay1 =
209 SurfaceComposerClient::createVirtualDisplay(kDisplayName1, false /*isSecure*/);
210
211 t.setDisplaySurface(virtualDisplay1, cpuProducer1);
212 t.setDisplayLayerStack(virtualDisplay1, layerStack);
213 t.apply(true);
214
215 static const std::string kDisplayName2("VirtualDisplay2 - rejectDuplicateLayerStacks");
216 sp<IBinder> virtualDisplay2 =
217 SurfaceComposerClient::createVirtualDisplay(kDisplayName2, false /*isSecure*/);
218
219 t.setDisplaySurface(virtualDisplay2, cpuProducer2);
220 t.setDisplayLayerStack(virtualDisplay2, layerStack);
221 t.apply(true);
222
223 // The second consumer will not be able to lock a buffer because
224 // the duplicate layer stack should be rejected.
225 ASSERT_EQ(NO_ERROR, cpuConsumer1->lockNextBuffer(&buffer1));
226 ASSERT_NE(NO_ERROR, cpuConsumer2->lockNextBuffer(&buffer2));
227 }
228 #endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
229 } // namespace android
230
231 // TODO(b/129481165): remove the #pragma below and fix conversion issues
232 #pragma clang diagnostic pop // ignored "-Wconversion"
233