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 <gui/BufferItemConsumer.h>
22 #include <ui/Transform.h>
23 #include <thread>
24 #include "TransactionTestHarnesses.h"
25 namespace android {
26
27 using android::hardware::graphics::common::V1_1::BufferUsage;
28
29 ::testing::Environment* const binderEnv =
30 ::testing::AddGlobalTestEnvironment(new BinderEnvironment());
31
32 class LayerRenderTypeTransactionTest : public LayerTransactionTest,
33 public ::testing::WithParamInterface<RenderPath> {
34 public:
LayerRenderTypeTransactionTest()35 LayerRenderTypeTransactionTest() : mHarness(LayerRenderPathTestHarness(this, GetParam())) {}
36
getScreenCapture()37 std::unique_ptr<ScreenCapture> getScreenCapture() { return mHarness.getScreenCapture(); }
38 void setRelativeZBasicHelper(uint32_t layerType);
39 void setRelativeZGroupHelper(uint32_t layerType);
40 void setAlphaBasicHelper(uint32_t layerType);
41 void setBackgroundColorHelper(uint32_t layerType, bool priorColor, bool bufferFill, float alpha,
42 Color finalColor);
43
44 protected:
45 LayerRenderPathTestHarness mHarness;
46
47 static constexpr int64_t kUsageFlags = BufferUsage::CPU_READ_OFTEN |
48 BufferUsage::CPU_WRITE_OFTEN | BufferUsage::COMPOSER_OVERLAY | BufferUsage::GPU_TEXTURE;
49 };
50
51 INSTANTIATE_TEST_CASE_P(LayerRenderTypeTransactionTests, LayerRenderTypeTransactionTest,
52 ::testing::Values(RenderPath::VIRTUAL_DISPLAY, RenderPath::SCREENSHOT));
53
TEST_P(LayerRenderTypeTransactionTest,SetPositionBasic_BufferQueue)54 TEST_P(LayerRenderTypeTransactionTest, SetPositionBasic_BufferQueue) {
55 sp<SurfaceControl> layer;
56 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
57 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
58
59 {
60 SCOPED_TRACE("default position");
61 const Rect rect(0, 0, 32, 32);
62 auto shot = getScreenCapture();
63 shot->expectColor(rect, Color::RED);
64 shot->expectBorder(rect, Color::BLACK);
65 }
66
67 Transaction().setPosition(layer, 5, 10).apply();
68 {
69 SCOPED_TRACE("new position");
70 const Rect rect(5, 10, 37, 42);
71 auto shot = getScreenCapture();
72 shot->expectColor(rect, Color::RED);
73 shot->expectBorder(rect, Color::BLACK);
74 }
75 }
76
TEST_P(LayerRenderTypeTransactionTest,SetPositionRounding_BufferQueue)77 TEST_P(LayerRenderTypeTransactionTest, SetPositionRounding_BufferQueue) {
78 sp<SurfaceControl> layer;
79 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
80 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
81
82 // GPU composition requires only 4 bits of subpixel precision during rasterization
83 // XXX GPU composition does not match HWC composition due to precision
84 // loss (b/69315223)
85 const float epsilon = 1.0f / 16.0f;
86 Transaction().setPosition(layer, 0.5f - epsilon, 0.5f - epsilon).apply();
87 {
88 SCOPED_TRACE("rounding down");
89 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
90 }
91
92 Transaction().setPosition(layer, 0.5f + epsilon, 0.5f + epsilon).apply();
93 {
94 SCOPED_TRACE("rounding up");
95 getScreenCapture()->expectColor(Rect(1, 1, 33, 33), Color::RED);
96 }
97 }
98
TEST_P(LayerRenderTypeTransactionTest,SetPositionOutOfBounds_BufferQueue)99 TEST_P(LayerRenderTypeTransactionTest, SetPositionOutOfBounds_BufferQueue) {
100 sp<SurfaceControl> layer;
101 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
102 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
103
104 Transaction().setPosition(layer, -32, -32).apply();
105 {
106 SCOPED_TRACE("negative coordinates");
107 getScreenCapture()->expectColor(mDisplayRect, Color::BLACK);
108 }
109
110 Transaction().setPosition(layer, mDisplayWidth, mDisplayHeight).apply();
111 {
112 SCOPED_TRACE("positive coordinates");
113 getScreenCapture()->expectColor(mDisplayRect, Color::BLACK);
114 }
115 }
116
TEST_P(LayerRenderTypeTransactionTest,SetPositionPartiallyOutOfBounds_BufferQueue)117 TEST_P(LayerRenderTypeTransactionTest, SetPositionPartiallyOutOfBounds_BufferQueue) {
118 sp<SurfaceControl> layer;
119 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
120 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
121
122 // partially out of bounds
123 Transaction().setPosition(layer, -30, -30).apply();
124 {
125 SCOPED_TRACE("negative coordinates");
126 getScreenCapture()->expectColor(Rect(0, 0, 2, 2), Color::RED);
127 }
128
129 Transaction().setPosition(layer, mDisplayWidth - 2, mDisplayHeight - 2).apply();
130 {
131 SCOPED_TRACE("positive coordinates");
132 getScreenCapture()->expectColor(Rect(mDisplayWidth - 2, mDisplayHeight - 2, mDisplayWidth,
133 mDisplayHeight),
134 Color::RED);
135 }
136 }
137
TEST_P(LayerRenderTypeTransactionTest,CreateLayer_BufferState)138 TEST_P(LayerRenderTypeTransactionTest, CreateLayer_BufferState) {
139 uint32_t transformHint = ui::Transform::ROT_INVALID;
140 sp<SurfaceControl> layer;
141 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32,
142 ISurfaceComposerClient::eFXSurfaceBufferState,
143 /*parent*/ nullptr, &transformHint));
144 ASSERT_NE(ui::Transform::ROT_INVALID, transformHint);
145 }
146
setRelativeZBasicHelper(uint32_t layerType)147 void LayerRenderTypeTransactionTest::setRelativeZBasicHelper(uint32_t layerType) {
148 sp<SurfaceControl> layerR;
149 sp<SurfaceControl> layerG;
150 ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32, layerType));
151 ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerR, Color::RED, 32, 32));
152 ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test G", 32, 32, layerType));
153 ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerG, Color::GREEN, 32, 32));
154
155 switch (layerType) {
156 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
157 Transaction().setPosition(layerG, 16, 16).setRelativeLayer(layerG, layerR, 1).apply();
158 break;
159 case ISurfaceComposerClient::eFXSurfaceBufferState:
160 Transaction().setPosition(layerG, 16, 16).setRelativeLayer(layerG, layerR, 1).apply();
161 break;
162 default:
163 ASSERT_FALSE(true) << "Unsupported layer type";
164 }
165 {
166 SCOPED_TRACE("layerG above");
167 auto shot = getScreenCapture();
168 shot->expectColor(Rect(0, 0, 16, 16), Color::RED);
169 shot->expectColor(Rect(16, 16, 48, 48), Color::GREEN);
170 }
171
172 Transaction().setRelativeLayer(layerG, layerR, -1).apply();
173 {
174 SCOPED_TRACE("layerG below");
175 auto shot = getScreenCapture();
176 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
177 shot->expectColor(Rect(32, 32, 48, 48), Color::GREEN);
178 }
179 }
180
TEST_P(LayerRenderTypeTransactionTest,SetRelativeZBasic_BufferQueue)181 TEST_P(LayerRenderTypeTransactionTest, SetRelativeZBasic_BufferQueue) {
182 ASSERT_NO_FATAL_FAILURE(setRelativeZBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
183 }
184
TEST_P(LayerRenderTypeTransactionTest,SetRelativeZBasic_BufferState)185 TEST_P(LayerRenderTypeTransactionTest, SetRelativeZBasic_BufferState) {
186 ASSERT_NO_FATAL_FAILURE(setRelativeZBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
187 }
188
setRelativeZGroupHelper(uint32_t layerType)189 void LayerRenderTypeTransactionTest::setRelativeZGroupHelper(uint32_t layerType) {
190 sp<SurfaceControl> layerR;
191 sp<SurfaceControl> layerG;
192 sp<SurfaceControl> layerB;
193 ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test", 32, 32, layerType));
194 ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerR, Color::RED, 32, 32));
195 ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test", 32, 32, layerType));
196 ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerG, Color::GREEN, 32, 32));
197 ASSERT_NO_FATAL_FAILURE(layerB = createLayer("test", 32, 32, layerType));
198 ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerB, Color::BLUE, 32, 32));
199
200 // layerR = 0, layerG = layerR + 3, layerB = 2
201 switch (layerType) {
202 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
203 Transaction()
204 .setPosition(layerG, 8, 8)
205 .setRelativeLayer(layerG, layerR, 3)
206 .setPosition(layerB, 16, 16)
207 .setLayer(layerB, mLayerZBase + 2)
208 .apply();
209 break;
210 case ISurfaceComposerClient::eFXSurfaceBufferState:
211 Transaction()
212 .setPosition(layerG, 8, 8)
213 .setRelativeLayer(layerG, layerR, 3)
214 .setPosition(layerB, 16, 16)
215 .setLayer(layerB, mLayerZBase + 2)
216 .apply();
217 break;
218 default:
219 ASSERT_FALSE(true) << "Unsupported layer type";
220 }
221
222 {
223 SCOPED_TRACE("(layerR < layerG) < layerB");
224 auto shot = getScreenCapture();
225 shot->expectColor(Rect(0, 0, 8, 8), Color::RED);
226 shot->expectColor(Rect(8, 8, 16, 16), Color::GREEN);
227 shot->expectColor(Rect(16, 16, 48, 48), Color::BLUE);
228 }
229
230 // layerR = 4, layerG = layerR + 3, layerB = 2
231 Transaction().setLayer(layerR, mLayerZBase + 4).apply();
232 {
233 SCOPED_TRACE("layerB < (layerR < layerG)");
234 auto shot = getScreenCapture();
235 shot->expectColor(Rect(0, 0, 8, 8), Color::RED);
236 shot->expectColor(Rect(8, 8, 40, 40), Color::GREEN);
237 shot->expectColor(Rect(40, 40, 48, 48), Color::BLUE);
238 }
239
240 // layerR = 4, layerG = layerR - 3, layerB = 2
241 Transaction().setRelativeLayer(layerG, layerR, -3).apply();
242 {
243 SCOPED_TRACE("layerB < (layerG < layerR)");
244 auto shot = getScreenCapture();
245 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
246 shot->expectColor(Rect(32, 32, 40, 40), Color::GREEN);
247 shot->expectColor(Rect(40, 40, 48, 48), Color::BLUE);
248 }
249
250 // restore to absolute z
251 // layerR = 4, layerG = 0, layerB = 2
252 Transaction().setLayer(layerG, mLayerZBase).apply();
253 {
254 SCOPED_TRACE("layerG < layerB < layerR");
255 auto shot = getScreenCapture();
256 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
257 shot->expectColor(Rect(32, 32, 48, 48), Color::BLUE);
258 }
259
260 // layerR should not affect layerG anymore
261 // layerR = 1, layerG = 0, layerB = 2
262 Transaction().setLayer(layerR, mLayerZBase + 1).apply();
263 {
264 SCOPED_TRACE("layerG < layerR < layerB");
265 auto shot = getScreenCapture();
266 shot->expectColor(Rect(0, 0, 16, 16), Color::RED);
267 shot->expectColor(Rect(16, 16, 48, 48), Color::BLUE);
268 }
269 }
270
TEST_P(LayerRenderTypeTransactionTest,SetRelativeZGroup_BufferQueue)271 TEST_P(LayerRenderTypeTransactionTest, SetRelativeZGroup_BufferQueue) {
272 ASSERT_NO_FATAL_FAILURE(setRelativeZGroupHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
273 }
274
TEST_P(LayerRenderTypeTransactionTest,SetRelativeZGroup_BufferState)275 TEST_P(LayerRenderTypeTransactionTest, SetRelativeZGroup_BufferState) {
276 ASSERT_NO_FATAL_FAILURE(setRelativeZGroupHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
277 }
278
TEST_P(LayerRenderTypeTransactionTest,SetTransparentRegionHintBasic_BufferQueue)279 TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintBasic_BufferQueue) {
280 const Rect top(0, 0, 32, 16);
281 const Rect bottom(0, 16, 32, 32);
282 sp<SurfaceControl> layer;
283 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
284
285 ANativeWindow_Buffer buffer;
286 ASSERT_NO_FATAL_FAILURE(buffer = getBufferQueueLayerBuffer(layer));
287 ASSERT_NO_FATAL_FAILURE(
288 TransactionUtils::fillANativeWindowBufferColor(buffer, top, Color::TRANSPARENT));
289 ASSERT_NO_FATAL_FAILURE(
290 TransactionUtils::fillANativeWindowBufferColor(buffer, bottom, Color::RED));
291 // setTransparentRegionHint always applies to the following buffer
292 Transaction().setTransparentRegionHint(layer, Region(top)).apply();
293 ASSERT_NO_FATAL_FAILURE(postBufferQueueLayerBuffer(layer));
294 {
295 SCOPED_TRACE("top transparent");
296 auto shot = getScreenCapture();
297 shot->expectColor(top, Color::BLACK);
298 shot->expectColor(bottom, Color::RED);
299 }
300
301 Transaction().setTransparentRegionHint(layer, Region(bottom)).apply();
302 {
303 SCOPED_TRACE("transparent region hint pending");
304 auto shot = getScreenCapture();
305 shot->expectColor(top, Color::BLACK);
306 shot->expectColor(bottom, Color::RED);
307 }
308
309 ASSERT_NO_FATAL_FAILURE(buffer = getBufferQueueLayerBuffer(layer));
310 ASSERT_NO_FATAL_FAILURE(
311 TransactionUtils::fillANativeWindowBufferColor(buffer, top, Color::RED));
312 ASSERT_NO_FATAL_FAILURE(
313 TransactionUtils::fillANativeWindowBufferColor(buffer, bottom, Color::TRANSPARENT));
314 ASSERT_NO_FATAL_FAILURE(postBufferQueueLayerBuffer(layer));
315 {
316 SCOPED_TRACE("bottom transparent");
317 auto shot = getScreenCapture();
318 shot->expectColor(top, Color::RED);
319 shot->expectColor(bottom, Color::BLACK);
320 }
321 }
322
TEST_P(LayerRenderTypeTransactionTest,SetTransparentRegionHintBasic_BufferState)323 TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintBasic_BufferState) {
324 const Rect top(0, 0, 32, 16);
325 const Rect bottom(0, 16, 32, 32);
326 sp<SurfaceControl> layer;
327 ASSERT_NO_FATAL_FAILURE(
328 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
329
330 sp<GraphicBuffer> buffer =
331 sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
332
333 ASSERT_NO_FATAL_FAILURE(
334 TransactionUtils::fillGraphicBufferColor(buffer, top, Color::TRANSPARENT));
335 ASSERT_NO_FATAL_FAILURE(TransactionUtils::fillGraphicBufferColor(buffer, bottom, Color::RED));
336 Transaction()
337 .setTransparentRegionHint(layer, Region(top))
338 .setBuffer(layer, buffer)
339 .apply();
340 {
341 SCOPED_TRACE("top transparent");
342 auto shot = getScreenCapture();
343 shot->expectColor(top, Color::BLACK);
344 shot->expectColor(bottom, Color::RED);
345 }
346
347 Transaction().setTransparentRegionHint(layer, Region(bottom)).apply();
348 {
349 SCOPED_TRACE("transparent region hint intermediate");
350 auto shot = getScreenCapture();
351 shot->expectColor(top, Color::BLACK);
352 shot->expectColor(bottom, Color::BLACK);
353 }
354
355 buffer = sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
356
357 ASSERT_NO_FATAL_FAILURE(TransactionUtils::fillGraphicBufferColor(buffer, top, Color::RED));
358 ASSERT_NO_FATAL_FAILURE(
359 TransactionUtils::fillGraphicBufferColor(buffer, bottom, Color::TRANSPARENT));
360 Transaction().setBuffer(layer, buffer).apply();
361 {
362 SCOPED_TRACE("bottom transparent");
363 auto shot = getScreenCapture();
364 shot->expectColor(top, Color::RED);
365 shot->expectColor(bottom, Color::BLACK);
366 }
367 }
368
TEST_P(LayerRenderTypeTransactionTest,SetTransparentRegionHintOutOfBounds_BufferQueue)369 TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintOutOfBounds_BufferQueue) {
370 sp<SurfaceControl> layerTransparent;
371 sp<SurfaceControl> layerR;
372 ASSERT_NO_FATAL_FAILURE(layerTransparent = createLayer("test transparent", 32, 32));
373 ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32));
374
375 // check that transparent region hint is bound by the layer size
376 Transaction()
377 .setTransparentRegionHint(layerTransparent, Region(mDisplayRect))
378 .setPosition(layerR, 16, 16)
379 .setLayer(layerR, mLayerZBase + 1)
380 .apply();
381 ASSERT_NO_FATAL_FAILURE(
382 fillBufferQueueLayerColor(layerTransparent, Color::TRANSPARENT, 32, 32));
383 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layerR, Color::RED, 32, 32));
384 getScreenCapture()->expectColor(Rect(16, 16, 48, 48), Color::RED);
385 }
386
TEST_P(LayerRenderTypeTransactionTest,SetTransparentRegionHintOutOfBounds_BufferState)387 TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintOutOfBounds_BufferState) {
388 sp<SurfaceControl> layerTransparent;
389 sp<SurfaceControl> layerR;
390 ASSERT_NO_FATAL_FAILURE(layerTransparent = createLayer("test transparent", 32, 32));
391 ASSERT_NO_FATAL_FAILURE(
392 layerR = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
393
394 // check that transparent region hint is bound by the layer size
395 Transaction()
396 .setTransparentRegionHint(layerTransparent, Region(mDisplayRect))
397 .setPosition(layerR, 16, 16)
398 .setLayer(layerR, mLayerZBase + 1)
399 .apply();
400 ASSERT_NO_FATAL_FAILURE(
401 fillBufferQueueLayerColor(layerTransparent, Color::TRANSPARENT, 32, 32));
402 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layerR, Color::RED, 32, 32));
403 getScreenCapture()->expectColor(Rect(16, 16, 48, 48), Color::RED);
404 }
405
setAlphaBasicHelper(uint32_t layerType)406 void LayerRenderTypeTransactionTest::setAlphaBasicHelper(uint32_t layerType) {
407 sp<SurfaceControl> layer1;
408 sp<SurfaceControl> layer2;
409 ASSERT_NO_FATAL_FAILURE(layer1 = createLayer("test 1", 32, 32, layerType));
410 ASSERT_NO_FATAL_FAILURE(layer2 = createLayer("test 2", 32, 32, layerType));
411 ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layer1, {64, 0, 0, 255}, 32, 32));
412 ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layer2, {0, 64, 0, 255}, 32, 32));
413
414 switch (layerType) {
415 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
416 Transaction()
417 .setAlpha(layer1, 0.25f)
418 .setAlpha(layer2, 0.75f)
419 .setPosition(layer2, 16, 0)
420 .setLayer(layer2, mLayerZBase + 1)
421 .apply();
422 break;
423 case ISurfaceComposerClient::eFXSurfaceBufferState:
424 Transaction()
425 .setAlpha(layer1, 0.25f)
426 .setAlpha(layer2, 0.75f)
427 .setPosition(layer2, 16, 0)
428 .setLayer(layer2, mLayerZBase + 1)
429 .apply();
430 break;
431 default:
432 ASSERT_FALSE(true) << "Unsupported layer type";
433 }
434 {
435 auto shot = getScreenCapture();
436 uint8_t r = 16; // 64 * 0.25f
437 uint8_t g = 48; // 64 * 0.75f
438 shot->expectColor(Rect(0, 0, 16, 32), {r, 0, 0, 255});
439 shot->expectColor(Rect(32, 0, 48, 32), {0, g, 0, 255});
440
441 r /= 4; // r * (1.0f - 0.75f)
442 shot->expectColor(Rect(16, 0, 32, 32), {r, g, 0, 255});
443 }
444 }
445
TEST_P(LayerRenderTypeTransactionTest,SetAlphaBasic_BufferQueue)446 TEST_P(LayerRenderTypeTransactionTest, SetAlphaBasic_BufferQueue) {
447 ASSERT_NO_FATAL_FAILURE(setAlphaBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
448 }
449
TEST_P(LayerRenderTypeTransactionTest,SetAlphaBasic_BufferState)450 TEST_P(LayerRenderTypeTransactionTest, SetAlphaBasic_BufferState) {
451 ASSERT_NO_FATAL_FAILURE(setAlphaBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
452 }
453
TEST_P(LayerRenderTypeTransactionTest,SetColorBasic)454 TEST_P(LayerRenderTypeTransactionTest, SetColorBasic) {
455 sp<SurfaceControl> bufferLayer;
456 sp<SurfaceControl> colorLayer;
457 ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
458 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
459 ASSERT_NO_FATAL_FAILURE(colorLayer =
460 createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
461 ISurfaceComposerClient::eFXSurfaceEffect));
462
463 Transaction()
464 .setCrop(colorLayer, Rect(0, 0, 32, 32))
465 .setLayer(colorLayer, mLayerZBase + 1)
466 .apply();
467
468 {
469 SCOPED_TRACE("default color");
470 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
471 }
472
473 const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
474 const Color expected = {15, 51, 85, 255};
475 // this is handwavy, but the precison loss scaled by 255 (8-bit per
476 // channel) should be less than one
477 const uint8_t tolerance = 1;
478 Transaction().setColor(colorLayer, color).apply();
479 {
480 SCOPED_TRACE("new color");
481 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expected, tolerance);
482 }
483 }
484
485 // RED: Color layer base color and Layer buffer fill
486 // BLUE: prior background color
487 // GREEN: final background color
488 // BLACK: no color or fill
setBackgroundColorHelper(uint32_t layerType,bool priorColor,bool bufferFill,float alpha,Color finalColor)489 void LayerRenderTypeTransactionTest::setBackgroundColorHelper(uint32_t layerType, bool priorColor,
490 bool bufferFill, float alpha,
491 Color finalColor) {
492 sp<SurfaceControl> layer;
493 int32_t width = 500;
494 int32_t height = 500;
495
496 Color fillColor = Color::RED;
497 Color priorBgColor = Color::BLUE;
498 Color expectedColor = Color::BLACK;
499 switch (layerType) {
500 case ISurfaceComposerClient::eFXSurfaceEffect:
501 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 0, 0, layerType));
502 Transaction()
503 .setCrop(layer, Rect(0, 0, width, height))
504 .setColor(layer, half3(1.0f, 0, 0))
505 .apply();
506 expectedColor = fillColor;
507 break;
508 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
509 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", width, height));
510 if (bufferFill) {
511 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, fillColor, width, height));
512 expectedColor = fillColor;
513 }
514 Transaction().setCrop(layer, Rect(0, 0, width, height)).apply();
515 break;
516 case ISurfaceComposerClient::eFXSurfaceBufferState:
517 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", width, height, layerType));
518 if (bufferFill) {
519 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, fillColor, width, height));
520 expectedColor = fillColor;
521 }
522 Transaction().setCrop(layer, Rect(0, 0, width, height)).apply();
523 break;
524 default:
525 GTEST_FAIL() << "Unknown layer type in setBackgroundColorHelper";
526 return;
527 }
528
529 if (priorColor && layerType != ISurfaceComposerClient::eFXSurfaceEffect) {
530 Transaction()
531 .setBackgroundColor(layer, half3(0, 0, 1.0f), 1.0f, ui::Dataspace::UNKNOWN)
532 .apply();
533 if (!bufferFill) {
534 expectedColor = priorBgColor;
535 }
536 }
537
538 {
539 SCOPED_TRACE("default before setting background color layer");
540 screenshot()->expectColor(Rect(0, 0, width, height), expectedColor);
541 }
542 Transaction()
543 .setBackgroundColor(layer, half3(0, 1.0f, 0), alpha, ui::Dataspace::UNKNOWN)
544 .apply();
545
546 {
547 SCOPED_TRACE("final color");
548 auto shot = screenshot();
549 shot->expectColor(Rect(0, 0, width, height), finalColor);
550 shot->expectBorder(Rect(0, 0, width, height), Color::BLACK);
551 }
552 }
553
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_Color_NoEffect)554 TEST_P(LayerRenderTypeTransactionTest, SetBackgroundColor_Color_NoEffect) {
555 bool priorColor = false;
556 bool bufferFill = false;
557 float alpha = 1.0f;
558 Color finalColor = Color::RED;
559 ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceEffect,
560 priorColor, bufferFill, alpha, finalColor));
561 }
562
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferQueue_NoPriorColor_ZeroAlpha_NoEffect)563 TEST_P(LayerRenderTypeTransactionTest,
564 SetBackgroundColor_BufferQueue_NoPriorColor_ZeroAlpha_NoEffect) {
565 bool priorColor = false;
566 bool bufferFill = false;
567 float alpha = 0;
568 Color finalColor = Color::BLACK;
569 ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
570 priorColor, bufferFill, alpha, finalColor));
571 }
572
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferQueue_PriorColor_ZeroAlpha_DeleteBackground)573 TEST_P(LayerRenderTypeTransactionTest,
574 SetBackgroundColor_BufferQueue_PriorColor_ZeroAlpha_DeleteBackground) {
575 bool priorColor = true;
576 bool bufferFill = false;
577 float alpha = 0;
578 Color finalColor = Color::BLACK;
579 ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
580 priorColor, bufferFill, alpha, finalColor));
581 }
582
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_BufferFill_NoPriorColor_Basic)583 TEST_P(LayerRenderTypeTransactionTest,
584 SetBackgroundColor_BufferState_BufferFill_NoPriorColor_Basic) {
585 bool priorColor = false;
586 bool bufferFill = true;
587 float alpha = 1.0f;
588 Color finalColor = Color::RED;
589 ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
590 priorColor, bufferFill, alpha, finalColor));
591 }
592
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_NoBufferFill_NoPriorColor_Basic)593 TEST_P(LayerRenderTypeTransactionTest,
594 SetBackgroundColor_BufferState_NoBufferFill_NoPriorColor_Basic) {
595 bool priorColor = false;
596 bool bufferFill = false;
597 float alpha = 1.0f;
598 Color finalColor = Color::GREEN;
599 ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
600 priorColor, bufferFill, alpha, finalColor));
601 }
602
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_NoBufferFill_PriorColor_Basic)603 TEST_P(LayerRenderTypeTransactionTest,
604 SetBackgroundColor_BufferState_NoBufferFill_PriorColor_Basic) {
605 bool priorColor = true;
606 bool bufferFill = false;
607 float alpha = 1.0f;
608 Color finalColor = Color::GREEN;
609 ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
610 priorColor, bufferFill, alpha, finalColor));
611 }
612
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_NoPriorColor_ZeroAlpha_NoEffect)613 TEST_P(LayerRenderTypeTransactionTest,
614 SetBackgroundColor_BufferState_NoPriorColor_ZeroAlpha_NoEffect) {
615 bool priorColor = false;
616 bool bufferFill = false;
617 float alpha = 0;
618 Color finalColor = Color::BLACK;
619 ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
620 priorColor, bufferFill, alpha, finalColor));
621 }
622
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_PriorColor_ZeroAlpha_DeleteBackground)623 TEST_P(LayerRenderTypeTransactionTest,
624 SetBackgroundColor_BufferState_PriorColor_ZeroAlpha_DeleteBackground) {
625 bool priorColor = true;
626 bool bufferFill = false;
627 float alpha = 0;
628 Color finalColor = Color::BLACK;
629 ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
630 priorColor, bufferFill, alpha, finalColor));
631 }
632
TEST_P(LayerRenderTypeTransactionTest,SetColorClamped)633 TEST_P(LayerRenderTypeTransactionTest, SetColorClamped) {
634 sp<SurfaceControl> colorLayer;
635 ASSERT_NO_FATAL_FAILURE(colorLayer =
636 createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
637 ISurfaceComposerClient::eFXSurfaceEffect));
638 Transaction()
639 .setCrop(colorLayer, Rect(0, 0, 32, 32))
640 .setColor(colorLayer, half3(2.0f, 0.0f, 0.0f))
641 .apply();
642
643 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
644 }
645
646 // An invalid color will not render a color and the layer will not be visible.
TEST_P(LayerRenderTypeTransactionTest,SetInvalidColor)647 TEST_P(LayerRenderTypeTransactionTest, SetInvalidColor) {
648 sp<SurfaceControl> colorLayer;
649 ASSERT_NO_FATAL_FAILURE(colorLayer =
650 createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
651 ISurfaceComposerClient::eFXSurfaceEffect));
652 Transaction()
653 .setCrop(colorLayer, Rect(0, 0, 32, 32))
654 .setColor(colorLayer, half3(1.0f, -1.0f, 0.5f))
655 .apply();
656
657 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
658 }
659
TEST_P(LayerRenderTypeTransactionTest,SetColorWithAlpha)660 TEST_P(LayerRenderTypeTransactionTest, SetColorWithAlpha) {
661 sp<SurfaceControl> bufferLayer;
662 sp<SurfaceControl> colorLayer;
663 ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
664 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
665 ASSERT_NO_FATAL_FAILURE(colorLayer =
666 createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
667 ISurfaceComposerClient::eFXSurfaceEffect));
668 Transaction().setCrop(colorLayer, Rect(0, 0, 32, 32)).apply();
669
670 const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
671 const float alpha = 0.25f;
672 const ubyte3 expected((vec3(color) * alpha + vec3(1.0f, 0.0f, 0.0f) * (1.0f - alpha)) * 255.0f);
673 // this is handwavy, but the precison loss scaled by 255 (8-bit per
674 // channel) should be less than one
675 const uint8_t tolerance = 1;
676 Transaction()
677 .setColor(colorLayer, color)
678 .setAlpha(colorLayer, alpha)
679 .setLayer(colorLayer, mLayerZBase + 1)
680 .apply();
681 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), {expected.r, expected.g, expected.b, 255},
682 tolerance);
683 }
684
TEST_P(LayerRenderTypeTransactionTest,SetColorWithParentAlpha_Bug74220420)685 TEST_P(LayerRenderTypeTransactionTest, SetColorWithParentAlpha_Bug74220420) {
686 sp<SurfaceControl> bufferLayer;
687 sp<SurfaceControl> parentLayer;
688 sp<SurfaceControl> colorLayer;
689 ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
690 ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parentWithAlpha", 32, 32));
691 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
692 ASSERT_NO_FATAL_FAILURE(colorLayer = createLayer("childWithColor", 0 /* buffer width */,
693 0 /* buffer height */,
694 ISurfaceComposerClient::eFXSurfaceEffect));
695 Transaction().setCrop(colorLayer, Rect(0, 0, 32, 32)).apply();
696 const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
697 const float alpha = 0.25f;
698 const ubyte3 expected((vec3(color) * alpha + vec3(1.0f, 0.0f, 0.0f) * (1.0f - alpha)) * 255.0f);
699 // this is handwavy, but the precision loss scaled by 255 (8-bit per
700 // channel) should be less than one
701 const uint8_t tolerance = 1;
702 Transaction()
703 .reparent(colorLayer, parentLayer)
704 .setColor(colorLayer, color)
705 .setAlpha(parentLayer, alpha)
706 .setLayer(parentLayer, mLayerZBase + 1)
707 .apply();
708 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), {expected.r, expected.g, expected.b, 255},
709 tolerance);
710 }
711
TEST_P(LayerRenderTypeTransactionTest,SetMatrixBasic_BufferQueue)712 TEST_P(LayerRenderTypeTransactionTest, SetMatrixBasic_BufferQueue) {
713 sp<SurfaceControl> layer;
714 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
715 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
716 Color::BLUE, Color::WHITE));
717
718 Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, 1.0f).setPosition(layer, 0, 0).apply();
719 {
720 SCOPED_TRACE("IDENTITY");
721 getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::RED, Color::GREEN,
722 Color::BLUE, Color::WHITE);
723 }
724
725 Transaction().setMatrix(layer, -1.0f, 0.0f, 0.0f, 1.0f).setPosition(layer, 32, 0).apply();
726 {
727 SCOPED_TRACE("FLIP_H");
728 getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::GREEN, Color::RED,
729 Color::WHITE, Color::BLUE);
730 }
731
732 Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, -1.0f).setPosition(layer, 0, 32).apply();
733 {
734 SCOPED_TRACE("FLIP_V");
735 getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::WHITE,
736 Color::RED, Color::GREEN);
737 }
738
739 Transaction().setMatrix(layer, 0.0f, 1.0f, -1.0f, 0.0f).setPosition(layer, 32, 0).apply();
740 {
741 SCOPED_TRACE("ROT_90");
742 getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::RED,
743 Color::WHITE, Color::GREEN);
744 }
745
746 Transaction().setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f).setPosition(layer, 0, 0).apply();
747 {
748 SCOPED_TRACE("SCALE");
749 getScreenCapture()->expectQuadrant(Rect(0, 0, 64, 64), Color::RED, Color::GREEN,
750 Color::BLUE, Color::WHITE, true /* filtered */);
751 }
752 }
753
TEST_P(LayerRenderTypeTransactionTest,SetMatrixBasic_BufferState)754 TEST_P(LayerRenderTypeTransactionTest, SetMatrixBasic_BufferState) {
755 sp<SurfaceControl> layer;
756 ASSERT_NO_FATAL_FAILURE(
757 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
758 ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
759 Color::BLUE, Color::WHITE));
760
761 Transaction().setPosition(layer, 32, 32).setMatrix(layer, 1.0f, 0.0f, 0.0f, 1.0f).apply();
762 {
763 SCOPED_TRACE("IDENTITY");
764 getScreenCapture()->expectQuadrant(Rect(32, 32, 64, 64), Color::RED, Color::GREEN,
765 Color::BLUE, Color::WHITE);
766 }
767
768 Transaction().setMatrix(layer, -1.0f, 0.0f, 0.0f, 1.0f).apply();
769 {
770 SCOPED_TRACE("FLIP_H");
771 getScreenCapture()->expectQuadrant(Rect(0, 32, 32, 64), Color::GREEN, Color::RED,
772 Color::WHITE, Color::BLUE);
773 }
774
775 Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, -1.0f).apply();
776 {
777 SCOPED_TRACE("FLIP_V");
778 getScreenCapture()->expectQuadrant(Rect(32, 0, 64, 32), Color::BLUE, Color::WHITE,
779 Color::RED, Color::GREEN);
780 }
781
782 Transaction().setMatrix(layer, 0.0f, 1.0f, -1.0f, 0.0f).apply();
783 {
784 SCOPED_TRACE("ROT_90");
785 getScreenCapture()->expectQuadrant(Rect(0, 32, 32, 64), Color::BLUE, Color::RED,
786 Color::WHITE, Color::GREEN);
787 }
788
789 Transaction().setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f).apply();
790 {
791 SCOPED_TRACE("SCALE");
792 getScreenCapture()->expectQuadrant(Rect(32, 32, 96, 96), Color::RED, Color::GREEN,
793 Color::BLUE, Color::WHITE, 1 /* tolerance */);
794 }
795 }
796
TEST_P(LayerRenderTypeTransactionTest,SetMatrixRot45_BufferQueue)797 TEST_P(LayerRenderTypeTransactionTest, SetMatrixRot45_BufferQueue) {
798 sp<SurfaceControl> layer;
799 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
800 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
801 Color::BLUE, Color::WHITE));
802
803 const float rot = M_SQRT1_2; // 45 degrees
804 const float trans = M_SQRT2 * 16.0f;
805 Transaction().setMatrix(layer, rot, rot, -rot, rot).setPosition(layer, trans, 0).apply();
806
807 auto shot = getScreenCapture();
808 // check a 8x8 region inside each color
809 auto get8x8Rect = [](int32_t centerX, int32_t centerY) {
810 const int32_t halfL = 4;
811 return Rect(centerX - halfL, centerY - halfL, centerX + halfL, centerY + halfL);
812 };
813 const int32_t unit = int32_t(trans / 2);
814 shot->expectColor(get8x8Rect(2 * unit, 1 * unit), Color::RED);
815 shot->expectColor(get8x8Rect(3 * unit, 2 * unit), Color::GREEN);
816 shot->expectColor(get8x8Rect(1 * unit, 2 * unit), Color::BLUE);
817 shot->expectColor(get8x8Rect(2 * unit, 3 * unit), Color::WHITE);
818 }
819
TEST_P(LayerRenderTypeTransactionTest,SetCropBasic_BufferQueue)820 TEST_P(LayerRenderTypeTransactionTest, SetCropBasic_BufferQueue) {
821 sp<SurfaceControl> layer;
822 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
823 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
824 const Rect crop(8, 8, 24, 24);
825
826 Transaction().setCrop(layer, crop).apply();
827 auto shot = getScreenCapture();
828 shot->expectColor(crop, Color::RED);
829 shot->expectBorder(crop, Color::BLACK);
830 }
831
TEST_P(LayerRenderTypeTransactionTest,SetCropBasic_BufferState)832 TEST_P(LayerRenderTypeTransactionTest, SetCropBasic_BufferState) {
833 sp<SurfaceControl> layer;
834 ASSERT_NO_FATAL_FAILURE(
835 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
836 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
837 const Rect crop(8, 8, 24, 24);
838
839 Transaction().setCrop(layer, crop).apply();
840 auto shot = getScreenCapture();
841 shot->expectColor(crop, Color::RED);
842 shot->expectBorder(crop, Color::BLACK);
843 }
844
TEST_P(LayerRenderTypeTransactionTest,SetCropEmpty_BufferQueue)845 TEST_P(LayerRenderTypeTransactionTest, SetCropEmpty_BufferQueue) {
846 sp<SurfaceControl> layer;
847 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
848 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
849
850 {
851 SCOPED_TRACE("empty rect");
852 Transaction().setCrop(layer, Rect(8, 8, 8, 8)).apply();
853 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
854 }
855
856 {
857 SCOPED_TRACE("negative rect");
858 Transaction().setCrop(layer, Rect(8, 8, 0, 0)).apply();
859 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
860 }
861 }
862
TEST_P(LayerRenderTypeTransactionTest,SetCropEmpty_BufferState)863 TEST_P(LayerRenderTypeTransactionTest, SetCropEmpty_BufferState) {
864 sp<SurfaceControl> layer;
865 ASSERT_NO_FATAL_FAILURE(
866 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
867 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
868
869 {
870 SCOPED_TRACE("empty rect");
871 Transaction().setCrop(layer, Rect(8, 8, 8, 8)).apply();
872 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
873 }
874
875 {
876 SCOPED_TRACE("negative rect");
877 Transaction().setCrop(layer, Rect(8, 8, 0, 0)).apply();
878 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
879 }
880 }
881
TEST_P(LayerRenderTypeTransactionTest,SetCropOutOfBounds_BufferQueue)882 TEST_P(LayerRenderTypeTransactionTest, SetCropOutOfBounds_BufferQueue) {
883 sp<SurfaceControl> layer;
884 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
885 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
886
887 Transaction().setCrop(layer, Rect(-128, -64, 128, 64)).apply();
888 auto shot = getScreenCapture();
889 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
890 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
891 }
892
TEST_P(LayerRenderTypeTransactionTest,SetCropOutOfBounds_BufferState)893 TEST_P(LayerRenderTypeTransactionTest, SetCropOutOfBounds_BufferState) {
894 sp<SurfaceControl> layer;
895 ASSERT_NO_FATAL_FAILURE(
896 layer = createLayer("test", 32, 64, ISurfaceComposerClient::eFXSurfaceBufferState));
897 sp<GraphicBuffer> buffer =
898 sp<GraphicBuffer>::make(32, 64, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
899 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 16), Color::BLUE);
900 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 16, 32, 64), Color::RED);
901
902 Transaction().setBuffer(layer, buffer).apply();
903
904 // Partially out of bounds in the negative (upper left) direction
905 Transaction().setCrop(layer, Rect(-128, -128, 32, 16)).apply();
906 {
907 SCOPED_TRACE("out of bounds, negative (upper left) direction");
908 auto shot = getScreenCapture();
909 shot->expectColor(Rect(0, 0, 32, 16), Color::BLUE);
910 shot->expectBorder(Rect(0, 0, 32, 16), Color::BLACK);
911 }
912
913 // Partially out of bounds in the positive (lower right) direction
914 Transaction().setCrop(layer, Rect(0, 16, 128, 128)).apply();
915 {
916 SCOPED_TRACE("out of bounds, positive (lower right) direction");
917 auto shot = getScreenCapture();
918 shot->expectColor(Rect(0, 16, 32, 64), Color::RED);
919 shot->expectBorder(Rect(0, 16, 32, 64), Color::BLACK);
920 }
921
922 // Fully out of buffer space bounds
923 Transaction().setCrop(layer, Rect(-128, -128, -1, -1)).apply();
924 {
925 SCOPED_TRACE("Fully out of bounds");
926 auto shot = getScreenCapture();
927 shot->expectColor(Rect(0, 0, 64, 64), Color::BLACK);
928 }
929 }
930
TEST_P(LayerRenderTypeTransactionTest,SetCropWithTranslation_BufferQueue)931 TEST_P(LayerRenderTypeTransactionTest, SetCropWithTranslation_BufferQueue) {
932 sp<SurfaceControl> layer;
933 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
934 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
935
936 const Point position(32, 32);
937 const Rect crop(8, 8, 24, 24);
938 Transaction().setPosition(layer, position.x, position.y).setCrop(layer, crop).apply();
939 auto shot = getScreenCapture();
940 shot->expectColor(crop + position, Color::RED);
941 shot->expectBorder(crop + position, Color::BLACK);
942 }
943
TEST_P(LayerRenderTypeTransactionTest,SetCropWithTranslation_BufferState)944 TEST_P(LayerRenderTypeTransactionTest, SetCropWithTranslation_BufferState) {
945 sp<SurfaceControl> layer;
946 ASSERT_NO_FATAL_FAILURE(
947 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
948 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
949
950 const Rect crop(8, 8, 24, 24);
951 Transaction().setPosition(layer, 32, 32).setCrop(layer, crop).apply();
952 auto shot = getScreenCapture();
953 shot->expectColor(Rect(40, 40, 56, 56), Color::RED);
954 shot->expectBorder(Rect(40, 40, 56, 56), Color::BLACK);
955 }
956
TEST_P(LayerRenderTypeTransactionTest,SetCropWithScale_BufferQueue)957 TEST_P(LayerRenderTypeTransactionTest, SetCropWithScale_BufferQueue) {
958 sp<SurfaceControl> layer;
959 ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
960 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
961
962 // crop is affected by matrix
963 Transaction()
964 .setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f)
965 .setCrop(layer, Rect(8, 8, 24, 24))
966 .apply();
967 auto shot = getScreenCapture();
968 shot->expectColor(Rect(16, 16, 48, 48), Color::RED);
969 shot->expectBorder(Rect(16, 16, 48, 48), Color::BLACK);
970 }
971
TEST_P(LayerRenderTypeTransactionTest,SetFrameBasic_BufferState)972 TEST_P(LayerRenderTypeTransactionTest, SetFrameBasic_BufferState) {
973 sp<SurfaceControl> layer;
974 ASSERT_NO_FATAL_FAILURE(
975 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
976 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
977 const Rect frame(8, 8, 24, 24);
978
979 Transaction t;
980 TransactionUtils::setFrame(t, layer, Rect(0, 0, 32, 32), frame);
981 t.apply();
982
983 auto shot = getScreenCapture();
984 shot->expectColor(frame, Color::RED);
985 shot->expectBorder(frame, Color::BLACK);
986 }
987
TEST_P(LayerRenderTypeTransactionTest,SetFrameEmpty_BufferState)988 TEST_P(LayerRenderTypeTransactionTest, SetFrameEmpty_BufferState) {
989 sp<SurfaceControl> layer;
990 ASSERT_NO_FATAL_FAILURE(
991 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
992 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
993
994 Transaction t;
995 {
996 SCOPED_TRACE("empty rect");
997 TransactionUtils::setFrame(t, layer, Rect(0, 0, 32, 32), Rect(8, 8, 8, 8));
998 t.apply();
999
1000 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
1001 }
1002
1003 {
1004 SCOPED_TRACE("negative rect");
1005 TransactionUtils::setFrame(t, layer, Rect(0, 0, 32, 32), Rect(8, 8, 0, 0));
1006 t.apply();
1007
1008 auto shot = getScreenCapture();
1009 shot->expectColor(Rect(0, 0, 8, 8), Color::RED);
1010 shot->expectBorder(Rect(0, 0, 8, 8), Color::BLACK);
1011 }
1012 }
1013
TEST_P(LayerRenderTypeTransactionTest,SetFrameDefaultParentless_BufferState)1014 TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultParentless_BufferState) {
1015 sp<SurfaceControl> layer;
1016 ASSERT_NO_FATAL_FAILURE(
1017 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1018 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 10, 10));
1019
1020 // A layer with a buffer will have a computed size that matches the buffer size.
1021 auto shot = getScreenCapture();
1022 shot->expectColor(Rect(0, 0, 10, 10), Color::RED);
1023 shot->expectBorder(Rect(0, 0, 10, 10), Color::BLACK);
1024 }
1025
TEST_P(LayerRenderTypeTransactionTest,SetFrameDefaultBSParent_BufferState)1026 TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultBSParent_BufferState) {
1027 sp<SurfaceControl> parent, child;
1028 ASSERT_NO_FATAL_FAILURE(
1029 parent = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1030 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(parent, Color::RED, 32, 32));
1031
1032 ASSERT_NO_FATAL_FAILURE(
1033 child = createLayer("test", 10, 10, ISurfaceComposerClient::eFXSurfaceBufferState));
1034 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(child, Color::BLUE, 10, 10));
1035
1036 Transaction().reparent(child, parent).apply();
1037
1038 // A layer with a buffer will have a computed size that matches the buffer size.
1039 auto shot = getScreenCapture();
1040 shot->expectColor(Rect(0, 0, 10, 10), Color::BLUE);
1041 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1042 }
1043
TEST_P(LayerRenderTypeTransactionTest,SetFrameDefaultBQParent_BufferState)1044 TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultBQParent_BufferState) {
1045 sp<SurfaceControl> parent, child;
1046 ASSERT_NO_FATAL_FAILURE(parent = createLayer("test", 32, 32));
1047 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(parent, Color::RED, 32, 32));
1048
1049 ASSERT_NO_FATAL_FAILURE(
1050 child = createLayer("test", 10, 10, ISurfaceComposerClient::eFXSurfaceBufferState));
1051 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(child, Color::BLUE, 10, 10));
1052
1053 Transaction().reparent(child, parent).apply();
1054
1055 // A layer with a buffer will have a computed size that matches the buffer size.
1056 auto shot = getScreenCapture();
1057 shot->expectColor(Rect(0, 0, 10, 10), Color::BLUE);
1058 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1059 }
1060
TEST_P(LayerRenderTypeTransactionTest,SetFrameUpdate_BufferState)1061 TEST_P(LayerRenderTypeTransactionTest, SetFrameUpdate_BufferState) {
1062 sp<SurfaceControl> layer;
1063 ASSERT_NO_FATAL_FAILURE(
1064 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1065 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
1066
1067 std::this_thread::sleep_for(500ms);
1068
1069 Transaction().setPosition(layer, 16, 16).apply();
1070
1071 auto shot = getScreenCapture();
1072 shot->expectColor(Rect(16, 16, 48, 48), Color::RED);
1073 shot->expectBorder(Rect(16, 16, 48, 48), Color::BLACK);
1074 }
1075
TEST_P(LayerRenderTypeTransactionTest,SetFrameOutsideBounds_BufferState)1076 TEST_P(LayerRenderTypeTransactionTest, SetFrameOutsideBounds_BufferState) {
1077 sp<SurfaceControl> parent, child;
1078 ASSERT_NO_FATAL_FAILURE(
1079 parent = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1080 ASSERT_NO_FATAL_FAILURE(
1081 child = createLayer("test", 10, 10, ISurfaceComposerClient::eFXSurfaceBufferState));
1082 Transaction().reparent(child, parent).apply();
1083
1084 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(parent, Color::RED, 32, 32));
1085
1086 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(child, Color::BLUE, 10, 10));
1087 Rect childDst(0, 16, 32, 32);
1088 Transaction t;
1089 TransactionUtils::setFrame(t, child, Rect(0, 0, 10, 10), childDst);
1090 t.apply();
1091
1092 auto shot = getScreenCapture();
1093 shot->expectColor(Rect(0, 0, 32, 16), Color::RED);
1094 shot->expectColor(childDst, Color::BLUE);
1095 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1096 }
1097
TEST_P(LayerRenderTypeTransactionTest,SetBufferBasic_BufferState)1098 TEST_P(LayerRenderTypeTransactionTest, SetBufferBasic_BufferState) {
1099 sp<SurfaceControl> layer;
1100 ASSERT_NO_FATAL_FAILURE(
1101 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1102
1103 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
1104
1105 auto shot = getScreenCapture();
1106 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1107 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1108 }
1109
TEST_P(LayerRenderTypeTransactionTest,SetBufferMultipleBuffers_BufferState)1110 TEST_P(LayerRenderTypeTransactionTest, SetBufferMultipleBuffers_BufferState) {
1111 sp<SurfaceControl> layer;
1112 ASSERT_NO_FATAL_FAILURE(
1113 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1114
1115 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
1116
1117 {
1118 SCOPED_TRACE("set buffer 1");
1119 auto shot = getScreenCapture();
1120 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1121 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1122 }
1123
1124 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::BLUE, 32, 32));
1125
1126 {
1127 SCOPED_TRACE("set buffer 2");
1128 auto shot = getScreenCapture();
1129 shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
1130 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1131 }
1132
1133 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer, Color::RED, 32, 32));
1134
1135 {
1136 SCOPED_TRACE("set buffer 3");
1137 auto shot = getScreenCapture();
1138 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1139 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1140 }
1141 }
1142
TEST_P(LayerRenderTypeTransactionTest,SetBufferMultipleLayers_BufferState)1143 TEST_P(LayerRenderTypeTransactionTest, SetBufferMultipleLayers_BufferState) {
1144 sp<SurfaceControl> layer1;
1145 ASSERT_NO_FATAL_FAILURE(
1146 layer1 = createLayer("test", 64, 64, ISurfaceComposerClient::eFXSurfaceBufferState));
1147
1148 sp<SurfaceControl> layer2;
1149 ASSERT_NO_FATAL_FAILURE(
1150 layer2 = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1151
1152 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer1, Color::RED, 64, 64));
1153
1154 {
1155 SCOPED_TRACE("set layer 1 buffer red");
1156 auto shot = getScreenCapture();
1157 shot->expectColor(Rect(0, 0, 64, 64), Color::RED);
1158 }
1159
1160 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer2, Color::BLUE, 32, 32));
1161
1162 {
1163 SCOPED_TRACE("set layer 2 buffer blue");
1164 auto shot = getScreenCapture();
1165 shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
1166 shot->expectColor(Rect(0, 32, 64, 64), Color::RED);
1167 shot->expectColor(Rect(0, 32, 32, 64), Color::RED);
1168 }
1169
1170 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer1, Color::GREEN, 64, 64));
1171 {
1172 SCOPED_TRACE("set layer 1 buffer green");
1173 auto shot = getScreenCapture();
1174 shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
1175 shot->expectColor(Rect(0, 32, 64, 64), Color::GREEN);
1176 shot->expectColor(Rect(0, 32, 32, 64), Color::GREEN);
1177 }
1178
1179 ASSERT_NO_FATAL_FAILURE(fillBufferLayerColor(layer2, Color::WHITE, 32, 32));
1180
1181 {
1182 SCOPED_TRACE("set layer 2 buffer white");
1183 auto shot = getScreenCapture();
1184 shot->expectColor(Rect(0, 0, 32, 32), Color::WHITE);
1185 shot->expectColor(Rect(0, 32, 64, 64), Color::GREEN);
1186 shot->expectColor(Rect(0, 32, 32, 64), Color::GREEN);
1187 }
1188 }
1189
TEST_P(LayerRenderTypeTransactionTest,SetBufferCaching_BufferState)1190 TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_BufferState) {
1191 sp<SurfaceControl> layer;
1192 ASSERT_NO_FATAL_FAILURE(
1193 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1194
1195 std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
1196
1197 std::array<sp<GraphicBuffer>, 10> buffers;
1198
1199 size_t idx = 0;
1200 for (auto& buffer : buffers) {
1201 buffer = sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1202 Color color = colors[idx % colors.size()];
1203 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
1204 idx++;
1205 }
1206
1207 // Set each buffer twice. The first time adds it to the cache, the second time tests that the
1208 // cache is working.
1209 idx = 0;
1210 for (auto& buffer : buffers) {
1211 for (int i = 0; i < 2; i++) {
1212 Transaction().setBuffer(layer, buffer).apply();
1213
1214 Color color = colors[idx % colors.size()];
1215 auto shot = screenshot();
1216 shot->expectColor(Rect(0, 0, 32, 32), color);
1217 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1218 }
1219 idx++;
1220 }
1221 }
1222
TEST_P(LayerRenderTypeTransactionTest,SetBufferCaching_LeastRecentlyUsed_BufferState)1223 TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_LeastRecentlyUsed_BufferState) {
1224 sp<SurfaceControl> layer;
1225 ASSERT_NO_FATAL_FAILURE(
1226 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1227
1228 std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
1229
1230 std::array<sp<GraphicBuffer>, 70> buffers;
1231
1232 size_t idx = 0;
1233 for (auto& buffer : buffers) {
1234 buffer = sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1235 Color color = colors[idx % colors.size()];
1236 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
1237 idx++;
1238 }
1239
1240 // Set each buffer twice. The first time adds it to the cache, the second time tests that the
1241 // cache is working.
1242 idx = 0;
1243 for (auto& buffer : buffers) {
1244 for (int i = 0; i < 2; i++) {
1245 Transaction().setBuffer(layer, buffer).apply();
1246
1247 Color color = colors[idx % colors.size()];
1248 auto shot = screenshot();
1249 shot->expectColor(Rect(0, 0, 32, 32), color);
1250 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1251 }
1252 idx++;
1253 }
1254 }
1255
TEST_P(LayerRenderTypeTransactionTest,SetBufferCaching_DestroyedBuffer_BufferState)1256 TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_DestroyedBuffer_BufferState) {
1257 sp<SurfaceControl> layer;
1258 ASSERT_NO_FATAL_FAILURE(
1259 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1260
1261 std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
1262
1263 std::array<sp<GraphicBuffer>, 65> buffers;
1264
1265 size_t idx = 0;
1266 for (auto& buffer : buffers) {
1267 buffer = sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1268 Color color = colors[idx % colors.size()];
1269 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
1270 idx++;
1271 }
1272
1273 // Set each buffer twice. The first time adds it to the cache, the second time tests that the
1274 // cache is working.
1275 idx = 0;
1276 for (auto& buffer : buffers) {
1277 for (int i = 0; i < 2; i++) {
1278 Transaction().setBuffer(layer, buffer).apply();
1279
1280 Color color = colors[idx % colors.size()];
1281 auto shot = screenshot();
1282 shot->expectColor(Rect(0, 0, 32, 32), color);
1283 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1284 }
1285 if (idx == 0) {
1286 buffers[0].clear();
1287 }
1288 idx++;
1289 }
1290 }
1291
TEST_P(LayerRenderTypeTransactionTest,SetTransformRotate90_BufferState)1292 TEST_P(LayerRenderTypeTransactionTest, SetTransformRotate90_BufferState) {
1293 sp<SurfaceControl> layer;
1294 ASSERT_NO_FATAL_FAILURE(
1295 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1296
1297 ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
1298 Color::BLUE, Color::WHITE));
1299
1300 Transaction()
1301 .setTransform(layer, NATIVE_WINDOW_TRANSFORM_ROT_90)
1302 .apply();
1303
1304 getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::RED, Color::WHITE,
1305 Color::GREEN, true /* filtered */);
1306 }
1307
TEST_P(LayerRenderTypeTransactionTest,SetTransformFlipH_BufferState)1308 TEST_P(LayerRenderTypeTransactionTest, SetTransformFlipH_BufferState) {
1309 sp<SurfaceControl> layer;
1310 ASSERT_NO_FATAL_FAILURE(
1311 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1312
1313 ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
1314 Color::BLUE, Color::WHITE));
1315
1316 Transaction()
1317 .setTransform(layer, NATIVE_WINDOW_TRANSFORM_FLIP_H)
1318 .apply();
1319
1320 getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::GREEN, Color::RED, Color::WHITE,
1321 Color::BLUE, true /* filtered */);
1322 }
1323
TEST_P(LayerRenderTypeTransactionTest,SetTransformFlipV_BufferState)1324 TEST_P(LayerRenderTypeTransactionTest, SetTransformFlipV_BufferState) {
1325 sp<SurfaceControl> layer;
1326 ASSERT_NO_FATAL_FAILURE(
1327 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1328
1329 ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
1330 Color::BLUE, Color::WHITE));
1331
1332 Transaction()
1333 .setTransform(layer, NATIVE_WINDOW_TRANSFORM_FLIP_V)
1334 .apply();
1335
1336 getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::WHITE, Color::RED,
1337 Color::GREEN, true /* filtered */);
1338 }
1339
1340 // TODO (b/186543004): Fix & re-enable
TEST_P(LayerRenderTypeTransactionTest,DISABLED_SetFenceBasic_BufferState)1341 TEST_P(LayerRenderTypeTransactionTest, DISABLED_SetFenceBasic_BufferState) {
1342 sp<SurfaceControl> layer;
1343 Transaction transaction;
1344 ASSERT_NO_FATAL_FAILURE(
1345 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1346
1347 sp<GraphicBuffer> buffer =
1348 sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1349 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1350
1351 sp<Fence> fence;
1352 if (getBuffer(nullptr, &fence) != NO_ERROR) {
1353 GTEST_SUCCEED() << "test not supported";
1354 return;
1355 }
1356
1357 Transaction().setBuffer(layer, buffer, fence).apply();
1358
1359 status_t status = fence->wait(1000);
1360 ASSERT_NE(static_cast<status_t>(Fence::Status::Unsignaled), status);
1361 std::this_thread::sleep_for(200ms);
1362
1363 auto shot = getScreenCapture();
1364 shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
1365 shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
1366 }
1367
TEST_P(LayerRenderTypeTransactionTest,SetFenceNull_BufferState)1368 TEST_P(LayerRenderTypeTransactionTest, SetFenceNull_BufferState) {
1369 sp<SurfaceControl> layer;
1370 ASSERT_NO_FATAL_FAILURE(
1371 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1372
1373 sp<GraphicBuffer> buffer =
1374 sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1375 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1376
1377 sp<Fence> fence = Fence::NO_FENCE;
1378
1379 Transaction().setBuffer(layer, buffer, fence).apply();
1380
1381 auto shot = getScreenCapture();
1382 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1383 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1384 }
1385
TEST_P(LayerRenderTypeTransactionTest,SetDataspaceBasic_BufferState)1386 TEST_P(LayerRenderTypeTransactionTest, SetDataspaceBasic_BufferState) {
1387 sp<SurfaceControl> layer;
1388 ASSERT_NO_FATAL_FAILURE(
1389 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1390
1391 sp<GraphicBuffer> buffer =
1392 sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1393 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1394
1395 Transaction().setBuffer(layer, buffer).setDataspace(layer, ui::Dataspace::UNKNOWN).apply();
1396
1397 auto shot = getScreenCapture();
1398 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1399 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1400 }
1401
TEST_P(LayerRenderTypeTransactionTest,SetHdrMetadataBasic_BufferState)1402 TEST_P(LayerRenderTypeTransactionTest, SetHdrMetadataBasic_BufferState) {
1403 sp<SurfaceControl> layer;
1404 ASSERT_NO_FATAL_FAILURE(
1405 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1406
1407 sp<GraphicBuffer> buffer =
1408 sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1409 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1410
1411 HdrMetadata hdrMetadata;
1412 hdrMetadata.validTypes = 0;
1413 Transaction().setBuffer(layer, buffer).setHdrMetadata(layer, hdrMetadata).apply();
1414
1415 auto shot = getScreenCapture();
1416 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1417 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1418 }
1419
TEST_P(LayerRenderTypeTransactionTest,SetSurfaceDamageRegionBasic_BufferState)1420 TEST_P(LayerRenderTypeTransactionTest, SetSurfaceDamageRegionBasic_BufferState) {
1421 sp<SurfaceControl> layer;
1422 ASSERT_NO_FATAL_FAILURE(
1423 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1424
1425 sp<GraphicBuffer> buffer =
1426 sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1427 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1428
1429 Region region;
1430 region.set(32, 32);
1431 Transaction().setBuffer(layer, buffer).setSurfaceDamageRegion(layer, region).apply();
1432
1433 auto shot = getScreenCapture();
1434 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1435 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1436 }
1437
TEST_P(LayerRenderTypeTransactionTest,SetApiBasic_BufferState)1438 TEST_P(LayerRenderTypeTransactionTest, SetApiBasic_BufferState) {
1439 sp<SurfaceControl> layer;
1440 ASSERT_NO_FATAL_FAILURE(
1441 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1442
1443 sp<GraphicBuffer> buffer =
1444 sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1445 TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1446
1447 Transaction().setBuffer(layer, buffer).setApi(layer, NATIVE_WINDOW_API_CPU).apply();
1448
1449 auto shot = getScreenCapture();
1450 shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1451 shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1452 }
1453
TEST_P(LayerRenderTypeTransactionTest,SetColorTransformBasic)1454 TEST_P(LayerRenderTypeTransactionTest, SetColorTransformBasic) {
1455 sp<SurfaceControl> colorLayer;
1456 ASSERT_NO_FATAL_FAILURE(colorLayer =
1457 createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
1458 ISurfaceComposerClient::eFXSurfaceEffect));
1459 Transaction()
1460 .setCrop(colorLayer, Rect(0, 0, 32, 32))
1461 .setLayer(colorLayer, mLayerZBase + 1)
1462 .apply();
1463 {
1464 SCOPED_TRACE("default color");
1465 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
1466 }
1467
1468 const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
1469 half3 expected = color;
1470 mat3 matrix;
1471 matrix[0][0] = 0.3;
1472 matrix[1][0] = 0.59;
1473 matrix[2][0] = 0.11;
1474 matrix[0][1] = 0.3;
1475 matrix[1][1] = 0.59;
1476 matrix[2][1] = 0.11;
1477 matrix[0][2] = 0.3;
1478 matrix[1][2] = 0.59;
1479 matrix[2][2] = 0.11;
1480
1481 // degamma before applying the matrix
1482 if (mColorManagementUsed) {
1483 ColorTransformHelper::DegammaColor(expected);
1484 }
1485
1486 ColorTransformHelper::applyMatrix(expected, matrix);
1487
1488 if (mColorManagementUsed) {
1489 ColorTransformHelper::GammaColor(expected);
1490 }
1491
1492 const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
1493 uint8_t(expected.b * 255), 255};
1494
1495 // this is handwavy, but the precison loss scaled by 255 (8-bit per
1496 // channel) should be less than one
1497 const uint8_t tolerance = 1;
1498
1499 Transaction().setColor(colorLayer, color).setColorTransform(colorLayer, matrix, vec3()).apply();
1500 {
1501 SCOPED_TRACE("new color");
1502 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
1503 }
1504 }
1505
TEST_P(LayerRenderTypeTransactionTest,SetColorTransformOnParent)1506 TEST_P(LayerRenderTypeTransactionTest, SetColorTransformOnParent) {
1507 sp<SurfaceControl> parentLayer;
1508 sp<SurfaceControl> colorLayer;
1509 ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parent", 0 /* buffer width */,
1510 0 /* buffer height */,
1511 ISurfaceComposerClient::eFXSurfaceContainer));
1512 ASSERT_NO_FATAL_FAILURE(
1513 colorLayer = createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
1514 ISurfaceComposerClient::eFXSurfaceEffect, parentLayer.get()));
1515
1516 Transaction()
1517 .setCrop(parentLayer, Rect(0, 0, 100, 100))
1518 .setCrop(colorLayer, Rect(0, 0, 32, 32))
1519 .setLayer(parentLayer, mLayerZBase + 1)
1520 .apply();
1521 {
1522 SCOPED_TRACE("default color");
1523 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
1524 }
1525
1526 const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
1527 half3 expected = color;
1528 mat3 matrix;
1529 matrix[0][0] = 0.3;
1530 matrix[1][0] = 0.59;
1531 matrix[2][0] = 0.11;
1532 matrix[0][1] = 0.3;
1533 matrix[1][1] = 0.59;
1534 matrix[2][1] = 0.11;
1535 matrix[0][2] = 0.3;
1536 matrix[1][2] = 0.59;
1537 matrix[2][2] = 0.11;
1538
1539 // degamma before applying the matrix
1540 if (mColorManagementUsed) {
1541 ColorTransformHelper::DegammaColor(expected);
1542 }
1543
1544 ColorTransformHelper::applyMatrix(expected, matrix);
1545
1546 if (mColorManagementUsed) {
1547 ColorTransformHelper::GammaColor(expected);
1548 }
1549
1550 const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
1551 uint8_t(expected.b * 255), 255};
1552
1553 // this is handwavy, but the precison loss scaled by 255 (8-bit per
1554 // channel) should be less than one
1555 const uint8_t tolerance = 1;
1556
1557 Transaction()
1558 .setColor(colorLayer, color)
1559 .setColorTransform(parentLayer, matrix, vec3())
1560 .apply();
1561 {
1562 SCOPED_TRACE("new color");
1563 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
1564 }
1565 }
1566
TEST_P(LayerRenderTypeTransactionTest,SetColorTransformOnChildAndParent)1567 TEST_P(LayerRenderTypeTransactionTest, SetColorTransformOnChildAndParent) {
1568 sp<SurfaceControl> parentLayer;
1569 sp<SurfaceControl> colorLayer;
1570 ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parent", 0 /* buffer width */,
1571 0 /* buffer height */,
1572 ISurfaceComposerClient::eFXSurfaceContainer));
1573 ASSERT_NO_FATAL_FAILURE(
1574 colorLayer = createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
1575 ISurfaceComposerClient::eFXSurfaceEffect, parentLayer.get()));
1576
1577 Transaction()
1578 .setCrop(parentLayer, Rect(0, 0, 100, 100))
1579 .setCrop(colorLayer, Rect(0, 0, 32, 32))
1580 .setLayer(parentLayer, mLayerZBase + 1)
1581 .apply();
1582 {
1583 SCOPED_TRACE("default color");
1584 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
1585 }
1586
1587 const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
1588 half3 expected = color;
1589 mat3 matrixChild;
1590 matrixChild[0][0] = 0.3;
1591 matrixChild[1][0] = 0.59;
1592 matrixChild[2][0] = 0.11;
1593 matrixChild[0][1] = 0.3;
1594 matrixChild[1][1] = 0.59;
1595 matrixChild[2][1] = 0.11;
1596 matrixChild[0][2] = 0.3;
1597 matrixChild[1][2] = 0.59;
1598 matrixChild[2][2] = 0.11;
1599 mat3 matrixParent;
1600 matrixParent[0][0] = 0.2;
1601 matrixParent[1][0] = 0.4;
1602 matrixParent[2][0] = 0.10;
1603 matrixParent[0][1] = 0.2;
1604 matrixParent[1][1] = 0.4;
1605 matrixParent[2][1] = 0.10;
1606 matrixParent[0][2] = 0.2;
1607 matrixParent[1][2] = 0.4;
1608 matrixParent[2][2] = 0.10;
1609
1610 // degamma before applying the matrix
1611 if (mColorManagementUsed) {
1612 ColorTransformHelper::DegammaColor(expected);
1613 }
1614
1615 ColorTransformHelper::applyMatrix(expected, matrixChild);
1616 ColorTransformHelper::applyMatrix(expected, matrixParent);
1617
1618 if (mColorManagementUsed) {
1619 ColorTransformHelper::GammaColor(expected);
1620 }
1621
1622 const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
1623 uint8_t(expected.b * 255), 255};
1624
1625 // this is handwavy, but the precison loss scaled by 255 (8-bit per
1626 // channel) should be less than one
1627 const uint8_t tolerance = 1;
1628
1629 Transaction()
1630 .setColor(colorLayer, color)
1631 .setColorTransform(parentLayer, matrixParent, vec3())
1632 .setColorTransform(colorLayer, matrixChild, vec3())
1633 .apply();
1634 {
1635 SCOPED_TRACE("new color");
1636 getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
1637 }
1638 }
1639
TEST_P(LayerRenderTypeTransactionTest,SetNullBuffer)1640 TEST_P(LayerRenderTypeTransactionTest, SetNullBuffer) {
1641 const Rect bounds(0, 0, 32, 32);
1642 sp<SurfaceControl> layer;
1643 ASSERT_NO_FATAL_FAILURE(
1644 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1645
1646 sp<GraphicBuffer> buffer =
1647 sp<GraphicBuffer>::make(32u, 32u, PIXEL_FORMAT_RGBA_8888, 1u, kUsageFlags, "test");
1648
1649 ASSERT_NO_FATAL_FAILURE(TransactionUtils::fillGraphicBufferColor(buffer, bounds, Color::GREEN));
1650 Transaction().setBuffer(layer, buffer).apply();
1651 {
1652 SCOPED_TRACE("before null buffer");
1653 auto shot = getScreenCapture();
1654 shot->expectColor(bounds, Color::GREEN);
1655 }
1656
1657 Transaction().setBuffer(layer, nullptr).apply();
1658 {
1659 SCOPED_TRACE("null buffer removes buffer");
1660 auto shot = getScreenCapture();
1661 shot->expectColor(bounds, Color::BLACK);
1662 }
1663
1664 Transaction().setBuffer(layer, buffer).apply();
1665 {
1666 SCOPED_TRACE("after null buffer");
1667 auto shot = getScreenCapture();
1668 shot->expectColor(bounds, Color::GREEN);
1669 }
1670 }
1671
TEST_P(LayerRenderTypeTransactionTest,SetNullBufferOnLayerWithoutBuffer)1672 TEST_P(LayerRenderTypeTransactionTest, SetNullBufferOnLayerWithoutBuffer) {
1673 const Rect bounds(0, 0, 32, 32);
1674 sp<SurfaceControl> layer;
1675 ASSERT_NO_FATAL_FAILURE(
1676 layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1677 {
1678 SCOPED_TRACE("starting state");
1679 auto shot = getScreenCapture();
1680 shot->expectColor(bounds, Color::BLACK);
1681 }
1682
1683 Transaction().setBuffer(layer, nullptr).apply();
1684 {
1685 SCOPED_TRACE("null buffer has no effect");
1686 auto shot = getScreenCapture();
1687 shot->expectColor(bounds, Color::BLACK);
1688 }
1689
1690 Transaction().setBuffer(layer, nullptr).apply();
1691 {
1692 SCOPED_TRACE("null buffer has no effect");
1693 auto shot = getScreenCapture();
1694 shot->expectColor(bounds, Color::BLACK);
1695 }
1696 }
1697
1698 } // namespace android
1699
1700 // TODO(b/129481165): remove the #pragma below and fix conversion issues
1701 #pragma clang diagnostic pop // ignored "-Wconversion"
1702