1 /*
2 * Copyright 2018 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 <chrono>
22 #include <condition_variable>
23 #include <fstream>
24
25 #include <gtest/gtest.h>
26 #include <cutils/properties.h>
27 #include <renderengine/RenderEngine.h>
28 #include <sync/sync.h>
29 #include <ui/PixelFormat.h>
30 #include "../gl/GLESRenderEngine.h"
31
32 constexpr int DEFAULT_DISPLAY_WIDTH = 128;
33 constexpr int DEFAULT_DISPLAY_HEIGHT = 256;
34 constexpr int DEFAULT_DISPLAY_OFFSET = 64;
35 constexpr bool WRITE_BUFFER_TO_FILE_ON_FAILURE = false;
36
37 namespace android {
38
39 struct RenderEngineTest : public ::testing::Test {
SetUpTestSuiteandroid::RenderEngineTest40 static void SetUpTestSuite() {
41 sRE = renderengine::gl::GLESRenderEngine::create(
42 renderengine::RenderEngineCreationArgs::Builder()
43 .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))
44 .setImageCacheSize(1)
45 .setUseColorManagerment(false)
46 .setEnableProtectedContext(false)
47 .setPrecacheToneMapperShaderOnly(false)
48 .setSupportsBackgroundBlur(true)
49 .setContextPriority(renderengine::RenderEngine::ContextPriority::MEDIUM)
50 .build());
51 }
52
TearDownTestSuiteandroid::RenderEngineTest53 static void TearDownTestSuite() {
54 // The ordering here is important - sCurrentBuffer must live longer
55 // than RenderEngine to avoid a null reference on tear-down.
56 sRE = nullptr;
57 sCurrentBuffer = nullptr;
58 }
59
allocateDefaultBufferandroid::RenderEngineTest60 static sp<GraphicBuffer> allocateDefaultBuffer() {
61 return new GraphicBuffer(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT,
62 HAL_PIXEL_FORMAT_RGBA_8888, 1,
63 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
64 GRALLOC_USAGE_HW_RENDER,
65 "output");
66 }
67
68 // Allocates a 1x1 buffer to fill with a solid color
allocateSourceBufferandroid::RenderEngineTest69 static sp<GraphicBuffer> allocateSourceBuffer(uint32_t width, uint32_t height) {
70 return new GraphicBuffer(width, height, HAL_PIXEL_FORMAT_RGBA_8888, 1,
71 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
72 GRALLOC_USAGE_HW_TEXTURE,
73 "input");
74 }
75
RenderEngineTestandroid::RenderEngineTest76 RenderEngineTest() { mBuffer = allocateDefaultBuffer(); }
77
~RenderEngineTestandroid::RenderEngineTest78 ~RenderEngineTest() {
79 if (WRITE_BUFFER_TO_FILE_ON_FAILURE && ::testing::Test::HasFailure()) {
80 writeBufferToFile("/data/texture_out_");
81 }
82 for (uint32_t texName : mTexNames) {
83 sRE->deleteTextures(1, &texName);
84 }
85 }
86
writeBufferToFileandroid::RenderEngineTest87 void writeBufferToFile(const char* basename) {
88 std::string filename(basename);
89 filename.append(::testing::UnitTest::GetInstance()->current_test_info()->name());
90 filename.append(".ppm");
91 std::ofstream file(filename.c_str(), std::ios::binary);
92 if (!file.is_open()) {
93 ALOGE("Unable to open file: %s", filename.c_str());
94 ALOGE("You may need to do: \"adb shell setenforce 0\" to enable "
95 "surfaceflinger to write debug images");
96 return;
97 }
98
99 uint8_t* pixels;
100 mBuffer->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
101 reinterpret_cast<void**>(&pixels));
102
103 file << "P6\n";
104 file << mBuffer->getWidth() << "\n";
105 file << mBuffer->getHeight() << "\n";
106 file << 255 << "\n";
107
108 std::vector<uint8_t> outBuffer(mBuffer->getWidth() * mBuffer->getHeight() * 3);
109 auto outPtr = reinterpret_cast<uint8_t*>(outBuffer.data());
110
111 for (int32_t j = 0; j < mBuffer->getHeight(); j++) {
112 const uint8_t* src = pixels + (mBuffer->getStride() * j) * 4;
113 for (int32_t i = 0; i < mBuffer->getWidth(); i++) {
114 // Only copy R, G and B components
115 outPtr[0] = src[0];
116 outPtr[1] = src[1];
117 outPtr[2] = src[2];
118 outPtr += 3;
119
120 src += 4;
121 }
122 }
123 file.write(reinterpret_cast<char*>(outBuffer.data()), outBuffer.size());
124 mBuffer->unlock();
125 }
126
expectBufferColorandroid::RenderEngineTest127 void expectBufferColor(const Region& region, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
128 size_t c;
129 Rect const* rect = region.getArray(&c);
130 for (size_t i = 0; i < c; i++, rect++) {
131 expectBufferColor(*rect, r, g, b, a);
132 }
133 }
134
expectBufferColorandroid::RenderEngineTest135 void expectBufferColor(const Rect& rect, uint8_t r, uint8_t g, uint8_t b, uint8_t a,
136 uint8_t tolerance = 0) {
137 auto colorCompare = [tolerance](const uint8_t* colorA, const uint8_t* colorB) {
138 auto colorBitCompare = [tolerance](uint8_t a, uint8_t b) {
139 uint8_t tmp = a >= b ? a - b : b - a;
140 return tmp <= tolerance;
141 };
142 return std::equal(colorA, colorA + 4, colorB, colorBitCompare);
143 };
144
145 expectBufferColor(rect, r, g, b, a, colorCompare);
146 }
147
expectBufferColorandroid::RenderEngineTest148 void expectBufferColor(const Rect& region, uint8_t r, uint8_t g, uint8_t b, uint8_t a,
149 std::function<bool(const uint8_t* a, const uint8_t* b)> colorCompare) {
150 uint8_t* pixels;
151 mBuffer->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
152 reinterpret_cast<void**>(&pixels));
153 int32_t maxFails = 10;
154 int32_t fails = 0;
155 for (int32_t j = 0; j < region.getHeight(); j++) {
156 const uint8_t* src =
157 pixels + (mBuffer->getStride() * (region.top + j) + region.left) * 4;
158 for (int32_t i = 0; i < region.getWidth(); i++) {
159 const uint8_t expected[4] = {r, g, b, a};
160 bool equal = colorCompare(src, expected);
161 EXPECT_TRUE(equal)
162 << "pixel @ (" << region.left + i << ", " << region.top + j << "): "
163 << "expected (" << static_cast<uint32_t>(r) << ", "
164 << static_cast<uint32_t>(g) << ", " << static_cast<uint32_t>(b) << ", "
165 << static_cast<uint32_t>(a) << "), "
166 << "got (" << static_cast<uint32_t>(src[0]) << ", "
167 << static_cast<uint32_t>(src[1]) << ", " << static_cast<uint32_t>(src[2])
168 << ", " << static_cast<uint32_t>(src[3]) << ")";
169 src += 4;
170 if (!equal && ++fails >= maxFails) {
171 break;
172 }
173 }
174 if (fails >= maxFails) {
175 break;
176 }
177 }
178 mBuffer->unlock();
179 }
180
expectAlphaandroid::RenderEngineTest181 void expectAlpha(const Rect& rect, uint8_t a) {
182 auto colorCompare = [](const uint8_t* colorA, const uint8_t* colorB) {
183 return colorA[3] == colorB[3];
184 };
185 expectBufferColor(rect, 0.0f /* r */, 0.0f /*g */, 0.0f /* b */, a, colorCompare);
186 }
187
expectShadowColorandroid::RenderEngineTest188 void expectShadowColor(const renderengine::LayerSettings& castingLayer,
189 const renderengine::ShadowSettings& shadow, const ubyte4& casterColor,
190 const ubyte4& backgroundColor) {
191 const Rect casterRect(castingLayer.geometry.boundaries);
192 Region casterRegion = Region(casterRect);
193 const float casterCornerRadius = castingLayer.geometry.roundedCornersRadius;
194 if (casterCornerRadius > 0.0f) {
195 // ignore the corners if a corner radius is set
196 Rect cornerRect(casterCornerRadius, casterCornerRadius);
197 casterRegion.subtractSelf(cornerRect.offsetTo(casterRect.left, casterRect.top));
198 casterRegion.subtractSelf(
199 cornerRect.offsetTo(casterRect.right - casterCornerRadius, casterRect.top));
200 casterRegion.subtractSelf(
201 cornerRect.offsetTo(casterRect.left, casterRect.bottom - casterCornerRadius));
202 casterRegion.subtractSelf(cornerRect.offsetTo(casterRect.right - casterCornerRadius,
203 casterRect.bottom - casterCornerRadius));
204 }
205
206 const float shadowInset = shadow.length * -1.0f;
207 const Rect casterWithShadow =
208 Rect(casterRect).inset(shadowInset, shadowInset, shadowInset, shadowInset);
209 const Region shadowRegion = Region(casterWithShadow).subtractSelf(casterRect);
210 const Region backgroundRegion = Region(fullscreenRect()).subtractSelf(casterWithShadow);
211
212 // verify casting layer
213 expectBufferColor(casterRegion, casterColor.r, casterColor.g, casterColor.b, casterColor.a);
214
215 // verify shadows by testing just the alpha since its difficult to validate the shadow color
216 size_t c;
217 Rect const* r = shadowRegion.getArray(&c);
218 for (size_t i = 0; i < c; i++, r++) {
219 expectAlpha(*r, 255);
220 }
221
222 // verify background
223 expectBufferColor(backgroundRegion, backgroundColor.r, backgroundColor.g, backgroundColor.b,
224 backgroundColor.a);
225 }
226
getShadowSettingsandroid::RenderEngineTest227 static renderengine::ShadowSettings getShadowSettings(const vec2& casterPos, float shadowLength,
228 bool casterIsTranslucent) {
229 renderengine::ShadowSettings shadow;
230 shadow.ambientColor = {0.0f, 0.0f, 0.0f, 0.039f};
231 shadow.spotColor = {0.0f, 0.0f, 0.0f, 0.19f};
232 shadow.lightPos = vec3(casterPos.x, casterPos.y, 0);
233 shadow.lightRadius = 0.0f;
234 shadow.length = shadowLength;
235 shadow.casterIsTranslucent = casterIsTranslucent;
236 return shadow;
237 }
238
fullscreenRectandroid::RenderEngineTest239 static Rect fullscreenRect() { return Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT); }
240
offsetRectandroid::RenderEngineTest241 static Rect offsetRect() {
242 return Rect(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_WIDTH,
243 DEFAULT_DISPLAY_HEIGHT);
244 }
245
offsetRectAtZeroandroid::RenderEngineTest246 static Rect offsetRectAtZero() {
247 return Rect(DEFAULT_DISPLAY_WIDTH - DEFAULT_DISPLAY_OFFSET,
248 DEFAULT_DISPLAY_HEIGHT - DEFAULT_DISPLAY_OFFSET);
249 }
250
invokeDrawandroid::RenderEngineTest251 void invokeDraw(renderengine::DisplaySettings settings,
252 std::vector<const renderengine::LayerSettings*> layers,
253 sp<GraphicBuffer> buffer) {
254 base::unique_fd fence;
255 status_t status = sRE->drawLayers(settings, layers, buffer->getNativeBuffer(), true,
256 base::unique_fd(), &fence);
257 sCurrentBuffer = buffer;
258
259 int fd = fence.release();
260 if (fd >= 0) {
261 sync_wait(fd, -1);
262 close(fd);
263 }
264
265 ASSERT_EQ(NO_ERROR, status);
266 if (layers.size() > 0) {
267 ASSERT_TRUE(sRE->isFramebufferImageCachedForTesting(buffer->getId()));
268 }
269 }
270
drawEmptyLayersandroid::RenderEngineTest271 void drawEmptyLayers() {
272 renderengine::DisplaySettings settings;
273 std::vector<const renderengine::LayerSettings*> layers;
274 // Meaningless buffer since we don't do any drawing
275 sp<GraphicBuffer> buffer = new GraphicBuffer();
276 invokeDraw(settings, layers, buffer);
277 }
278
279 template <typename SourceVariant>
280 void fillBuffer(half r, half g, half b, half a);
281
282 template <typename SourceVariant>
283 void fillRedBuffer();
284
285 template <typename SourceVariant>
286 void fillGreenBuffer();
287
288 template <typename SourceVariant>
289 void fillBlueBuffer();
290
291 template <typename SourceVariant>
292 void fillRedTransparentBuffer();
293
294 template <typename SourceVariant>
295 void fillRedOffsetBuffer();
296
297 template <typename SourceVariant>
298 void fillBufferPhysicalOffset();
299
300 template <typename SourceVariant>
301 void fillBufferCheckers(uint32_t rotation);
302
303 template <typename SourceVariant>
304 void fillBufferCheckersRotate0();
305
306 template <typename SourceVariant>
307 void fillBufferCheckersRotate90();
308
309 template <typename SourceVariant>
310 void fillBufferCheckersRotate180();
311
312 template <typename SourceVariant>
313 void fillBufferCheckersRotate270();
314
315 template <typename SourceVariant>
316 void fillBufferWithLayerTransform();
317
318 template <typename SourceVariant>
319 void fillBufferLayerTransform();
320
321 template <typename SourceVariant>
322 void fillBufferWithColorTransform();
323
324 template <typename SourceVariant>
325 void fillBufferColorTransform();
326
327 template <typename SourceVariant>
328 void fillRedBufferWithRoundedCorners();
329
330 template <typename SourceVariant>
331 void fillBufferWithRoundedCorners();
332
333 template <typename SourceVariant>
334 void fillBufferAndBlurBackground();
335
336 template <typename SourceVariant>
337 void overlayCorners();
338
339 void fillRedBufferTextureTransform();
340
341 void fillBufferTextureTransform();
342
343 void fillRedBufferWithPremultiplyAlpha();
344
345 void fillBufferWithPremultiplyAlpha();
346
347 void fillRedBufferWithoutPremultiplyAlpha();
348
349 void fillBufferWithoutPremultiplyAlpha();
350
351 void fillGreenColorBufferThenClearRegion();
352
353 void clearLeftRegion();
354
355 void clearRegion();
356
357 template <typename SourceVariant>
358 void drawShadow(const renderengine::LayerSettings& castingLayer,
359 const renderengine::ShadowSettings& shadow, const ubyte4& casterColor,
360 const ubyte4& backgroundColor);
361
362 // Keep around the same renderengine object to save on initialization time.
363 // For now, exercise the GL backend directly so that some caching specifics
364 // can be tested without changing the interface.
365 static std::unique_ptr<renderengine::gl::GLESRenderEngine> sRE;
366 // Dumb hack to avoid NPE in the EGL driver: the GraphicBuffer needs to
367 // be freed *after* RenderEngine is destroyed, so that the EGL image is
368 // destroyed first.
369 static sp<GraphicBuffer> sCurrentBuffer;
370
371 sp<GraphicBuffer> mBuffer;
372
373 std::vector<uint32_t> mTexNames;
374 };
375
376 std::unique_ptr<renderengine::gl::GLESRenderEngine> RenderEngineTest::sRE = nullptr;
377 sp<GraphicBuffer> RenderEngineTest::sCurrentBuffer = nullptr;
378
379 struct ColorSourceVariant {
fillColorandroid::ColorSourceVariant380 static void fillColor(renderengine::LayerSettings& layer, half r, half g, half b,
381 RenderEngineTest* /*fixture*/) {
382 layer.source.solidColor = half3(r, g, b);
383 }
384 };
385
386 struct RelaxOpaqueBufferVariant {
setOpaqueBitandroid::RelaxOpaqueBufferVariant387 static void setOpaqueBit(renderengine::LayerSettings& layer) {
388 layer.source.buffer.isOpaque = false;
389 }
390
getAlphaChannelandroid::RelaxOpaqueBufferVariant391 static uint8_t getAlphaChannel() { return 255; }
392 };
393
394 struct ForceOpaqueBufferVariant {
setOpaqueBitandroid::ForceOpaqueBufferVariant395 static void setOpaqueBit(renderengine::LayerSettings& layer) {
396 layer.source.buffer.isOpaque = true;
397 }
398
getAlphaChannelandroid::ForceOpaqueBufferVariant399 static uint8_t getAlphaChannel() {
400 // The isOpaque bit will override the alpha channel, so this should be
401 // arbitrary.
402 return 10;
403 }
404 };
405
406 template <typename OpaquenessVariant>
407 struct BufferSourceVariant {
fillColorandroid::BufferSourceVariant408 static void fillColor(renderengine::LayerSettings& layer, half r, half g, half b,
409 RenderEngineTest* fixture) {
410 sp<GraphicBuffer> buf = RenderEngineTest::allocateSourceBuffer(1, 1);
411 uint32_t texName;
412 fixture->sRE->genTextures(1, &texName);
413 fixture->mTexNames.push_back(texName);
414
415 uint8_t* pixels;
416 buf->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
417 reinterpret_cast<void**>(&pixels));
418
419 for (int32_t j = 0; j < buf->getHeight(); j++) {
420 uint8_t* iter = pixels + (buf->getStride() * j) * 4;
421 for (int32_t i = 0; i < buf->getWidth(); i++) {
422 iter[0] = uint8_t(r * 255);
423 iter[1] = uint8_t(g * 255);
424 iter[2] = uint8_t(b * 255);
425 iter[3] = OpaquenessVariant::getAlphaChannel();
426 iter += 4;
427 }
428 }
429
430 buf->unlock();
431
432 layer.source.buffer.buffer = buf;
433 layer.source.buffer.textureName = texName;
434 OpaquenessVariant::setOpaqueBit(layer);
435 }
436 };
437
438 template <typename SourceVariant>
fillBuffer(half r,half g,half b,half a)439 void RenderEngineTest::fillBuffer(half r, half g, half b, half a) {
440 renderengine::DisplaySettings settings;
441 settings.physicalDisplay = fullscreenRect();
442 settings.clip = fullscreenRect();
443
444 std::vector<const renderengine::LayerSettings*> layers;
445
446 renderengine::LayerSettings layer;
447 layer.geometry.boundaries = fullscreenRect().toFloatRect();
448 SourceVariant::fillColor(layer, r, g, b, this);
449 layer.alpha = a;
450
451 layers.push_back(&layer);
452
453 invokeDraw(settings, layers, mBuffer);
454 }
455
456 template <typename SourceVariant>
fillRedBuffer()457 void RenderEngineTest::fillRedBuffer() {
458 fillBuffer<SourceVariant>(1.0f, 0.0f, 0.0f, 1.0f);
459 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
460 }
461
462 template <typename SourceVariant>
fillGreenBuffer()463 void RenderEngineTest::fillGreenBuffer() {
464 fillBuffer<SourceVariant>(0.0f, 1.0f, 0.0f, 1.0f);
465 expectBufferColor(fullscreenRect(), 0, 255, 0, 255);
466 }
467
468 template <typename SourceVariant>
fillBlueBuffer()469 void RenderEngineTest::fillBlueBuffer() {
470 fillBuffer<SourceVariant>(0.0f, 0.0f, 1.0f, 1.0f);
471 expectBufferColor(fullscreenRect(), 0, 0, 255, 255);
472 }
473
474 template <typename SourceVariant>
fillRedTransparentBuffer()475 void RenderEngineTest::fillRedTransparentBuffer() {
476 fillBuffer<SourceVariant>(1.0f, 0.0f, 0.0f, .2f);
477 expectBufferColor(fullscreenRect(), 51, 0, 0, 51);
478 }
479
480 template <typename SourceVariant>
fillRedOffsetBuffer()481 void RenderEngineTest::fillRedOffsetBuffer() {
482 renderengine::DisplaySettings settings;
483 settings.physicalDisplay = offsetRect();
484 settings.clip = offsetRectAtZero();
485
486 std::vector<const renderengine::LayerSettings*> layers;
487
488 renderengine::LayerSettings layer;
489 layer.geometry.boundaries = offsetRectAtZero().toFloatRect();
490 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
491 layer.alpha = 1.0f;
492
493 layers.push_back(&layer);
494 invokeDraw(settings, layers, mBuffer);
495 }
496
497 template <typename SourceVariant>
fillBufferPhysicalOffset()498 void RenderEngineTest::fillBufferPhysicalOffset() {
499 fillRedOffsetBuffer<SourceVariant>();
500
501 expectBufferColor(Rect(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_WIDTH,
502 DEFAULT_DISPLAY_HEIGHT),
503 255, 0, 0, 255);
504 Rect offsetRegionLeft(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_HEIGHT);
505 Rect offsetRegionTop(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_OFFSET);
506
507 expectBufferColor(offsetRegionLeft, 0, 0, 0, 0);
508 expectBufferColor(offsetRegionTop, 0, 0, 0, 0);
509 }
510
511 template <typename SourceVariant>
fillBufferCheckers(uint32_t orientationFlag)512 void RenderEngineTest::fillBufferCheckers(uint32_t orientationFlag) {
513 renderengine::DisplaySettings settings;
514 settings.physicalDisplay = fullscreenRect();
515 // Here logical space is 2x2
516 settings.clip = Rect(2, 2);
517 settings.orientation = orientationFlag;
518
519 std::vector<const renderengine::LayerSettings*> layers;
520
521 renderengine::LayerSettings layerOne;
522 Rect rectOne(0, 0, 1, 1);
523 layerOne.geometry.boundaries = rectOne.toFloatRect();
524 SourceVariant::fillColor(layerOne, 1.0f, 0.0f, 0.0f, this);
525 layerOne.alpha = 1.0f;
526
527 renderengine::LayerSettings layerTwo;
528 Rect rectTwo(0, 1, 1, 2);
529 layerTwo.geometry.boundaries = rectTwo.toFloatRect();
530 SourceVariant::fillColor(layerTwo, 0.0f, 1.0f, 0.0f, this);
531 layerTwo.alpha = 1.0f;
532
533 renderengine::LayerSettings layerThree;
534 Rect rectThree(1, 0, 2, 1);
535 layerThree.geometry.boundaries = rectThree.toFloatRect();
536 SourceVariant::fillColor(layerThree, 0.0f, 0.0f, 1.0f, this);
537 layerThree.alpha = 1.0f;
538
539 layers.push_back(&layerOne);
540 layers.push_back(&layerTwo);
541 layers.push_back(&layerThree);
542
543 invokeDraw(settings, layers, mBuffer);
544 }
545
546 template <typename SourceVariant>
fillBufferCheckersRotate0()547 void RenderEngineTest::fillBufferCheckersRotate0() {
548 fillBufferCheckers<SourceVariant>(ui::Transform::ROT_0);
549 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 255, 0, 0,
550 255);
551 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
552 DEFAULT_DISPLAY_HEIGHT / 2),
553 0, 0, 255, 255);
554 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
555 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
556 0, 0, 0, 0);
557 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
558 DEFAULT_DISPLAY_HEIGHT),
559 0, 255, 0, 255);
560 }
561
562 template <typename SourceVariant>
fillBufferCheckersRotate90()563 void RenderEngineTest::fillBufferCheckersRotate90() {
564 fillBufferCheckers<SourceVariant>(ui::Transform::ROT_90);
565 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 255, 0,
566 255);
567 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
568 DEFAULT_DISPLAY_HEIGHT / 2),
569 255, 0, 0, 255);
570 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
571 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
572 0, 0, 255, 255);
573 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
574 DEFAULT_DISPLAY_HEIGHT),
575 0, 0, 0, 0);
576 }
577
578 template <typename SourceVariant>
fillBufferCheckersRotate180()579 void RenderEngineTest::fillBufferCheckersRotate180() {
580 fillBufferCheckers<SourceVariant>(ui::Transform::ROT_180);
581 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 0,
582 0);
583 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
584 DEFAULT_DISPLAY_HEIGHT / 2),
585 0, 255, 0, 255);
586 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
587 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
588 255, 0, 0, 255);
589 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
590 DEFAULT_DISPLAY_HEIGHT),
591 0, 0, 255, 255);
592 }
593
594 template <typename SourceVariant>
fillBufferCheckersRotate270()595 void RenderEngineTest::fillBufferCheckersRotate270() {
596 fillBufferCheckers<SourceVariant>(ui::Transform::ROT_270);
597 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 255,
598 255);
599 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
600 DEFAULT_DISPLAY_HEIGHT / 2),
601 0, 0, 0, 0);
602 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
603 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
604 0, 255, 0, 255);
605 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
606 DEFAULT_DISPLAY_HEIGHT),
607 255, 0, 0, 255);
608 }
609
610 template <typename SourceVariant>
fillBufferWithLayerTransform()611 void RenderEngineTest::fillBufferWithLayerTransform() {
612 renderengine::DisplaySettings settings;
613 settings.physicalDisplay = fullscreenRect();
614 // Here logical space is 2x2
615 settings.clip = Rect(2, 2);
616
617 std::vector<const renderengine::LayerSettings*> layers;
618
619 renderengine::LayerSettings layer;
620 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
621 // Translate one pixel diagonally
622 layer.geometry.positionTransform = mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1);
623 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
624 layer.source.solidColor = half3(1.0f, 0.0f, 0.0f);
625 layer.alpha = 1.0f;
626
627 layers.push_back(&layer);
628
629 invokeDraw(settings, layers, mBuffer);
630 }
631
632 template <typename SourceVariant>
fillBufferLayerTransform()633 void RenderEngineTest::fillBufferLayerTransform() {
634 fillBufferWithLayerTransform<SourceVariant>();
635 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 0, 0);
636 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 0);
637 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
638 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
639 255, 0, 0, 255);
640 }
641
642 template <typename SourceVariant>
fillBufferWithColorTransform()643 void RenderEngineTest::fillBufferWithColorTransform() {
644 renderengine::DisplaySettings settings;
645 settings.physicalDisplay = fullscreenRect();
646 settings.clip = Rect(1, 1);
647
648 std::vector<const renderengine::LayerSettings*> layers;
649
650 renderengine::LayerSettings layer;
651 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
652 SourceVariant::fillColor(layer, 0.5f, 0.25f, 0.125f, this);
653 layer.alpha = 1.0f;
654
655 // construct a fake color matrix
656 // annihilate green and blue channels
657 settings.colorTransform = mat4::scale(vec4(1, 0, 0, 1));
658 // set red channel to red + green
659 layer.colorTransform = mat4(1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
660
661 layer.alpha = 1.0f;
662 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
663
664 layers.push_back(&layer);
665
666 invokeDraw(settings, layers, mBuffer);
667 }
668
669 template <typename SourceVariant>
fillBufferColorTransform()670 void RenderEngineTest::fillBufferColorTransform() {
671 fillBufferWithColorTransform<SourceVariant>();
672 expectBufferColor(fullscreenRect(), 191, 0, 0, 255);
673 }
674
675 template <typename SourceVariant>
fillRedBufferWithRoundedCorners()676 void RenderEngineTest::fillRedBufferWithRoundedCorners() {
677 renderengine::DisplaySettings settings;
678 settings.physicalDisplay = fullscreenRect();
679 settings.clip = fullscreenRect();
680
681 std::vector<const renderengine::LayerSettings*> layers;
682
683 renderengine::LayerSettings layer;
684 layer.geometry.boundaries = fullscreenRect().toFloatRect();
685 layer.geometry.roundedCornersRadius = 5.0f;
686 layer.geometry.roundedCornersCrop = fullscreenRect().toFloatRect();
687 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
688 layer.alpha = 1.0f;
689
690 layers.push_back(&layer);
691
692 invokeDraw(settings, layers, mBuffer);
693 }
694
695 template <typename SourceVariant>
fillBufferWithRoundedCorners()696 void RenderEngineTest::fillBufferWithRoundedCorners() {
697 fillRedBufferWithRoundedCorners<SourceVariant>();
698 // Corners should be ignored...
699 expectBufferColor(Rect(0, 0, 1, 1), 0, 0, 0, 0);
700 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH - 1, 0, DEFAULT_DISPLAY_WIDTH, 1), 0, 0, 0, 0);
701 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT - 1, 1, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 0);
702 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH - 1, DEFAULT_DISPLAY_HEIGHT - 1,
703 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
704 0, 0, 0, 0);
705 // ...And the non-rounded portion should be red.
706 // Other pixels may be anti-aliased, so let's not check those.
707 expectBufferColor(Rect(5, 5, DEFAULT_DISPLAY_WIDTH - 5, DEFAULT_DISPLAY_HEIGHT - 5), 255, 0, 0,
708 255);
709 }
710
711 template <typename SourceVariant>
fillBufferAndBlurBackground()712 void RenderEngineTest::fillBufferAndBlurBackground() {
713 char value[PROPERTY_VALUE_MAX];
714 property_get("ro.surface_flinger.supports_background_blur", value, "0");
715 if (!atoi(value)) {
716 // This device doesn't support blurs, no-op.
717 return;
718 }
719
720 auto blurRadius = 50;
721 auto center = DEFAULT_DISPLAY_WIDTH / 2;
722
723 renderengine::DisplaySettings settings;
724 settings.physicalDisplay = fullscreenRect();
725 settings.clip = fullscreenRect();
726
727 std::vector<const renderengine::LayerSettings*> layers;
728
729 renderengine::LayerSettings backgroundLayer;
730 backgroundLayer.geometry.boundaries = fullscreenRect().toFloatRect();
731 SourceVariant::fillColor(backgroundLayer, 0.0f, 1.0f, 0.0f, this);
732 backgroundLayer.alpha = 1.0f;
733 layers.push_back(&backgroundLayer);
734
735 renderengine::LayerSettings leftLayer;
736 leftLayer.geometry.boundaries =
737 Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT).toFloatRect();
738 SourceVariant::fillColor(leftLayer, 1.0f, 0.0f, 0.0f, this);
739 leftLayer.alpha = 1.0f;
740 layers.push_back(&leftLayer);
741
742 renderengine::LayerSettings blurLayer;
743 blurLayer.geometry.boundaries = fullscreenRect().toFloatRect();
744 blurLayer.backgroundBlurRadius = blurRadius;
745 blurLayer.alpha = 0;
746 layers.push_back(&blurLayer);
747
748 invokeDraw(settings, layers, mBuffer);
749
750 expectBufferColor(Rect(center - 1, center - 5, center, center + 5), 150, 150, 0, 255,
751 50 /* tolerance */);
752 expectBufferColor(Rect(center, center - 5, center + 1, center + 5), 150, 150, 0, 255,
753 50 /* tolerance */);
754 }
755
756 template <typename SourceVariant>
overlayCorners()757 void RenderEngineTest::overlayCorners() {
758 renderengine::DisplaySettings settings;
759 settings.physicalDisplay = fullscreenRect();
760 settings.clip = fullscreenRect();
761
762 std::vector<const renderengine::LayerSettings*> layersFirst;
763
764 renderengine::LayerSettings layerOne;
765 layerOne.geometry.boundaries =
766 FloatRect(0, 0, DEFAULT_DISPLAY_WIDTH / 3.0, DEFAULT_DISPLAY_HEIGHT / 3.0);
767 SourceVariant::fillColor(layerOne, 1.0f, 0.0f, 0.0f, this);
768 layerOne.alpha = 0.2;
769
770 layersFirst.push_back(&layerOne);
771 invokeDraw(settings, layersFirst, mBuffer);
772 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3, DEFAULT_DISPLAY_HEIGHT / 3), 51, 0, 0, 51);
773 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3 + 1, DEFAULT_DISPLAY_HEIGHT / 3 + 1,
774 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
775 0, 0, 0, 0);
776
777 std::vector<const renderengine::LayerSettings*> layersSecond;
778 renderengine::LayerSettings layerTwo;
779 layerTwo.geometry.boundaries =
780 FloatRect(DEFAULT_DISPLAY_WIDTH / 3.0, DEFAULT_DISPLAY_HEIGHT / 3.0,
781 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
782 SourceVariant::fillColor(layerTwo, 0.0f, 1.0f, 0.0f, this);
783 layerTwo.alpha = 1.0f;
784
785 layersSecond.push_back(&layerTwo);
786 invokeDraw(settings, layersSecond, mBuffer);
787
788 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3, DEFAULT_DISPLAY_HEIGHT / 3), 0, 0, 0, 0);
789 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3 + 1, DEFAULT_DISPLAY_HEIGHT / 3 + 1,
790 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
791 0, 255, 0, 255);
792 }
793
fillRedBufferTextureTransform()794 void RenderEngineTest::fillRedBufferTextureTransform() {
795 renderengine::DisplaySettings settings;
796 settings.physicalDisplay = fullscreenRect();
797 settings.clip = Rect(1, 1);
798
799 std::vector<const renderengine::LayerSettings*> layers;
800
801 renderengine::LayerSettings layer;
802 // Here will allocate a checker board texture, but transform texture
803 // coordinates so that only the upper left is applied.
804 sp<GraphicBuffer> buf = allocateSourceBuffer(2, 2);
805 uint32_t texName;
806 RenderEngineTest::sRE->genTextures(1, &texName);
807 this->mTexNames.push_back(texName);
808
809 uint8_t* pixels;
810 buf->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
811 reinterpret_cast<void**>(&pixels));
812 // Red top left, Green top right, Blue bottom left, Black bottom right
813 pixels[0] = 255;
814 pixels[1] = 0;
815 pixels[2] = 0;
816 pixels[3] = 255;
817 pixels[4] = 0;
818 pixels[5] = 255;
819 pixels[6] = 0;
820 pixels[7] = 255;
821 pixels[8] = 0;
822 pixels[9] = 0;
823 pixels[10] = 255;
824 pixels[11] = 255;
825 buf->unlock();
826
827 layer.source.buffer.buffer = buf;
828 layer.source.buffer.textureName = texName;
829 // Transform coordinates to only be inside the red quadrant.
830 layer.source.buffer.textureTransform = mat4::scale(vec4(0.2, 0.2, 1, 1));
831 layer.alpha = 1.0f;
832 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
833
834 layers.push_back(&layer);
835
836 invokeDraw(settings, layers, mBuffer);
837 }
838
fillBufferTextureTransform()839 void RenderEngineTest::fillBufferTextureTransform() {
840 fillRedBufferTextureTransform();
841 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
842 }
843
fillRedBufferWithPremultiplyAlpha()844 void RenderEngineTest::fillRedBufferWithPremultiplyAlpha() {
845 renderengine::DisplaySettings settings;
846 settings.physicalDisplay = fullscreenRect();
847 // Here logical space is 1x1
848 settings.clip = Rect(1, 1);
849
850 std::vector<const renderengine::LayerSettings*> layers;
851
852 renderengine::LayerSettings layer;
853 sp<GraphicBuffer> buf = allocateSourceBuffer(1, 1);
854 uint32_t texName;
855 RenderEngineTest::sRE->genTextures(1, &texName);
856 this->mTexNames.push_back(texName);
857
858 uint8_t* pixels;
859 buf->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
860 reinterpret_cast<void**>(&pixels));
861 pixels[0] = 255;
862 pixels[1] = 0;
863 pixels[2] = 0;
864 pixels[3] = 255;
865 buf->unlock();
866
867 layer.source.buffer.buffer = buf;
868 layer.source.buffer.textureName = texName;
869 layer.source.buffer.usePremultipliedAlpha = true;
870 layer.alpha = 0.5f;
871 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
872
873 layers.push_back(&layer);
874
875 invokeDraw(settings, layers, mBuffer);
876 }
877
fillBufferWithPremultiplyAlpha()878 void RenderEngineTest::fillBufferWithPremultiplyAlpha() {
879 fillRedBufferWithPremultiplyAlpha();
880 expectBufferColor(fullscreenRect(), 128, 0, 0, 128);
881 }
882
fillRedBufferWithoutPremultiplyAlpha()883 void RenderEngineTest::fillRedBufferWithoutPremultiplyAlpha() {
884 renderengine::DisplaySettings settings;
885 settings.physicalDisplay = fullscreenRect();
886 // Here logical space is 1x1
887 settings.clip = Rect(1, 1);
888
889 std::vector<const renderengine::LayerSettings*> layers;
890
891 renderengine::LayerSettings layer;
892 sp<GraphicBuffer> buf = allocateSourceBuffer(1, 1);
893 uint32_t texName;
894 RenderEngineTest::sRE->genTextures(1, &texName);
895 this->mTexNames.push_back(texName);
896
897 uint8_t* pixels;
898 buf->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
899 reinterpret_cast<void**>(&pixels));
900 pixels[0] = 255;
901 pixels[1] = 0;
902 pixels[2] = 0;
903 pixels[3] = 255;
904 buf->unlock();
905
906 layer.source.buffer.buffer = buf;
907 layer.source.buffer.textureName = texName;
908 layer.source.buffer.usePremultipliedAlpha = false;
909 layer.alpha = 0.5f;
910 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
911
912 layers.push_back(&layer);
913
914 invokeDraw(settings, layers, mBuffer);
915 }
916
fillBufferWithoutPremultiplyAlpha()917 void RenderEngineTest::fillBufferWithoutPremultiplyAlpha() {
918 fillRedBufferWithoutPremultiplyAlpha();
919 expectBufferColor(fullscreenRect(), 128, 0, 0, 64, 1);
920 }
921
clearLeftRegion()922 void RenderEngineTest::clearLeftRegion() {
923 renderengine::DisplaySettings settings;
924 settings.physicalDisplay = fullscreenRect();
925 // Here logical space is 4x4
926 settings.clip = Rect(4, 4);
927 settings.clearRegion = Region(Rect(2, 4));
928 std::vector<const renderengine::LayerSettings*> layers;
929 // dummy layer, without bounds should not render anything
930 renderengine::LayerSettings layer;
931 layers.push_back(&layer);
932 invokeDraw(settings, layers, mBuffer);
933 }
934
clearRegion()935 void RenderEngineTest::clearRegion() {
936 // Reuse mBuffer
937 clearLeftRegion();
938 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 255);
939 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
940 DEFAULT_DISPLAY_HEIGHT),
941 0, 0, 0, 0);
942 }
943
944 template <typename SourceVariant>
drawShadow(const renderengine::LayerSettings & castingLayer,const renderengine::ShadowSettings & shadow,const ubyte4 & casterColor,const ubyte4 & backgroundColor)945 void RenderEngineTest::drawShadow(const renderengine::LayerSettings& castingLayer,
946 const renderengine::ShadowSettings& shadow,
947 const ubyte4& casterColor, const ubyte4& backgroundColor) {
948 renderengine::DisplaySettings settings;
949 settings.physicalDisplay = fullscreenRect();
950 settings.clip = fullscreenRect();
951
952 std::vector<const renderengine::LayerSettings*> layers;
953
954 // add background layer
955 renderengine::LayerSettings bgLayer;
956 bgLayer.geometry.boundaries = fullscreenRect().toFloatRect();
957 ColorSourceVariant::fillColor(bgLayer, backgroundColor.r / 255.0f, backgroundColor.g / 255.0f,
958 backgroundColor.b / 255.0f, this);
959 bgLayer.alpha = backgroundColor.a / 255.0f;
960 layers.push_back(&bgLayer);
961
962 // add shadow layer
963 renderengine::LayerSettings shadowLayer;
964 shadowLayer.geometry.boundaries = castingLayer.geometry.boundaries;
965 shadowLayer.alpha = castingLayer.alpha;
966 shadowLayer.shadow = shadow;
967 layers.push_back(&shadowLayer);
968
969 // add layer casting the shadow
970 renderengine::LayerSettings layer = castingLayer;
971 SourceVariant::fillColor(layer, casterColor.r / 255.0f, casterColor.g / 255.0f,
972 casterColor.b / 255.0f, this);
973 layers.push_back(&layer);
974
975 invokeDraw(settings, layers, mBuffer);
976 }
977
TEST_F(RenderEngineTest,drawLayers_noLayersToDraw)978 TEST_F(RenderEngineTest, drawLayers_noLayersToDraw) {
979 drawEmptyLayers();
980 }
981
TEST_F(RenderEngineTest,drawLayers_nullOutputBuffer)982 TEST_F(RenderEngineTest, drawLayers_nullOutputBuffer) {
983 renderengine::DisplaySettings settings;
984 std::vector<const renderengine::LayerSettings*> layers;
985 renderengine::LayerSettings layer;
986 layer.geometry.boundaries = fullscreenRect().toFloatRect();
987 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
988 layers.push_back(&layer);
989 base::unique_fd fence;
990 status_t status = sRE->drawLayers(settings, layers, nullptr, true, base::unique_fd(), &fence);
991
992 ASSERT_EQ(BAD_VALUE, status);
993 }
994
TEST_F(RenderEngineTest,drawLayers_nullOutputFence)995 TEST_F(RenderEngineTest, drawLayers_nullOutputFence) {
996 renderengine::DisplaySettings settings;
997 settings.physicalDisplay = fullscreenRect();
998 settings.clip = fullscreenRect();
999
1000 std::vector<const renderengine::LayerSettings*> layers;
1001 renderengine::LayerSettings layer;
1002 layer.geometry.boundaries = fullscreenRect().toFloatRect();
1003 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
1004 layer.alpha = 1.0;
1005 layers.push_back(&layer);
1006
1007 status_t status = sRE->drawLayers(settings, layers, mBuffer->getNativeBuffer(), true,
1008 base::unique_fd(), nullptr);
1009 sCurrentBuffer = mBuffer;
1010 ASSERT_EQ(NO_ERROR, status);
1011 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
1012 }
1013
TEST_F(RenderEngineTest,drawLayers_doesNotCacheFramebuffer)1014 TEST_F(RenderEngineTest, drawLayers_doesNotCacheFramebuffer) {
1015 renderengine::DisplaySettings settings;
1016 settings.physicalDisplay = fullscreenRect();
1017 settings.clip = fullscreenRect();
1018
1019 std::vector<const renderengine::LayerSettings*> layers;
1020 renderengine::LayerSettings layer;
1021 layer.geometry.boundaries = fullscreenRect().toFloatRect();
1022 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
1023 layer.alpha = 1.0;
1024 layers.push_back(&layer);
1025
1026 status_t status = sRE->drawLayers(settings, layers, mBuffer->getNativeBuffer(), false,
1027 base::unique_fd(), nullptr);
1028 sCurrentBuffer = mBuffer;
1029 ASSERT_EQ(NO_ERROR, status);
1030 ASSERT_FALSE(sRE->isFramebufferImageCachedForTesting(mBuffer->getId()));
1031 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
1032 }
1033
TEST_F(RenderEngineTest,drawLayers_fillRedBuffer_colorSource)1034 TEST_F(RenderEngineTest, drawLayers_fillRedBuffer_colorSource) {
1035 fillRedBuffer<ColorSourceVariant>();
1036 }
1037
TEST_F(RenderEngineTest,drawLayers_fillGreenBuffer_colorSource)1038 TEST_F(RenderEngineTest, drawLayers_fillGreenBuffer_colorSource) {
1039 fillGreenBuffer<ColorSourceVariant>();
1040 }
1041
TEST_F(RenderEngineTest,drawLayers_fillBlueBuffer_colorSource)1042 TEST_F(RenderEngineTest, drawLayers_fillBlueBuffer_colorSource) {
1043 fillBlueBuffer<ColorSourceVariant>();
1044 }
1045
TEST_F(RenderEngineTest,drawLayers_fillRedTransparentBuffer_colorSource)1046 TEST_F(RenderEngineTest, drawLayers_fillRedTransparentBuffer_colorSource) {
1047 fillRedTransparentBuffer<ColorSourceVariant>();
1048 }
1049
TEST_F(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_colorSource)1050 TEST_F(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_colorSource) {
1051 fillBufferPhysicalOffset<ColorSourceVariant>();
1052 }
1053
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_colorSource)1054 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_colorSource) {
1055 fillBufferCheckersRotate0<ColorSourceVariant>();
1056 }
1057
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_colorSource)1058 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_colorSource) {
1059 fillBufferCheckersRotate90<ColorSourceVariant>();
1060 }
1061
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_colorSource)1062 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_colorSource) {
1063 fillBufferCheckersRotate180<ColorSourceVariant>();
1064 }
1065
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_colorSource)1066 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_colorSource) {
1067 fillBufferCheckersRotate270<ColorSourceVariant>();
1068 }
1069
TEST_F(RenderEngineTest,drawLayers_fillBufferLayerTransform_colorSource)1070 TEST_F(RenderEngineTest, drawLayers_fillBufferLayerTransform_colorSource) {
1071 fillBufferLayerTransform<ColorSourceVariant>();
1072 }
1073
TEST_F(RenderEngineTest,drawLayers_fillBufferColorTransform_colorSource)1074 TEST_F(RenderEngineTest, drawLayers_fillBufferColorTransform_colorSource) {
1075 fillBufferLayerTransform<ColorSourceVariant>();
1076 }
1077
TEST_F(RenderEngineTest,drawLayers_fillBufferRoundedCorners_colorSource)1078 TEST_F(RenderEngineTest, drawLayers_fillBufferRoundedCorners_colorSource) {
1079 fillBufferWithRoundedCorners<ColorSourceVariant>();
1080 }
1081
TEST_F(RenderEngineTest,drawLayers_fillBufferAndBlurBackground_colorSource)1082 TEST_F(RenderEngineTest, drawLayers_fillBufferAndBlurBackground_colorSource) {
1083 fillBufferAndBlurBackground<ColorSourceVariant>();
1084 }
1085
TEST_F(RenderEngineTest,drawLayers_overlayCorners_colorSource)1086 TEST_F(RenderEngineTest, drawLayers_overlayCorners_colorSource) {
1087 overlayCorners<ColorSourceVariant>();
1088 }
1089
TEST_F(RenderEngineTest,drawLayers_fillRedBuffer_opaqueBufferSource)1090 TEST_F(RenderEngineTest, drawLayers_fillRedBuffer_opaqueBufferSource) {
1091 fillRedBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1092 }
1093
TEST_F(RenderEngineTest,drawLayers_fillGreenBuffer_opaqueBufferSource)1094 TEST_F(RenderEngineTest, drawLayers_fillGreenBuffer_opaqueBufferSource) {
1095 fillGreenBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1096 }
1097
TEST_F(RenderEngineTest,drawLayers_fillBlueBuffer_opaqueBufferSource)1098 TEST_F(RenderEngineTest, drawLayers_fillBlueBuffer_opaqueBufferSource) {
1099 fillBlueBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1100 }
1101
TEST_F(RenderEngineTest,drawLayers_fillRedTransparentBuffer_opaqueBufferSource)1102 TEST_F(RenderEngineTest, drawLayers_fillRedTransparentBuffer_opaqueBufferSource) {
1103 fillRedTransparentBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1104 }
1105
TEST_F(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_opaqueBufferSource)1106 TEST_F(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_opaqueBufferSource) {
1107 fillBufferPhysicalOffset<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1108 }
1109
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_opaqueBufferSource)1110 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_opaqueBufferSource) {
1111 fillBufferCheckersRotate0<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1112 }
1113
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_opaqueBufferSource)1114 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_opaqueBufferSource) {
1115 fillBufferCheckersRotate90<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1116 }
1117
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_opaqueBufferSource)1118 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_opaqueBufferSource) {
1119 fillBufferCheckersRotate180<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1120 }
1121
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_opaqueBufferSource)1122 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_opaqueBufferSource) {
1123 fillBufferCheckersRotate270<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1124 }
1125
TEST_F(RenderEngineTest,drawLayers_fillBufferLayerTransform_opaqueBufferSource)1126 TEST_F(RenderEngineTest, drawLayers_fillBufferLayerTransform_opaqueBufferSource) {
1127 fillBufferLayerTransform<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1128 }
1129
TEST_F(RenderEngineTest,drawLayers_fillBufferColorTransform_opaqueBufferSource)1130 TEST_F(RenderEngineTest, drawLayers_fillBufferColorTransform_opaqueBufferSource) {
1131 fillBufferLayerTransform<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1132 }
1133
TEST_F(RenderEngineTest,drawLayers_fillBufferRoundedCorners_opaqueBufferSource)1134 TEST_F(RenderEngineTest, drawLayers_fillBufferRoundedCorners_opaqueBufferSource) {
1135 fillBufferWithRoundedCorners<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1136 }
1137
TEST_F(RenderEngineTest,drawLayers_fillBufferAndBlurBackground_opaqueBufferSource)1138 TEST_F(RenderEngineTest, drawLayers_fillBufferAndBlurBackground_opaqueBufferSource) {
1139 fillBufferAndBlurBackground<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1140 }
1141
TEST_F(RenderEngineTest,drawLayers_overlayCorners_opaqueBufferSource)1142 TEST_F(RenderEngineTest, drawLayers_overlayCorners_opaqueBufferSource) {
1143 overlayCorners<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1144 }
1145
TEST_F(RenderEngineTest,drawLayers_fillRedBuffer_bufferSource)1146 TEST_F(RenderEngineTest, drawLayers_fillRedBuffer_bufferSource) {
1147 fillRedBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1148 }
1149
TEST_F(RenderEngineTest,drawLayers_fillGreenBuffer_bufferSource)1150 TEST_F(RenderEngineTest, drawLayers_fillGreenBuffer_bufferSource) {
1151 fillGreenBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1152 }
1153
TEST_F(RenderEngineTest,drawLayers_fillBlueBuffer_bufferSource)1154 TEST_F(RenderEngineTest, drawLayers_fillBlueBuffer_bufferSource) {
1155 fillBlueBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1156 }
1157
TEST_F(RenderEngineTest,drawLayers_fillRedTransparentBuffer_bufferSource)1158 TEST_F(RenderEngineTest, drawLayers_fillRedTransparentBuffer_bufferSource) {
1159 fillRedTransparentBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1160 }
1161
TEST_F(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_bufferSource)1162 TEST_F(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_bufferSource) {
1163 fillBufferPhysicalOffset<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1164 }
1165
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_bufferSource)1166 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_bufferSource) {
1167 fillBufferCheckersRotate0<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1168 }
1169
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_bufferSource)1170 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_bufferSource) {
1171 fillBufferCheckersRotate90<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1172 }
1173
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_bufferSource)1174 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_bufferSource) {
1175 fillBufferCheckersRotate180<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1176 }
1177
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_bufferSource)1178 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_bufferSource) {
1179 fillBufferCheckersRotate270<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1180 }
1181
TEST_F(RenderEngineTest,drawLayers_fillBufferLayerTransform_bufferSource)1182 TEST_F(RenderEngineTest, drawLayers_fillBufferLayerTransform_bufferSource) {
1183 fillBufferLayerTransform<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1184 }
1185
TEST_F(RenderEngineTest,drawLayers_fillBufferColorTransform_bufferSource)1186 TEST_F(RenderEngineTest, drawLayers_fillBufferColorTransform_bufferSource) {
1187 fillBufferLayerTransform<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1188 }
1189
TEST_F(RenderEngineTest,drawLayers_fillBufferRoundedCorners_bufferSource)1190 TEST_F(RenderEngineTest, drawLayers_fillBufferRoundedCorners_bufferSource) {
1191 fillBufferWithRoundedCorners<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1192 }
1193
TEST_F(RenderEngineTest,drawLayers_fillBufferAndBlurBackground_bufferSource)1194 TEST_F(RenderEngineTest, drawLayers_fillBufferAndBlurBackground_bufferSource) {
1195 fillBufferAndBlurBackground<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1196 }
1197
TEST_F(RenderEngineTest,drawLayers_overlayCorners_bufferSource)1198 TEST_F(RenderEngineTest, drawLayers_overlayCorners_bufferSource) {
1199 overlayCorners<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1200 }
1201
TEST_F(RenderEngineTest,drawLayers_fillBufferTextureTransform)1202 TEST_F(RenderEngineTest, drawLayers_fillBufferTextureTransform) {
1203 fillBufferTextureTransform();
1204 }
1205
TEST_F(RenderEngineTest,drawLayers_fillBuffer_premultipliesAlpha)1206 TEST_F(RenderEngineTest, drawLayers_fillBuffer_premultipliesAlpha) {
1207 fillBufferWithPremultiplyAlpha();
1208 }
1209
TEST_F(RenderEngineTest,drawLayers_fillBuffer_withoutPremultiplyingAlpha)1210 TEST_F(RenderEngineTest, drawLayers_fillBuffer_withoutPremultiplyingAlpha) {
1211 fillBufferWithoutPremultiplyAlpha();
1212 }
1213
TEST_F(RenderEngineTest,drawLayers_clearRegion)1214 TEST_F(RenderEngineTest, drawLayers_clearRegion) {
1215 clearRegion();
1216 }
1217
TEST_F(RenderEngineTest,drawLayers_fillsBufferAndCachesImages)1218 TEST_F(RenderEngineTest, drawLayers_fillsBufferAndCachesImages) {
1219 renderengine::DisplaySettings settings;
1220 settings.physicalDisplay = fullscreenRect();
1221 settings.clip = fullscreenRect();
1222
1223 std::vector<const renderengine::LayerSettings*> layers;
1224
1225 renderengine::LayerSettings layer;
1226 layer.geometry.boundaries = fullscreenRect().toFloatRect();
1227 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
1228
1229 layers.push_back(&layer);
1230 invokeDraw(settings, layers, mBuffer);
1231 uint64_t bufferId = layer.source.buffer.buffer->getId();
1232 EXPECT_TRUE(sRE->isImageCachedForTesting(bufferId));
1233 std::shared_ptr<renderengine::gl::ImageManager::Barrier> barrier =
1234 sRE->unbindExternalTextureBufferForTesting(bufferId);
1235 std::lock_guard<std::mutex> lock(barrier->mutex);
1236 ASSERT_TRUE(barrier->condition.wait_for(barrier->mutex, std::chrono::seconds(5),
1237 [&]() REQUIRES(barrier->mutex) {
1238 return barrier->isOpen;
1239 }));
1240 EXPECT_FALSE(sRE->isImageCachedForTesting(bufferId));
1241 EXPECT_EQ(NO_ERROR, barrier->result);
1242 }
1243
TEST_F(RenderEngineTest,bindExternalBuffer_withNullBuffer)1244 TEST_F(RenderEngineTest, bindExternalBuffer_withNullBuffer) {
1245 status_t result = sRE->bindExternalTextureBuffer(0, nullptr, nullptr);
1246 ASSERT_EQ(BAD_VALUE, result);
1247 }
1248
TEST_F(RenderEngineTest,bindExternalBuffer_cachesImages)1249 TEST_F(RenderEngineTest, bindExternalBuffer_cachesImages) {
1250 sp<GraphicBuffer> buf = allocateSourceBuffer(1, 1);
1251 uint32_t texName;
1252 sRE->genTextures(1, &texName);
1253 mTexNames.push_back(texName);
1254
1255 sRE->bindExternalTextureBuffer(texName, buf, nullptr);
1256 uint64_t bufferId = buf->getId();
1257 EXPECT_TRUE(sRE->isImageCachedForTesting(bufferId));
1258 std::shared_ptr<renderengine::gl::ImageManager::Barrier> barrier =
1259 sRE->unbindExternalTextureBufferForTesting(bufferId);
1260 std::lock_guard<std::mutex> lock(barrier->mutex);
1261 ASSERT_TRUE(barrier->condition.wait_for(barrier->mutex, std::chrono::seconds(5),
1262 [&]() REQUIRES(barrier->mutex) {
1263 return barrier->isOpen;
1264 }));
1265 EXPECT_EQ(NO_ERROR, barrier->result);
1266 EXPECT_FALSE(sRE->isImageCachedForTesting(bufferId));
1267 }
1268
TEST_F(RenderEngineTest,cacheExternalBuffer_withNullBuffer)1269 TEST_F(RenderEngineTest, cacheExternalBuffer_withNullBuffer) {
1270 std::shared_ptr<renderengine::gl::ImageManager::Barrier> barrier =
1271 sRE->cacheExternalTextureBufferForTesting(nullptr);
1272 std::lock_guard<std::mutex> lock(barrier->mutex);
1273 ASSERT_TRUE(barrier->condition.wait_for(barrier->mutex, std::chrono::seconds(5),
1274 [&]() REQUIRES(barrier->mutex) {
1275 return barrier->isOpen;
1276 }));
1277 EXPECT_TRUE(barrier->isOpen);
1278 EXPECT_EQ(BAD_VALUE, barrier->result);
1279 }
1280
TEST_F(RenderEngineTest,cacheExternalBuffer_cachesImages)1281 TEST_F(RenderEngineTest, cacheExternalBuffer_cachesImages) {
1282 sp<GraphicBuffer> buf = allocateSourceBuffer(1, 1);
1283 uint64_t bufferId = buf->getId();
1284 std::shared_ptr<renderengine::gl::ImageManager::Barrier> barrier =
1285 sRE->cacheExternalTextureBufferForTesting(buf);
1286 {
1287 std::lock_guard<std::mutex> lock(barrier->mutex);
1288 ASSERT_TRUE(barrier->condition.wait_for(barrier->mutex, std::chrono::seconds(5),
1289 [&]() REQUIRES(barrier->mutex) {
1290 return barrier->isOpen;
1291 }));
1292 EXPECT_EQ(NO_ERROR, barrier->result);
1293 }
1294 EXPECT_TRUE(sRE->isImageCachedForTesting(bufferId));
1295 barrier = sRE->unbindExternalTextureBufferForTesting(bufferId);
1296 {
1297 std::lock_guard<std::mutex> lock(barrier->mutex);
1298 ASSERT_TRUE(barrier->condition.wait_for(barrier->mutex, std::chrono::seconds(5),
1299 [&]() REQUIRES(barrier->mutex) {
1300 return barrier->isOpen;
1301 }));
1302 EXPECT_EQ(NO_ERROR, barrier->result);
1303 }
1304 EXPECT_FALSE(sRE->isImageCachedForTesting(bufferId));
1305 }
1306
TEST_F(RenderEngineTest,drawLayers_fillShadow_casterLayerMinSize)1307 TEST_F(RenderEngineTest, drawLayers_fillShadow_casterLayerMinSize) {
1308 const ubyte4 casterColor(255, 0, 0, 255);
1309 const ubyte4 backgroundColor(255, 255, 255, 255);
1310 const float shadowLength = 5.0f;
1311 Rect casterBounds(1, 1);
1312 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1313 renderengine::LayerSettings castingLayer;
1314 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1315 castingLayer.alpha = 1.0f;
1316 renderengine::ShadowSettings settings =
1317 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1318 false /* casterIsTranslucent */);
1319
1320 drawShadow<ColorSourceVariant>(castingLayer, settings, casterColor, backgroundColor);
1321 expectShadowColor(castingLayer, settings, casterColor, backgroundColor);
1322 }
1323
TEST_F(RenderEngineTest,drawLayers_fillShadow_casterColorLayer)1324 TEST_F(RenderEngineTest, drawLayers_fillShadow_casterColorLayer) {
1325 const ubyte4 casterColor(255, 0, 0, 255);
1326 const ubyte4 backgroundColor(255, 255, 255, 255);
1327 const float shadowLength = 5.0f;
1328 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1329 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1330 renderengine::LayerSettings castingLayer;
1331 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1332 castingLayer.alpha = 1.0f;
1333 renderengine::ShadowSettings settings =
1334 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1335 false /* casterIsTranslucent */);
1336
1337 drawShadow<ColorSourceVariant>(castingLayer, settings, casterColor, backgroundColor);
1338 expectShadowColor(castingLayer, settings, casterColor, backgroundColor);
1339 }
1340
TEST_F(RenderEngineTest,drawLayers_fillShadow_casterOpaqueBufferLayer)1341 TEST_F(RenderEngineTest, drawLayers_fillShadow_casterOpaqueBufferLayer) {
1342 const ubyte4 casterColor(255, 0, 0, 255);
1343 const ubyte4 backgroundColor(255, 255, 255, 255);
1344 const float shadowLength = 5.0f;
1345 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1346 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1347 renderengine::LayerSettings castingLayer;
1348 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1349 castingLayer.alpha = 1.0f;
1350 renderengine::ShadowSettings settings =
1351 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1352 false /* casterIsTranslucent */);
1353
1354 drawShadow<BufferSourceVariant<ForceOpaqueBufferVariant>>(castingLayer, settings, casterColor,
1355 backgroundColor);
1356 expectShadowColor(castingLayer, settings, casterColor, backgroundColor);
1357 }
1358
TEST_F(RenderEngineTest,drawLayers_fillShadow_casterWithRoundedCorner)1359 TEST_F(RenderEngineTest, drawLayers_fillShadow_casterWithRoundedCorner) {
1360 const ubyte4 casterColor(255, 0, 0, 255);
1361 const ubyte4 backgroundColor(255, 255, 255, 255);
1362 const float shadowLength = 5.0f;
1363 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1364 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1365 renderengine::LayerSettings castingLayer;
1366 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1367 castingLayer.geometry.roundedCornersRadius = 3.0f;
1368 castingLayer.geometry.roundedCornersCrop = casterBounds.toFloatRect();
1369 castingLayer.alpha = 1.0f;
1370 renderengine::ShadowSettings settings =
1371 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1372 false /* casterIsTranslucent */);
1373
1374 drawShadow<BufferSourceVariant<ForceOpaqueBufferVariant>>(castingLayer, settings, casterColor,
1375 backgroundColor);
1376 expectShadowColor(castingLayer, settings, casterColor, backgroundColor);
1377 }
1378
TEST_F(RenderEngineTest,drawLayers_fillShadow_translucentCasterWithAlpha)1379 TEST_F(RenderEngineTest, drawLayers_fillShadow_translucentCasterWithAlpha) {
1380 const ubyte4 casterColor(255, 0, 0, 255);
1381 const ubyte4 backgroundColor(255, 255, 255, 255);
1382 const float shadowLength = 5.0f;
1383 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1384 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1385 renderengine::LayerSettings castingLayer;
1386 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1387 castingLayer.alpha = 0.5f;
1388 renderengine::ShadowSettings settings =
1389 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1390 true /* casterIsTranslucent */);
1391
1392 drawShadow<BufferSourceVariant<RelaxOpaqueBufferVariant>>(castingLayer, settings, casterColor,
1393 backgroundColor);
1394
1395 // verify only the background since the shadow will draw behind the caster
1396 const float shadowInset = settings.length * -1.0f;
1397 const Rect casterWithShadow =
1398 Rect(casterBounds).inset(shadowInset, shadowInset, shadowInset, shadowInset);
1399 const Region backgroundRegion = Region(fullscreenRect()).subtractSelf(casterWithShadow);
1400 expectBufferColor(backgroundRegion, backgroundColor.r, backgroundColor.g, backgroundColor.b,
1401 backgroundColor.a);
1402 }
1403
TEST_F(RenderEngineTest,cleanupPostRender_cleansUpOnce)1404 TEST_F(RenderEngineTest, cleanupPostRender_cleansUpOnce) {
1405 renderengine::DisplaySettings settings;
1406 settings.physicalDisplay = fullscreenRect();
1407 settings.clip = fullscreenRect();
1408
1409 std::vector<const renderengine::LayerSettings*> layers;
1410 renderengine::LayerSettings layer;
1411 layer.geometry.boundaries = fullscreenRect().toFloatRect();
1412 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
1413 layer.alpha = 1.0;
1414 layers.push_back(&layer);
1415
1416 base::unique_fd fenceOne;
1417 sRE->drawLayers(settings, layers, mBuffer->getNativeBuffer(), true, base::unique_fd(),
1418 &fenceOne);
1419 base::unique_fd fenceTwo;
1420 sRE->drawLayers(settings, layers, mBuffer->getNativeBuffer(), true, std::move(fenceOne),
1421 &fenceTwo);
1422
1423 const int fd = fenceTwo.get();
1424 if (fd >= 0) {
1425 sync_wait(fd, -1);
1426 }
1427
1428 // Only cleanup the first time.
1429 EXPECT_TRUE(sRE->cleanupPostRender());
1430 EXPECT_FALSE(sRE->cleanupPostRender());
1431 }
1432
1433 } // namespace android
1434
1435 // TODO(b/129481165): remove the #pragma below and fix conversion issues
1436 #pragma clang diagnostic pop // ignored "-Wconversion"
1437