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 #undef LOG_TAG
18 #define LOG_TAG "RenderEngineTest"
19
20 // TODO(b/129481165): remove the #pragma below and fix conversion issues
21 #pragma clang diagnostic push
22 #pragma clang diagnostic ignored "-Wconversion"
23 #pragma clang diagnostic ignored "-Wextra"
24
25 #include <cutils/properties.h>
26 #include <gtest/gtest.h>
27 #include <renderengine/ExternalTexture.h>
28 #include <renderengine/RenderEngine.h>
29 #include <sync/sync.h>
30 #include <ui/PixelFormat.h>
31
32 #include <chrono>
33 #include <condition_variable>
34 #include <fstream>
35
36 #include "../gl/GLESRenderEngine.h"
37 #include "../skia/SkiaGLRenderEngine.h"
38 #include "../threaded/RenderEngineThreaded.h"
39
40 constexpr int DEFAULT_DISPLAY_WIDTH = 128;
41 constexpr int DEFAULT_DISPLAY_HEIGHT = 256;
42 constexpr int DEFAULT_DISPLAY_OFFSET = 64;
43 constexpr bool WRITE_BUFFER_TO_FILE_ON_FAILURE = false;
44
45 namespace android {
46 namespace renderengine {
47
48 class RenderEngineFactory {
49 public:
50 virtual ~RenderEngineFactory() = default;
51
52 virtual std::string name() = 0;
53 virtual renderengine::RenderEngine::RenderEngineType type() = 0;
54 virtual std::unique_ptr<renderengine::RenderEngine> createRenderEngine() = 0;
createGLESRenderEngine()55 virtual std::unique_ptr<renderengine::gl::GLESRenderEngine> createGLESRenderEngine() {
56 return nullptr;
57 }
58 virtual bool useColorManagement() const = 0;
59 };
60
61 class GLESRenderEngineFactory : public RenderEngineFactory {
62 public:
name()63 std::string name() override { return "GLESRenderEngineFactory"; }
64
type()65 renderengine::RenderEngine::RenderEngineType type() {
66 return renderengine::RenderEngine::RenderEngineType::GLES;
67 }
68
createRenderEngine()69 std::unique_ptr<renderengine::RenderEngine> createRenderEngine() override {
70 return createGLESRenderEngine();
71 }
72
createGLESRenderEngine()73 std::unique_ptr<renderengine::gl::GLESRenderEngine> createGLESRenderEngine() {
74 renderengine::RenderEngineCreationArgs reCreationArgs =
75 renderengine::RenderEngineCreationArgs::Builder()
76 .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))
77 .setImageCacheSize(1)
78 .setUseColorManagerment(false)
79 .setEnableProtectedContext(false)
80 .setPrecacheToneMapperShaderOnly(false)
81 .setSupportsBackgroundBlur(true)
82 .setContextPriority(renderengine::RenderEngine::ContextPriority::MEDIUM)
83 .setRenderEngineType(type())
84 .setUseColorManagerment(useColorManagement())
85 .build();
86 return renderengine::gl::GLESRenderEngine::create(reCreationArgs);
87 }
88
useColorManagement() const89 bool useColorManagement() const override { return false; }
90 };
91
92 class GLESCMRenderEngineFactory : public RenderEngineFactory {
93 public:
name()94 std::string name() override { return "GLESCMRenderEngineFactory"; }
95
type()96 renderengine::RenderEngine::RenderEngineType type() {
97 return renderengine::RenderEngine::RenderEngineType::GLES;
98 }
99
createRenderEngine()100 std::unique_ptr<renderengine::RenderEngine> createRenderEngine() override {
101 return createGLESRenderEngine();
102 }
103
createGLESRenderEngine()104 std::unique_ptr<renderengine::gl::GLESRenderEngine> createGLESRenderEngine() override {
105 renderengine::RenderEngineCreationArgs reCreationArgs =
106 renderengine::RenderEngineCreationArgs::Builder()
107 .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))
108 .setImageCacheSize(1)
109 .setEnableProtectedContext(false)
110 .setPrecacheToneMapperShaderOnly(false)
111 .setSupportsBackgroundBlur(true)
112 .setContextPriority(renderengine::RenderEngine::ContextPriority::MEDIUM)
113 .setRenderEngineType(type())
114 .setUseColorManagerment(useColorManagement())
115 .build();
116 return renderengine::gl::GLESRenderEngine::create(reCreationArgs);
117 }
118
useColorManagement() const119 bool useColorManagement() const override { return true; }
120 };
121
122 class SkiaGLESRenderEngineFactory : public RenderEngineFactory {
123 public:
name()124 std::string name() override { return "SkiaGLRenderEngineFactory"; }
125
type()126 renderengine::RenderEngine::RenderEngineType type() {
127 return renderengine::RenderEngine::RenderEngineType::SKIA_GL;
128 }
129
createRenderEngine()130 std::unique_ptr<renderengine::RenderEngine> createRenderEngine() override {
131 renderengine::RenderEngineCreationArgs reCreationArgs =
132 renderengine::RenderEngineCreationArgs::Builder()
133 .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))
134 .setImageCacheSize(1)
135 .setEnableProtectedContext(false)
136 .setPrecacheToneMapperShaderOnly(false)
137 .setSupportsBackgroundBlur(true)
138 .setContextPriority(renderengine::RenderEngine::ContextPriority::MEDIUM)
139 .setRenderEngineType(type())
140 .setUseColorManagerment(useColorManagement())
141 .build();
142 return renderengine::skia::SkiaGLRenderEngine::create(reCreationArgs);
143 }
144
useColorManagement() const145 bool useColorManagement() const override { return false; }
146 };
147
148 class SkiaGLESCMRenderEngineFactory : public RenderEngineFactory {
149 public:
name()150 std::string name() override { return "SkiaGLCMRenderEngineFactory"; }
151
type()152 renderengine::RenderEngine::RenderEngineType type() {
153 return renderengine::RenderEngine::RenderEngineType::SKIA_GL;
154 }
155
createRenderEngine()156 std::unique_ptr<renderengine::RenderEngine> createRenderEngine() override {
157 renderengine::RenderEngineCreationArgs reCreationArgs =
158 renderengine::RenderEngineCreationArgs::Builder()
159 .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))
160 .setImageCacheSize(1)
161 .setEnableProtectedContext(false)
162 .setPrecacheToneMapperShaderOnly(false)
163 .setSupportsBackgroundBlur(true)
164 .setContextPriority(renderengine::RenderEngine::ContextPriority::MEDIUM)
165 .setRenderEngineType(type())
166 .setUseColorManagerment(useColorManagement())
167 .build();
168 return renderengine::skia::SkiaGLRenderEngine::create(reCreationArgs);
169 }
170
useColorManagement() const171 bool useColorManagement() const override { return true; }
172 };
173
174 class RenderEngineTest : public ::testing::TestWithParam<std::shared_ptr<RenderEngineFactory>> {
175 public:
allocateDefaultBuffer()176 std::shared_ptr<renderengine::ExternalTexture> allocateDefaultBuffer() {
177 return std::make_shared<
178 renderengine::
179 ExternalTexture>(new GraphicBuffer(DEFAULT_DISPLAY_WIDTH,
180 DEFAULT_DISPLAY_HEIGHT,
181 HAL_PIXEL_FORMAT_RGBA_8888, 1,
182 GRALLOC_USAGE_SW_READ_OFTEN |
183 GRALLOC_USAGE_SW_WRITE_OFTEN |
184 GRALLOC_USAGE_HW_RENDER |
185 GRALLOC_USAGE_HW_TEXTURE,
186 "output"),
187 *mRE,
188 renderengine::ExternalTexture::Usage::READABLE |
189 renderengine::ExternalTexture::Usage::WRITEABLE);
190 }
191
192 // Allocates a 1x1 buffer to fill with a solid color
allocateSourceBuffer(uint32_t width,uint32_t height)193 std::shared_ptr<renderengine::ExternalTexture> allocateSourceBuffer(uint32_t width,
194 uint32_t height) {
195 return std::make_shared<
196 renderengine::
197 ExternalTexture>(new GraphicBuffer(width, height,
198 HAL_PIXEL_FORMAT_RGBA_8888, 1,
199 GRALLOC_USAGE_SW_READ_OFTEN |
200 GRALLOC_USAGE_SW_WRITE_OFTEN |
201 GRALLOC_USAGE_HW_TEXTURE,
202 "input"),
203 *mRE,
204 renderengine::ExternalTexture::Usage::READABLE |
205 renderengine::ExternalTexture::Usage::WRITEABLE);
206 }
207
RenderEngineTest()208 RenderEngineTest() {
209 const ::testing::TestInfo* const test_info =
210 ::testing::UnitTest::GetInstance()->current_test_info();
211 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
212 }
213
~RenderEngineTest()214 ~RenderEngineTest() {
215 if (WRITE_BUFFER_TO_FILE_ON_FAILURE && ::testing::Test::HasFailure()) {
216 writeBufferToFile("/data/texture_out_");
217 }
218 for (uint32_t texName : mTexNames) {
219 mRE->deleteTextures(1, &texName);
220 if (mGLESRE != nullptr) {
221 EXPECT_FALSE(mGLESRE->isTextureNameKnownForTesting(texName));
222 }
223 }
224 const ::testing::TestInfo* const test_info =
225 ::testing::UnitTest::GetInstance()->current_test_info();
226 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
227 }
228
writeBufferToFile(const char * basename)229 void writeBufferToFile(const char* basename) {
230 std::string filename(basename);
231 filename.append(::testing::UnitTest::GetInstance()->current_test_info()->name());
232 filename.append(".ppm");
233 std::ofstream file(filename.c_str(), std::ios::binary);
234 if (!file.is_open()) {
235 ALOGE("Unable to open file: %s", filename.c_str());
236 ALOGE("You may need to do: \"adb shell setenforce 0\" to enable "
237 "surfaceflinger to write debug images");
238 return;
239 }
240
241 uint8_t* pixels;
242 mBuffer->getBuffer()->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
243 reinterpret_cast<void**>(&pixels));
244
245 file << "P6\n";
246 file << mBuffer->getBuffer()->getWidth() << "\n";
247 file << mBuffer->getBuffer()->getHeight() << "\n";
248 file << 255 << "\n";
249
250 std::vector<uint8_t> outBuffer(mBuffer->getBuffer()->getWidth() *
251 mBuffer->getBuffer()->getHeight() * 3);
252 auto outPtr = reinterpret_cast<uint8_t*>(outBuffer.data());
253
254 for (int32_t j = 0; j < mBuffer->getBuffer()->getHeight(); j++) {
255 const uint8_t* src = pixels + (mBuffer->getBuffer()->getStride() * j) * 4;
256 for (int32_t i = 0; i < mBuffer->getBuffer()->getWidth(); i++) {
257 // Only copy R, G and B components
258 outPtr[0] = src[0];
259 outPtr[1] = src[1];
260 outPtr[2] = src[2];
261 outPtr += 3;
262
263 src += 4;
264 }
265 }
266 file.write(reinterpret_cast<char*>(outBuffer.data()), outBuffer.size());
267 mBuffer->getBuffer()->unlock();
268 }
269
expectBufferColor(const Region & region,uint8_t r,uint8_t g,uint8_t b,uint8_t a)270 void expectBufferColor(const Region& region, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
271 size_t c;
272 Rect const* rect = region.getArray(&c);
273 for (size_t i = 0; i < c; i++, rect++) {
274 expectBufferColor(*rect, r, g, b, a);
275 }
276 }
277
expectBufferColor(const Point & point,uint8_t r,uint8_t g,uint8_t b,uint8_t a,uint8_t tolerance=0)278 void expectBufferColor(const Point& point, uint8_t r, uint8_t g, uint8_t b, uint8_t a,
279 uint8_t tolerance = 0) {
280 expectBufferColor(Rect(point.x, point.y, point.x + 1, point.y + 1), r, g, b, a, tolerance);
281 }
282
expectBufferColor(const Rect & rect,uint8_t r,uint8_t g,uint8_t b,uint8_t a,uint8_t tolerance=0)283 void expectBufferColor(const Rect& rect, uint8_t r, uint8_t g, uint8_t b, uint8_t a,
284 uint8_t tolerance = 0) {
285 auto colorCompare = [tolerance](const uint8_t* colorA, const uint8_t* colorB) {
286 auto colorBitCompare = [tolerance](uint8_t a, uint8_t b) {
287 uint8_t tmp = a >= b ? a - b : b - a;
288 return tmp <= tolerance;
289 };
290 return std::equal(colorA, colorA + 4, colorB, colorBitCompare);
291 };
292
293 expectBufferColor(rect, r, g, b, a, colorCompare);
294 }
295
expectBufferColor(const Rect & region,uint8_t r,uint8_t g,uint8_t b,uint8_t a,std::function<bool (const uint8_t * a,const uint8_t * b)> colorCompare)296 void expectBufferColor(const Rect& region, uint8_t r, uint8_t g, uint8_t b, uint8_t a,
297 std::function<bool(const uint8_t* a, const uint8_t* b)> colorCompare) {
298 uint8_t* pixels;
299 mBuffer->getBuffer()->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
300 reinterpret_cast<void**>(&pixels));
301 int32_t maxFails = 10;
302 int32_t fails = 0;
303 for (int32_t j = 0; j < region.getHeight(); j++) {
304 const uint8_t* src = pixels +
305 (mBuffer->getBuffer()->getStride() * (region.top + j) + region.left) * 4;
306 for (int32_t i = 0; i < region.getWidth(); i++) {
307 const uint8_t expected[4] = {r, g, b, a};
308 bool equal = colorCompare(src, expected);
309 EXPECT_TRUE(equal)
310 << GetParam()->name().c_str() << ": "
311 << "pixel @ (" << region.left + i << ", " << region.top + j << "): "
312 << "expected (" << static_cast<uint32_t>(r) << ", "
313 << static_cast<uint32_t>(g) << ", " << static_cast<uint32_t>(b) << ", "
314 << static_cast<uint32_t>(a) << "), "
315 << "got (" << static_cast<uint32_t>(src[0]) << ", "
316 << static_cast<uint32_t>(src[1]) << ", " << static_cast<uint32_t>(src[2])
317 << ", " << static_cast<uint32_t>(src[3]) << ")";
318 src += 4;
319 if (!equal && ++fails >= maxFails) {
320 break;
321 }
322 }
323 if (fails >= maxFails) {
324 break;
325 }
326 }
327 mBuffer->getBuffer()->unlock();
328 }
329
expectAlpha(const Rect & rect,uint8_t a)330 void expectAlpha(const Rect& rect, uint8_t a) {
331 auto colorCompare = [](const uint8_t* colorA, const uint8_t* colorB) {
332 return colorA[3] == colorB[3];
333 };
334 expectBufferColor(rect, 0.0f /* r */, 0.0f /*g */, 0.0f /* b */, a, colorCompare);
335 }
336
expectShadowColor(const renderengine::LayerSettings & castingLayer,const renderengine::ShadowSettings & shadow,const ubyte4 & casterColor,const ubyte4 & backgroundColor)337 void expectShadowColor(const renderengine::LayerSettings& castingLayer,
338 const renderengine::ShadowSettings& shadow, const ubyte4& casterColor,
339 const ubyte4& backgroundColor) {
340 const Rect casterRect(castingLayer.geometry.boundaries);
341 Region casterRegion = Region(casterRect);
342 const float casterCornerRadius = castingLayer.geometry.roundedCornersRadius;
343 if (casterCornerRadius > 0.0f) {
344 // ignore the corners if a corner radius is set
345 Rect cornerRect(casterCornerRadius, casterCornerRadius);
346 casterRegion.subtractSelf(cornerRect.offsetTo(casterRect.left, casterRect.top));
347 casterRegion.subtractSelf(
348 cornerRect.offsetTo(casterRect.right - casterCornerRadius, casterRect.top));
349 casterRegion.subtractSelf(
350 cornerRect.offsetTo(casterRect.left, casterRect.bottom - casterCornerRadius));
351 casterRegion.subtractSelf(cornerRect.offsetTo(casterRect.right - casterCornerRadius,
352 casterRect.bottom - casterCornerRadius));
353 }
354
355 const float shadowInset = shadow.length * -1.0f;
356 const Rect casterWithShadow =
357 Rect(casterRect).inset(shadowInset, shadowInset, shadowInset, shadowInset);
358 const Region shadowRegion = Region(casterWithShadow).subtractSelf(casterRect);
359 const Region backgroundRegion = Region(fullscreenRect()).subtractSelf(casterWithShadow);
360
361 // verify casting layer
362 expectBufferColor(casterRegion, casterColor.r, casterColor.g, casterColor.b, casterColor.a);
363
364 // verify shadows by testing just the alpha since its difficult to validate the shadow color
365 size_t c;
366 Rect const* r = shadowRegion.getArray(&c);
367 for (size_t i = 0; i < c; i++, r++) {
368 expectAlpha(*r, 255);
369 }
370
371 // verify background
372 expectBufferColor(backgroundRegion, backgroundColor.r, backgroundColor.g, backgroundColor.b,
373 backgroundColor.a);
374 }
375
expectShadowColorWithoutCaster(const FloatRect & casterBounds,const renderengine::ShadowSettings & shadow,const ubyte4 & backgroundColor)376 void expectShadowColorWithoutCaster(const FloatRect& casterBounds,
377 const renderengine::ShadowSettings& shadow,
378 const ubyte4& backgroundColor) {
379 const float shadowInset = shadow.length * -1.0f;
380 const Rect casterRect(casterBounds);
381 const Rect shadowRect =
382 Rect(casterRect).inset(shadowInset, shadowInset, shadowInset, shadowInset);
383
384 const Region backgroundRegion =
385 Region(fullscreenRect()).subtractSelf(casterRect).subtractSelf(shadowRect);
386
387 expectAlpha(shadowRect, 255);
388 // (0, 0, 0) fill on the bounds of the layer should be ignored.
389 expectBufferColor(casterRect, 255, 255, 255, 255, 254);
390
391 // verify background
392 expectBufferColor(backgroundRegion, backgroundColor.r, backgroundColor.g, backgroundColor.b,
393 backgroundColor.a);
394 }
395
getShadowSettings(const vec2 & casterPos,float shadowLength,bool casterIsTranslucent)396 static renderengine::ShadowSettings getShadowSettings(const vec2& casterPos, float shadowLength,
397 bool casterIsTranslucent) {
398 renderengine::ShadowSettings shadow;
399 shadow.ambientColor = {0.0f, 0.0f, 0.0f, 0.039f};
400 shadow.spotColor = {0.0f, 0.0f, 0.0f, 0.19f};
401 shadow.lightPos = vec3(casterPos.x, casterPos.y, 0);
402 shadow.lightRadius = 0.0f;
403 shadow.length = shadowLength;
404 shadow.casterIsTranslucent = casterIsTranslucent;
405 return shadow;
406 }
407
fullscreenRect()408 static Rect fullscreenRect() { return Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT); }
409
offsetRect()410 static Rect offsetRect() {
411 return Rect(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_WIDTH,
412 DEFAULT_DISPLAY_HEIGHT);
413 }
414
offsetRectAtZero()415 static Rect offsetRectAtZero() {
416 return Rect(DEFAULT_DISPLAY_WIDTH - DEFAULT_DISPLAY_OFFSET,
417 DEFAULT_DISPLAY_HEIGHT - DEFAULT_DISPLAY_OFFSET);
418 }
419
invokeDraw(renderengine::DisplaySettings settings,std::vector<const renderengine::LayerSettings * > layers)420 void invokeDraw(renderengine::DisplaySettings settings,
421 std::vector<const renderengine::LayerSettings*> layers) {
422 base::unique_fd fence;
423 status_t status =
424 mRE->drawLayers(settings, layers, mBuffer, true, base::unique_fd(), &fence);
425
426 int fd = fence.release();
427 if (fd >= 0) {
428 sync_wait(fd, -1);
429 close(fd);
430 }
431
432 ASSERT_EQ(NO_ERROR, status);
433 if (layers.size() > 0 && mGLESRE != nullptr) {
434 ASSERT_TRUE(mGLESRE->isFramebufferImageCachedForTesting(mBuffer->getBuffer()->getId()));
435 }
436 }
437
drawEmptyLayers()438 void drawEmptyLayers() {
439 renderengine::DisplaySettings settings;
440 std::vector<const renderengine::LayerSettings*> layers;
441 invokeDraw(settings, layers);
442 }
443
444 template <typename SourceVariant>
445 void fillBuffer(half r, half g, half b, half a);
446
447 template <typename SourceVariant>
448 void fillRedBuffer();
449
450 template <typename SourceVariant>
451 void fillGreenBuffer();
452
453 template <typename SourceVariant>
454 void fillBlueBuffer();
455
456 template <typename SourceVariant>
457 void fillRedTransparentBuffer();
458
459 template <typename SourceVariant>
460 void fillRedOffsetBuffer();
461
462 template <typename SourceVariant>
463 void fillBufferPhysicalOffset();
464
465 template <typename SourceVariant>
466 void fillBufferCheckers(uint32_t rotation);
467
468 template <typename SourceVariant>
469 void fillBufferCheckersRotate0();
470
471 template <typename SourceVariant>
472 void fillBufferCheckersRotate90();
473
474 template <typename SourceVariant>
475 void fillBufferCheckersRotate180();
476
477 template <typename SourceVariant>
478 void fillBufferCheckersRotate270();
479
480 template <typename SourceVariant>
481 void fillBufferWithLayerTransform();
482
483 template <typename SourceVariant>
484 void fillBufferLayerTransform();
485
486 template <typename SourceVariant>
487 void fillBufferWithColorTransform();
488
489 template <typename SourceVariant>
490 void fillBufferColorTransform();
491
492 template <typename SourceVariant>
493 void fillBufferWithColorTransformZeroLayerAlpha();
494
495 template <typename SourceVariant>
496 void fillBufferColorTransformZeroLayerAlpha();
497
498 template <typename SourceVariant>
499 void fillRedBufferWithRoundedCorners();
500
501 template <typename SourceVariant>
502 void fillBufferWithRoundedCorners();
503
504 template <typename SourceVariant>
505 void fillBufferAndBlurBackground();
506
507 template <typename SourceVariant>
508 void fillSmallLayerAndBlurBackground();
509
510 template <typename SourceVariant>
511 void overlayCorners();
512
513 void fillRedBufferTextureTransform();
514
515 void fillBufferTextureTransform();
516
517 void fillRedBufferWithPremultiplyAlpha();
518
519 void fillBufferWithPremultiplyAlpha();
520
521 void fillRedBufferWithoutPremultiplyAlpha();
522
523 void fillBufferWithoutPremultiplyAlpha();
524
525 void fillGreenColorBufferThenClearRegion();
526
527 void clearLeftRegion();
528
529 void clearRegion();
530
531 template <typename SourceVariant>
532 void drawShadow(const renderengine::LayerSettings& castingLayer,
533 const renderengine::ShadowSettings& shadow, const ubyte4& casterColor,
534 const ubyte4& backgroundColor);
535
536 void drawShadowWithoutCaster(const FloatRect& castingBounds,
537 const renderengine::ShadowSettings& shadow,
538 const ubyte4& backgroundColor);
539
540 void initializeRenderEngine();
541
542 std::unique_ptr<renderengine::RenderEngine> mRE;
543 std::shared_ptr<renderengine::ExternalTexture> mBuffer;
544 // GLESRenderEngine for testing GLES-specific behavior.
545 // Owened by mRE, but this is downcasted.
546 renderengine::gl::GLESRenderEngine* mGLESRE = nullptr;
547
548 std::vector<uint32_t> mTexNames;
549 };
550
initializeRenderEngine()551 void RenderEngineTest::initializeRenderEngine() {
552 const auto& renderEngineFactory = GetParam();
553 if (renderEngineFactory->type() == renderengine::RenderEngine::RenderEngineType::GLES) {
554 // Only GLESRenderEngine exposes test-only methods. Provide a pointer to the
555 // GLESRenderEngine if we're using it so that we don't need to dynamic_cast
556 // every time.
557 std::unique_ptr<renderengine::gl::GLESRenderEngine> renderEngine =
558 renderEngineFactory->createGLESRenderEngine();
559 mGLESRE = renderEngine.get();
560 mRE = std::move(renderEngine);
561 } else {
562 mRE = renderEngineFactory->createRenderEngine();
563 }
564 mBuffer = allocateDefaultBuffer();
565 }
566
567 struct ColorSourceVariant {
fillColorandroid::renderengine::ColorSourceVariant568 static void fillColor(renderengine::LayerSettings& layer, half r, half g, half b,
569 RenderEngineTest* /*fixture*/) {
570 layer.source.solidColor = half3(r, g, b);
571 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
572 }
573 };
574
575 struct RelaxOpaqueBufferVariant {
setOpaqueBitandroid::renderengine::RelaxOpaqueBufferVariant576 static void setOpaqueBit(renderengine::LayerSettings& layer) {
577 layer.source.buffer.isOpaque = false;
578 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
579 }
580
getAlphaChannelandroid::renderengine::RelaxOpaqueBufferVariant581 static uint8_t getAlphaChannel() { return 255; }
582 };
583
584 struct ForceOpaqueBufferVariant {
setOpaqueBitandroid::renderengine::ForceOpaqueBufferVariant585 static void setOpaqueBit(renderengine::LayerSettings& layer) {
586 layer.source.buffer.isOpaque = true;
587 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
588 }
589
getAlphaChannelandroid::renderengine::ForceOpaqueBufferVariant590 static uint8_t getAlphaChannel() {
591 // The isOpaque bit will override the alpha channel, so this should be
592 // arbitrary.
593 return 50;
594 }
595 };
596
597 template <typename OpaquenessVariant>
598 struct BufferSourceVariant {
fillColorandroid::renderengine::BufferSourceVariant599 static void fillColor(renderengine::LayerSettings& layer, half r, half g, half b,
600 RenderEngineTest* fixture) {
601 const auto buf = fixture->allocateSourceBuffer(1, 1);
602 uint32_t texName;
603 fixture->mRE->genTextures(1, &texName);
604 fixture->mTexNames.push_back(texName);
605
606 uint8_t* pixels;
607 buf->getBuffer()->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
608 reinterpret_cast<void**>(&pixels));
609
610 for (int32_t j = 0; j < buf->getBuffer()->getHeight(); j++) {
611 uint8_t* iter = pixels + (buf->getBuffer()->getStride() * j) * 4;
612 for (int32_t i = 0; i < buf->getBuffer()->getWidth(); i++) {
613 iter[0] = uint8_t(r * 255);
614 iter[1] = uint8_t(g * 255);
615 iter[2] = uint8_t(b * 255);
616 iter[3] = OpaquenessVariant::getAlphaChannel();
617 iter += 4;
618 }
619 }
620
621 buf->getBuffer()->unlock();
622
623 layer.source.buffer.buffer = buf;
624 layer.source.buffer.textureName = texName;
625 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
626 OpaquenessVariant::setOpaqueBit(layer);
627 }
628 };
629
630 template <typename SourceVariant>
fillBuffer(half r,half g,half b,half a)631 void RenderEngineTest::fillBuffer(half r, half g, half b, half a) {
632 renderengine::DisplaySettings settings;
633 settings.physicalDisplay = fullscreenRect();
634 settings.clip = fullscreenRect();
635 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
636
637 std::vector<const renderengine::LayerSettings*> layers;
638
639 renderengine::LayerSettings layer;
640 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
641 layer.geometry.boundaries = fullscreenRect().toFloatRect();
642 SourceVariant::fillColor(layer, r, g, b, this);
643 layer.alpha = a;
644
645 layers.push_back(&layer);
646
647 invokeDraw(settings, layers);
648 }
649
650 template <typename SourceVariant>
fillRedBuffer()651 void RenderEngineTest::fillRedBuffer() {
652 fillBuffer<SourceVariant>(1.0f, 0.0f, 0.0f, 1.0f);
653 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
654 }
655
656 template <typename SourceVariant>
fillGreenBuffer()657 void RenderEngineTest::fillGreenBuffer() {
658 fillBuffer<SourceVariant>(0.0f, 1.0f, 0.0f, 1.0f);
659 expectBufferColor(fullscreenRect(), 0, 255, 0, 255);
660 }
661
662 template <typename SourceVariant>
fillBlueBuffer()663 void RenderEngineTest::fillBlueBuffer() {
664 fillBuffer<SourceVariant>(0.0f, 0.0f, 1.0f, 1.0f);
665 expectBufferColor(fullscreenRect(), 0, 0, 255, 255);
666 }
667
668 template <typename SourceVariant>
fillRedTransparentBuffer()669 void RenderEngineTest::fillRedTransparentBuffer() {
670 fillBuffer<SourceVariant>(1.0f, 0.0f, 0.0f, .2f);
671 expectBufferColor(fullscreenRect(), 51, 0, 0, 51);
672 }
673
674 template <typename SourceVariant>
fillRedOffsetBuffer()675 void RenderEngineTest::fillRedOffsetBuffer() {
676 renderengine::DisplaySettings settings;
677 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
678 settings.physicalDisplay = offsetRect();
679 settings.clip = offsetRectAtZero();
680
681 std::vector<const renderengine::LayerSettings*> layers;
682
683 renderengine::LayerSettings layer;
684 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
685 layer.geometry.boundaries = offsetRectAtZero().toFloatRect();
686 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
687 layer.alpha = 1.0f;
688
689 layers.push_back(&layer);
690 invokeDraw(settings, layers);
691 }
692
693 template <typename SourceVariant>
fillBufferPhysicalOffset()694 void RenderEngineTest::fillBufferPhysicalOffset() {
695 fillRedOffsetBuffer<SourceVariant>();
696
697 expectBufferColor(Rect(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_WIDTH,
698 DEFAULT_DISPLAY_HEIGHT),
699 255, 0, 0, 255);
700 Rect offsetRegionLeft(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_HEIGHT);
701 Rect offsetRegionTop(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_OFFSET);
702
703 expectBufferColor(offsetRegionLeft, 0, 0, 0, 0);
704 expectBufferColor(offsetRegionTop, 0, 0, 0, 0);
705 }
706
707 template <typename SourceVariant>
fillBufferCheckers(uint32_t orientationFlag)708 void RenderEngineTest::fillBufferCheckers(uint32_t orientationFlag) {
709 renderengine::DisplaySettings settings;
710 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
711 settings.physicalDisplay = fullscreenRect();
712 // Here logical space is 2x2
713 settings.clip = Rect(2, 2);
714 settings.orientation = orientationFlag;
715
716 std::vector<const renderengine::LayerSettings*> layers;
717
718 renderengine::LayerSettings layerOne;
719 layerOne.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
720 Rect rectOne(0, 0, 1, 1);
721 layerOne.geometry.boundaries = rectOne.toFloatRect();
722 SourceVariant::fillColor(layerOne, 1.0f, 0.0f, 0.0f, this);
723 layerOne.alpha = 1.0f;
724
725 renderengine::LayerSettings layerTwo;
726 layerTwo.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
727 Rect rectTwo(0, 1, 1, 2);
728 layerTwo.geometry.boundaries = rectTwo.toFloatRect();
729 SourceVariant::fillColor(layerTwo, 0.0f, 1.0f, 0.0f, this);
730 layerTwo.alpha = 1.0f;
731
732 renderengine::LayerSettings layerThree;
733 layerThree.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
734 Rect rectThree(1, 0, 2, 1);
735 layerThree.geometry.boundaries = rectThree.toFloatRect();
736 SourceVariant::fillColor(layerThree, 0.0f, 0.0f, 1.0f, this);
737 layerThree.alpha = 1.0f;
738
739 layers.push_back(&layerOne);
740 layers.push_back(&layerTwo);
741 layers.push_back(&layerThree);
742
743 invokeDraw(settings, layers);
744 }
745
746 template <typename SourceVariant>
fillBufferCheckersRotate0()747 void RenderEngineTest::fillBufferCheckersRotate0() {
748 fillBufferCheckers<SourceVariant>(ui::Transform::ROT_0);
749 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 255, 0, 0,
750 255);
751 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
752 DEFAULT_DISPLAY_HEIGHT / 2),
753 0, 0, 255, 255);
754 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
755 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
756 0, 0, 0, 0);
757 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
758 DEFAULT_DISPLAY_HEIGHT),
759 0, 255, 0, 255);
760 }
761
762 template <typename SourceVariant>
fillBufferCheckersRotate90()763 void RenderEngineTest::fillBufferCheckersRotate90() {
764 fillBufferCheckers<SourceVariant>(ui::Transform::ROT_90);
765 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 255, 0,
766 255);
767 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
768 DEFAULT_DISPLAY_HEIGHT / 2),
769 255, 0, 0, 255);
770 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
771 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
772 0, 0, 255, 255);
773 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
774 DEFAULT_DISPLAY_HEIGHT),
775 0, 0, 0, 0);
776 }
777
778 template <typename SourceVariant>
fillBufferCheckersRotate180()779 void RenderEngineTest::fillBufferCheckersRotate180() {
780 fillBufferCheckers<SourceVariant>(ui::Transform::ROT_180);
781 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 0,
782 0);
783 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
784 DEFAULT_DISPLAY_HEIGHT / 2),
785 0, 255, 0, 255);
786 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
787 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
788 255, 0, 0, 255);
789 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
790 DEFAULT_DISPLAY_HEIGHT),
791 0, 0, 255, 255);
792 }
793
794 template <typename SourceVariant>
fillBufferCheckersRotate270()795 void RenderEngineTest::fillBufferCheckersRotate270() {
796 fillBufferCheckers<SourceVariant>(ui::Transform::ROT_270);
797 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 255,
798 255);
799 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
800 DEFAULT_DISPLAY_HEIGHT / 2),
801 0, 0, 0, 0);
802 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
803 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
804 0, 255, 0, 255);
805 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
806 DEFAULT_DISPLAY_HEIGHT),
807 255, 0, 0, 255);
808 }
809
810 template <typename SourceVariant>
fillBufferWithLayerTransform()811 void RenderEngineTest::fillBufferWithLayerTransform() {
812 renderengine::DisplaySettings settings;
813 settings.physicalDisplay = fullscreenRect();
814 // Here logical space is 2x2
815 settings.clip = Rect(2, 2);
816 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
817
818 std::vector<const renderengine::LayerSettings*> layers;
819
820 renderengine::LayerSettings layer;
821 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
822 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
823 // Translate one pixel diagonally
824 layer.geometry.positionTransform = mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1);
825 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
826 layer.source.solidColor = half3(1.0f, 0.0f, 0.0f);
827 layer.alpha = 1.0f;
828
829 layers.push_back(&layer);
830
831 invokeDraw(settings, layers);
832 }
833
834 template <typename SourceVariant>
fillBufferLayerTransform()835 void RenderEngineTest::fillBufferLayerTransform() {
836 fillBufferWithLayerTransform<SourceVariant>();
837 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 0, 0);
838 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 0);
839 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
840 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
841 255, 0, 0, 255);
842 }
843
844 template <typename SourceVariant>
fillBufferWithColorTransform()845 void RenderEngineTest::fillBufferWithColorTransform() {
846 renderengine::DisplaySettings settings;
847 settings.physicalDisplay = fullscreenRect();
848 settings.clip = Rect(1, 1);
849 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
850
851 std::vector<const renderengine::LayerSettings*> layers;
852
853 renderengine::LayerSettings layer;
854 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
855 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
856 SourceVariant::fillColor(layer, 0.5f, 0.25f, 0.125f, this);
857 layer.alpha = 1.0f;
858
859 // construct a fake color matrix
860 // annihilate green and blue channels
861 settings.colorTransform = mat4::scale(vec4(0.9f, 0, 0, 1));
862 // set red channel to red + green
863 layer.colorTransform = mat4(1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
864
865 layer.alpha = 1.0f;
866 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
867
868 layers.push_back(&layer);
869
870 invokeDraw(settings, layers);
871 }
872
873 template <typename SourceVariant>
fillBufferColorTransform()874 void RenderEngineTest::fillBufferColorTransform() {
875 fillBufferWithColorTransform<SourceVariant>();
876 expectBufferColor(fullscreenRect(), 172, 0, 0, 255, 1);
877 }
878
879 template <typename SourceVariant>
fillBufferWithColorTransformZeroLayerAlpha()880 void RenderEngineTest::fillBufferWithColorTransformZeroLayerAlpha() {
881 renderengine::DisplaySettings settings;
882 settings.physicalDisplay = fullscreenRect();
883 settings.clip = Rect(1, 1);
884
885 std::vector<const renderengine::LayerSettings*> layers;
886
887 renderengine::LayerSettings layer;
888 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
889 SourceVariant::fillColor(layer, 0.5f, 0.25f, 0.125f, this);
890 layer.alpha = 0;
891
892 // construct a fake color matrix
893 // simple inverse color
894 settings.colorTransform = mat4(-1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 1, 1, 1, 1);
895
896 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
897
898 layers.push_back(&layer);
899
900 invokeDraw(settings, layers);
901 }
902
903 template <typename SourceVariant>
fillBufferColorTransformZeroLayerAlpha()904 void RenderEngineTest::fillBufferColorTransformZeroLayerAlpha() {
905 fillBufferWithColorTransformZeroLayerAlpha<SourceVariant>();
906 expectBufferColor(fullscreenRect(), 0, 0, 0, 0);
907 }
908
909 template <typename SourceVariant>
fillRedBufferWithRoundedCorners()910 void RenderEngineTest::fillRedBufferWithRoundedCorners() {
911 renderengine::DisplaySettings settings;
912 settings.physicalDisplay = fullscreenRect();
913 settings.clip = fullscreenRect();
914 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
915
916 std::vector<const renderengine::LayerSettings*> layers;
917
918 renderengine::LayerSettings layer;
919 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
920 layer.geometry.boundaries = fullscreenRect().toFloatRect();
921 layer.geometry.roundedCornersRadius = 5.0f;
922 layer.geometry.roundedCornersCrop = fullscreenRect().toFloatRect();
923 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
924 layer.alpha = 1.0f;
925
926 layers.push_back(&layer);
927
928 invokeDraw(settings, layers);
929 }
930
931 template <typename SourceVariant>
fillBufferWithRoundedCorners()932 void RenderEngineTest::fillBufferWithRoundedCorners() {
933 fillRedBufferWithRoundedCorners<SourceVariant>();
934 // Corners should be ignored...
935 expectBufferColor(Rect(0, 0, 1, 1), 0, 0, 0, 0);
936 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH - 1, 0, DEFAULT_DISPLAY_WIDTH, 1), 0, 0, 0, 0);
937 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT - 1, 1, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 0);
938 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH - 1, DEFAULT_DISPLAY_HEIGHT - 1,
939 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
940 0, 0, 0, 0);
941 // ...And the non-rounded portion should be red.
942 // Other pixels may be anti-aliased, so let's not check those.
943 expectBufferColor(Rect(5, 5, DEFAULT_DISPLAY_WIDTH - 5, DEFAULT_DISPLAY_HEIGHT - 5), 255, 0, 0,
944 255);
945 }
946
947 template <typename SourceVariant>
fillBufferAndBlurBackground()948 void RenderEngineTest::fillBufferAndBlurBackground() {
949 auto blurRadius = 50;
950 auto center = DEFAULT_DISPLAY_WIDTH / 2;
951
952 renderengine::DisplaySettings settings;
953 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
954 settings.physicalDisplay = fullscreenRect();
955 settings.clip = fullscreenRect();
956
957 std::vector<const renderengine::LayerSettings*> layers;
958
959 renderengine::LayerSettings backgroundLayer;
960 backgroundLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
961 backgroundLayer.geometry.boundaries = fullscreenRect().toFloatRect();
962 SourceVariant::fillColor(backgroundLayer, 0.0f, 1.0f, 0.0f, this);
963 backgroundLayer.alpha = 1.0f;
964 layers.push_back(&backgroundLayer);
965
966 renderengine::LayerSettings leftLayer;
967 leftLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
968 leftLayer.geometry.boundaries =
969 Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT).toFloatRect();
970 SourceVariant::fillColor(leftLayer, 1.0f, 0.0f, 0.0f, this);
971 leftLayer.alpha = 1.0f;
972 layers.push_back(&leftLayer);
973
974 renderengine::LayerSettings blurLayer;
975 blurLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
976 blurLayer.geometry.boundaries = fullscreenRect().toFloatRect();
977 blurLayer.backgroundBlurRadius = blurRadius;
978 SourceVariant::fillColor(blurLayer, 0.0f, 0.0f, 1.0f, this);
979 blurLayer.alpha = 0;
980 layers.push_back(&blurLayer);
981
982 invokeDraw(settings, layers);
983
984 // solid color
985 expectBufferColor(Rect(0, 0, 1, 1), 255, 0, 0, 255, 0 /* tolerance */);
986
987 if (mRE->supportsBackgroundBlur()) {
988 // blurred color (downsampling should result in the center color being close to 128)
989 expectBufferColor(Rect(center - 1, center - 5, center + 1, center + 5), 128, 128, 0, 255,
990 50 /* tolerance */);
991 }
992 }
993
994 template <typename SourceVariant>
fillSmallLayerAndBlurBackground()995 void RenderEngineTest::fillSmallLayerAndBlurBackground() {
996 auto blurRadius = 50;
997 renderengine::DisplaySettings settings;
998 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
999 settings.physicalDisplay = fullscreenRect();
1000 settings.clip = fullscreenRect();
1001
1002 std::vector<const renderengine::LayerSettings*> layers;
1003
1004 renderengine::LayerSettings backgroundLayer;
1005 backgroundLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1006 backgroundLayer.geometry.boundaries = fullscreenRect().toFloatRect();
1007 SourceVariant::fillColor(backgroundLayer, 1.0f, 0.0f, 0.0f, this);
1008 backgroundLayer.alpha = 1.0f;
1009 layers.push_back(&backgroundLayer);
1010
1011 renderengine::LayerSettings blurLayer;
1012 blurLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1013 blurLayer.geometry.boundaries = FloatRect(0.f, 0.f, 1.f, 1.f);
1014 blurLayer.backgroundBlurRadius = blurRadius;
1015 SourceVariant::fillColor(blurLayer, 0.0f, 0.0f, 1.0f, this);
1016 blurLayer.alpha = 0;
1017 layers.push_back(&blurLayer);
1018
1019 invokeDraw(settings, layers);
1020
1021 // Give a generous tolerance - the blur rectangle is very small and this test is
1022 // mainly concerned with ensuring that there's no device failure.
1023 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT), 255, 0, 0, 255,
1024 40 /* tolerance */);
1025 }
1026
1027 template <typename SourceVariant>
overlayCorners()1028 void RenderEngineTest::overlayCorners() {
1029 renderengine::DisplaySettings settings;
1030 settings.physicalDisplay = fullscreenRect();
1031 settings.clip = fullscreenRect();
1032 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1033
1034 std::vector<const renderengine::LayerSettings*> layersFirst;
1035
1036 renderengine::LayerSettings layerOne;
1037 layerOne.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1038 layerOne.geometry.boundaries =
1039 FloatRect(0, 0, DEFAULT_DISPLAY_WIDTH / 3.0, DEFAULT_DISPLAY_HEIGHT / 3.0);
1040 SourceVariant::fillColor(layerOne, 1.0f, 0.0f, 0.0f, this);
1041 layerOne.alpha = 0.2;
1042
1043 layersFirst.push_back(&layerOne);
1044 invokeDraw(settings, layersFirst);
1045 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3, DEFAULT_DISPLAY_HEIGHT / 3), 51, 0, 0, 51);
1046 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3 + 1, DEFAULT_DISPLAY_HEIGHT / 3 + 1,
1047 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
1048 0, 0, 0, 0);
1049
1050 std::vector<const renderengine::LayerSettings*> layersSecond;
1051 renderengine::LayerSettings layerTwo;
1052 layerTwo.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1053 layerTwo.geometry.boundaries =
1054 FloatRect(DEFAULT_DISPLAY_WIDTH / 3.0, DEFAULT_DISPLAY_HEIGHT / 3.0,
1055 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
1056 SourceVariant::fillColor(layerTwo, 0.0f, 1.0f, 0.0f, this);
1057 layerTwo.alpha = 1.0f;
1058
1059 layersSecond.push_back(&layerTwo);
1060 invokeDraw(settings, layersSecond);
1061
1062 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3, DEFAULT_DISPLAY_HEIGHT / 3), 0, 0, 0, 0);
1063 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3 + 1, DEFAULT_DISPLAY_HEIGHT / 3 + 1,
1064 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
1065 0, 255, 0, 255);
1066 }
1067
fillRedBufferTextureTransform()1068 void RenderEngineTest::fillRedBufferTextureTransform() {
1069 renderengine::DisplaySettings settings;
1070 settings.physicalDisplay = fullscreenRect();
1071 settings.clip = Rect(1, 1);
1072 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1073
1074 std::vector<const renderengine::LayerSettings*> layers;
1075
1076 renderengine::LayerSettings layer;
1077 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1078 // Here will allocate a checker board texture, but transform texture
1079 // coordinates so that only the upper left is applied.
1080 const auto buf = allocateSourceBuffer(2, 2);
1081 uint32_t texName;
1082 RenderEngineTest::mRE->genTextures(1, &texName);
1083 this->mTexNames.push_back(texName);
1084
1085 uint8_t* pixels;
1086 buf->getBuffer()->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
1087 reinterpret_cast<void**>(&pixels));
1088 // Red top left, Green top right, Blue bottom left, Black bottom right
1089 pixels[0] = 255;
1090 pixels[1] = 0;
1091 pixels[2] = 0;
1092 pixels[3] = 255;
1093 pixels[4] = 0;
1094 pixels[5] = 255;
1095 pixels[6] = 0;
1096 pixels[7] = 255;
1097 pixels[8] = 0;
1098 pixels[9] = 0;
1099 pixels[10] = 255;
1100 pixels[11] = 255;
1101 buf->getBuffer()->unlock();
1102
1103 layer.source.buffer.buffer = buf;
1104 layer.source.buffer.textureName = texName;
1105 // Transform coordinates to only be inside the red quadrant.
1106 layer.source.buffer.textureTransform = mat4::scale(vec4(0.2, 0.2, 1, 1));
1107 layer.alpha = 1.0f;
1108 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
1109
1110 layers.push_back(&layer);
1111
1112 invokeDraw(settings, layers);
1113 }
1114
fillBufferTextureTransform()1115 void RenderEngineTest::fillBufferTextureTransform() {
1116 fillRedBufferTextureTransform();
1117 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
1118 }
1119
fillRedBufferWithPremultiplyAlpha()1120 void RenderEngineTest::fillRedBufferWithPremultiplyAlpha() {
1121 renderengine::DisplaySettings settings;
1122 settings.physicalDisplay = fullscreenRect();
1123 // Here logical space is 1x1
1124 settings.clip = Rect(1, 1);
1125
1126 std::vector<const renderengine::LayerSettings*> layers;
1127
1128 renderengine::LayerSettings layer;
1129 const auto buf = allocateSourceBuffer(1, 1);
1130 uint32_t texName;
1131 RenderEngineTest::mRE->genTextures(1, &texName);
1132 this->mTexNames.push_back(texName);
1133
1134 uint8_t* pixels;
1135 buf->getBuffer()->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
1136 reinterpret_cast<void**>(&pixels));
1137 pixels[0] = 255;
1138 pixels[1] = 0;
1139 pixels[2] = 0;
1140 pixels[3] = 255;
1141 buf->getBuffer()->unlock();
1142
1143 layer.source.buffer.buffer = buf;
1144 layer.source.buffer.textureName = texName;
1145 layer.source.buffer.usePremultipliedAlpha = true;
1146 layer.alpha = 0.5f;
1147 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
1148
1149 layers.push_back(&layer);
1150
1151 invokeDraw(settings, layers);
1152 }
1153
fillBufferWithPremultiplyAlpha()1154 void RenderEngineTest::fillBufferWithPremultiplyAlpha() {
1155 fillRedBufferWithPremultiplyAlpha();
1156 expectBufferColor(fullscreenRect(), 128, 0, 0, 128);
1157 }
1158
fillRedBufferWithoutPremultiplyAlpha()1159 void RenderEngineTest::fillRedBufferWithoutPremultiplyAlpha() {
1160 renderengine::DisplaySettings settings;
1161 settings.physicalDisplay = fullscreenRect();
1162 // Here logical space is 1x1
1163 settings.clip = Rect(1, 1);
1164
1165 std::vector<const renderengine::LayerSettings*> layers;
1166
1167 renderengine::LayerSettings layer;
1168 const auto buf = allocateSourceBuffer(1, 1);
1169 uint32_t texName;
1170 RenderEngineTest::mRE->genTextures(1, &texName);
1171 this->mTexNames.push_back(texName);
1172
1173 uint8_t* pixels;
1174 buf->getBuffer()->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
1175 reinterpret_cast<void**>(&pixels));
1176 pixels[0] = 255;
1177 pixels[1] = 0;
1178 pixels[2] = 0;
1179 pixels[3] = 255;
1180 buf->getBuffer()->unlock();
1181
1182 layer.source.buffer.buffer = buf;
1183 layer.source.buffer.textureName = texName;
1184 layer.source.buffer.usePremultipliedAlpha = false;
1185 layer.alpha = 0.5f;
1186 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
1187
1188 layers.push_back(&layer);
1189
1190 invokeDraw(settings, layers);
1191 }
1192
fillBufferWithoutPremultiplyAlpha()1193 void RenderEngineTest::fillBufferWithoutPremultiplyAlpha() {
1194 fillRedBufferWithoutPremultiplyAlpha();
1195 expectBufferColor(fullscreenRect(), 128, 0, 0, 128, 1);
1196 }
1197
clearLeftRegion()1198 void RenderEngineTest::clearLeftRegion() {
1199 renderengine::DisplaySettings settings;
1200 settings.physicalDisplay = fullscreenRect();
1201 // Here logical space is 4x4
1202 settings.clip = Rect(4, 4);
1203 settings.clearRegion = Region(Rect(2, 4));
1204 std::vector<const renderengine::LayerSettings*> layers;
1205 // fake layer, without bounds should not render anything
1206 renderengine::LayerSettings layer;
1207 layers.push_back(&layer);
1208 invokeDraw(settings, layers);
1209 }
1210
clearRegion()1211 void RenderEngineTest::clearRegion() {
1212 // Reuse mBuffer
1213 clearLeftRegion();
1214 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 255);
1215 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
1216 DEFAULT_DISPLAY_HEIGHT),
1217 0, 0, 0, 0);
1218 }
1219
1220 template <typename SourceVariant>
drawShadow(const renderengine::LayerSettings & castingLayer,const renderengine::ShadowSettings & shadow,const ubyte4 & casterColor,const ubyte4 & backgroundColor)1221 void RenderEngineTest::drawShadow(const renderengine::LayerSettings& castingLayer,
1222 const renderengine::ShadowSettings& shadow,
1223 const ubyte4& casterColor, const ubyte4& backgroundColor) {
1224 renderengine::DisplaySettings settings;
1225 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1226 settings.physicalDisplay = fullscreenRect();
1227 settings.clip = fullscreenRect();
1228
1229 std::vector<const renderengine::LayerSettings*> layers;
1230
1231 // add background layer
1232 renderengine::LayerSettings bgLayer;
1233 bgLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1234 bgLayer.geometry.boundaries = fullscreenRect().toFloatRect();
1235 ColorSourceVariant::fillColor(bgLayer, backgroundColor.r / 255.0f, backgroundColor.g / 255.0f,
1236 backgroundColor.b / 255.0f, this);
1237 bgLayer.alpha = backgroundColor.a / 255.0f;
1238 layers.push_back(&bgLayer);
1239
1240 // add shadow layer
1241 renderengine::LayerSettings shadowLayer;
1242 shadowLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1243 shadowLayer.geometry.boundaries = castingLayer.geometry.boundaries;
1244 shadowLayer.alpha = castingLayer.alpha;
1245 shadowLayer.shadow = shadow;
1246 layers.push_back(&shadowLayer);
1247
1248 // add layer casting the shadow
1249 renderengine::LayerSettings layer = castingLayer;
1250 layer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1251 SourceVariant::fillColor(layer, casterColor.r / 255.0f, casterColor.g / 255.0f,
1252 casterColor.b / 255.0f, this);
1253 layers.push_back(&layer);
1254
1255 invokeDraw(settings, layers);
1256 }
1257
drawShadowWithoutCaster(const FloatRect & castingBounds,const renderengine::ShadowSettings & shadow,const ubyte4 & backgroundColor)1258 void RenderEngineTest::drawShadowWithoutCaster(const FloatRect& castingBounds,
1259 const renderengine::ShadowSettings& shadow,
1260 const ubyte4& backgroundColor) {
1261 renderengine::DisplaySettings settings;
1262 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1263 settings.physicalDisplay = fullscreenRect();
1264 settings.clip = fullscreenRect();
1265
1266 std::vector<const renderengine::LayerSettings*> layers;
1267
1268 // add background layer
1269 renderengine::LayerSettings bgLayer;
1270 bgLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1271 bgLayer.geometry.boundaries = fullscreenRect().toFloatRect();
1272 ColorSourceVariant::fillColor(bgLayer, backgroundColor.r / 255.0f, backgroundColor.g / 255.0f,
1273 backgroundColor.b / 255.0f, this);
1274 bgLayer.alpha = backgroundColor.a / 255.0f;
1275 layers.push_back(&bgLayer);
1276
1277 // add shadow layer
1278 renderengine::LayerSettings shadowLayer;
1279 shadowLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1280 shadowLayer.geometry.boundaries = castingBounds;
1281 shadowLayer.skipContentDraw = true;
1282 shadowLayer.alpha = 1.0f;
1283 ColorSourceVariant::fillColor(shadowLayer, 0, 0, 0, this);
1284 shadowLayer.shadow = shadow;
1285 layers.push_back(&shadowLayer);
1286
1287 invokeDraw(settings, layers);
1288 }
1289
1290 INSTANTIATE_TEST_SUITE_P(PerRenderEngineType, RenderEngineTest,
1291 testing::Values(std::make_shared<GLESRenderEngineFactory>(),
1292 std::make_shared<GLESCMRenderEngineFactory>(),
1293 std::make_shared<SkiaGLESRenderEngineFactory>(),
1294 std::make_shared<SkiaGLESCMRenderEngineFactory>()));
1295
TEST_P(RenderEngineTest,drawLayers_noLayersToDraw)1296 TEST_P(RenderEngineTest, drawLayers_noLayersToDraw) {
1297 initializeRenderEngine();
1298 drawEmptyLayers();
1299 }
1300
TEST_P(RenderEngineTest,drawLayers_withoutBuffers_withColorTransform)1301 TEST_P(RenderEngineTest, drawLayers_withoutBuffers_withColorTransform) {
1302 initializeRenderEngine();
1303
1304 renderengine::DisplaySettings settings;
1305 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1306 settings.physicalDisplay = fullscreenRect();
1307 settings.clip = fullscreenRect();
1308
1309 // 255, 255, 255, 255 is full opaque white.
1310 const ubyte4 backgroundColor(255.f, 255.f, 255.f, 255.f);
1311 // Create layer with given color.
1312 renderengine::LayerSettings bgLayer;
1313 bgLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1314 bgLayer.geometry.boundaries = fullscreenRect().toFloatRect();
1315 bgLayer.source.solidColor = half3(backgroundColor.r / 255.0f, backgroundColor.g / 255.0f,
1316 backgroundColor.b / 255.0f);
1317 bgLayer.alpha = backgroundColor.a / 255.0f;
1318 // Transform the red color.
1319 bgLayer.colorTransform = mat4(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
1320
1321 std::vector<const renderengine::LayerSettings*> layers;
1322 layers.push_back(&bgLayer);
1323
1324 invokeDraw(settings, layers);
1325
1326 // Expect to see full opaque pixel (with inverted red from the transform).
1327 expectBufferColor(Rect(0, 0, 10, 10), 0.f, backgroundColor.g, backgroundColor.b,
1328 backgroundColor.a);
1329 }
1330
TEST_P(RenderEngineTest,drawLayers_nullOutputBuffer)1331 TEST_P(RenderEngineTest, drawLayers_nullOutputBuffer) {
1332 initializeRenderEngine();
1333
1334 renderengine::DisplaySettings settings;
1335 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1336 std::vector<const renderengine::LayerSettings*> layers;
1337 renderengine::LayerSettings layer;
1338 layer.geometry.boundaries = fullscreenRect().toFloatRect();
1339 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
1340 layers.push_back(&layer);
1341 base::unique_fd fence;
1342 status_t status = mRE->drawLayers(settings, layers, nullptr, true, base::unique_fd(), &fence);
1343
1344 ASSERT_EQ(BAD_VALUE, status);
1345 }
1346
TEST_P(RenderEngineTest,drawLayers_nullOutputFence)1347 TEST_P(RenderEngineTest, drawLayers_nullOutputFence) {
1348 initializeRenderEngine();
1349
1350 renderengine::DisplaySettings settings;
1351 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1352 settings.physicalDisplay = fullscreenRect();
1353 settings.clip = fullscreenRect();
1354
1355 std::vector<const renderengine::LayerSettings*> layers;
1356 renderengine::LayerSettings layer;
1357 layer.geometry.boundaries = fullscreenRect().toFloatRect();
1358 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
1359 layer.alpha = 1.0;
1360 layers.push_back(&layer);
1361
1362 status_t status = mRE->drawLayers(settings, layers, mBuffer, true, base::unique_fd(), nullptr);
1363 ASSERT_EQ(NO_ERROR, status);
1364 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
1365 }
1366
TEST_P(RenderEngineTest,drawLayers_doesNotCacheFramebuffer)1367 TEST_P(RenderEngineTest, drawLayers_doesNotCacheFramebuffer) {
1368 const auto& renderEngineFactory = GetParam();
1369
1370 if (renderEngineFactory->type() != renderengine::RenderEngine::RenderEngineType::GLES) {
1371 // GLES-specific test
1372 return;
1373 }
1374
1375 initializeRenderEngine();
1376
1377 renderengine::DisplaySettings settings;
1378 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1379 settings.physicalDisplay = fullscreenRect();
1380 settings.clip = fullscreenRect();
1381
1382 std::vector<const renderengine::LayerSettings*> layers;
1383 renderengine::LayerSettings layer;
1384 layer.geometry.boundaries = fullscreenRect().toFloatRect();
1385 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
1386 layer.alpha = 1.0;
1387 layers.push_back(&layer);
1388
1389 status_t status = mRE->drawLayers(settings, layers, mBuffer, false, base::unique_fd(), nullptr);
1390 ASSERT_EQ(NO_ERROR, status);
1391 ASSERT_FALSE(mGLESRE->isFramebufferImageCachedForTesting(mBuffer->getBuffer()->getId()));
1392 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
1393 }
1394
TEST_P(RenderEngineTest,drawLayers_fillRedBuffer_colorSource)1395 TEST_P(RenderEngineTest, drawLayers_fillRedBuffer_colorSource) {
1396 initializeRenderEngine();
1397 fillRedBuffer<ColorSourceVariant>();
1398 }
1399
TEST_P(RenderEngineTest,drawLayers_fillGreenBuffer_colorSource)1400 TEST_P(RenderEngineTest, drawLayers_fillGreenBuffer_colorSource) {
1401 initializeRenderEngine();
1402 fillGreenBuffer<ColorSourceVariant>();
1403 }
1404
TEST_P(RenderEngineTest,drawLayers_fillBlueBuffer_colorSource)1405 TEST_P(RenderEngineTest, drawLayers_fillBlueBuffer_colorSource) {
1406 initializeRenderEngine();
1407 fillBlueBuffer<ColorSourceVariant>();
1408 }
1409
TEST_P(RenderEngineTest,drawLayers_fillRedTransparentBuffer_colorSource)1410 TEST_P(RenderEngineTest, drawLayers_fillRedTransparentBuffer_colorSource) {
1411 initializeRenderEngine();
1412 fillRedTransparentBuffer<ColorSourceVariant>();
1413 }
1414
TEST_P(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_colorSource)1415 TEST_P(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_colorSource) {
1416 initializeRenderEngine();
1417 fillBufferPhysicalOffset<ColorSourceVariant>();
1418 }
1419
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_colorSource)1420 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_colorSource) {
1421 initializeRenderEngine();
1422 fillBufferCheckersRotate0<ColorSourceVariant>();
1423 }
1424
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_colorSource)1425 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_colorSource) {
1426 initializeRenderEngine();
1427 fillBufferCheckersRotate90<ColorSourceVariant>();
1428 }
1429
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_colorSource)1430 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_colorSource) {
1431 initializeRenderEngine();
1432 fillBufferCheckersRotate180<ColorSourceVariant>();
1433 }
1434
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_colorSource)1435 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_colorSource) {
1436 initializeRenderEngine();
1437 fillBufferCheckersRotate270<ColorSourceVariant>();
1438 }
1439
TEST_P(RenderEngineTest,drawLayers_fillBufferLayerTransform_colorSource)1440 TEST_P(RenderEngineTest, drawLayers_fillBufferLayerTransform_colorSource) {
1441 initializeRenderEngine();
1442 fillBufferLayerTransform<ColorSourceVariant>();
1443 }
1444
TEST_P(RenderEngineTest,drawLayers_fillBufferColorTransform_colorSource)1445 TEST_P(RenderEngineTest, drawLayers_fillBufferColorTransform_colorSource) {
1446 initializeRenderEngine();
1447 fillBufferColorTransform<ColorSourceVariant>();
1448 }
1449
TEST_P(RenderEngineTest,drawLayers_fillBufferRoundedCorners_colorSource)1450 TEST_P(RenderEngineTest, drawLayers_fillBufferRoundedCorners_colorSource) {
1451 initializeRenderEngine();
1452 fillBufferWithRoundedCorners<ColorSourceVariant>();
1453 }
1454
TEST_P(RenderEngineTest,drawLayers_fillBufferColorTransformZeroLayerAlpha_colorSource)1455 TEST_P(RenderEngineTest, drawLayers_fillBufferColorTransformZeroLayerAlpha_colorSource) {
1456 initializeRenderEngine();
1457 fillBufferColorTransformZeroLayerAlpha<ColorSourceVariant>();
1458 }
1459
TEST_P(RenderEngineTest,drawLayers_fillBufferAndBlurBackground_colorSource)1460 TEST_P(RenderEngineTest, drawLayers_fillBufferAndBlurBackground_colorSource) {
1461 initializeRenderEngine();
1462 fillBufferAndBlurBackground<ColorSourceVariant>();
1463 }
1464
TEST_P(RenderEngineTest,drawLayers_fillSmallLayerAndBlurBackground_colorSource)1465 TEST_P(RenderEngineTest, drawLayers_fillSmallLayerAndBlurBackground_colorSource) {
1466 initializeRenderEngine();
1467 fillSmallLayerAndBlurBackground<ColorSourceVariant>();
1468 }
1469
TEST_P(RenderEngineTest,drawLayers_overlayCorners_colorSource)1470 TEST_P(RenderEngineTest, drawLayers_overlayCorners_colorSource) {
1471 initializeRenderEngine();
1472 overlayCorners<ColorSourceVariant>();
1473 }
1474
TEST_P(RenderEngineTest,drawLayers_fillRedBuffer_opaqueBufferSource)1475 TEST_P(RenderEngineTest, drawLayers_fillRedBuffer_opaqueBufferSource) {
1476 initializeRenderEngine();
1477 fillRedBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1478 }
1479
TEST_P(RenderEngineTest,drawLayers_fillGreenBuffer_opaqueBufferSource)1480 TEST_P(RenderEngineTest, drawLayers_fillGreenBuffer_opaqueBufferSource) {
1481 initializeRenderEngine();
1482 fillGreenBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1483 }
1484
TEST_P(RenderEngineTest,drawLayers_fillBlueBuffer_opaqueBufferSource)1485 TEST_P(RenderEngineTest, drawLayers_fillBlueBuffer_opaqueBufferSource) {
1486 initializeRenderEngine();
1487 fillBlueBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1488 }
1489
TEST_P(RenderEngineTest,drawLayers_fillRedTransparentBuffer_opaqueBufferSource)1490 TEST_P(RenderEngineTest, drawLayers_fillRedTransparentBuffer_opaqueBufferSource) {
1491 initializeRenderEngine();
1492 fillRedTransparentBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1493 }
1494
TEST_P(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_opaqueBufferSource)1495 TEST_P(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_opaqueBufferSource) {
1496 initializeRenderEngine();
1497 fillBufferPhysicalOffset<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1498 }
1499
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_opaqueBufferSource)1500 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_opaqueBufferSource) {
1501 initializeRenderEngine();
1502 fillBufferCheckersRotate0<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1503 }
1504
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_opaqueBufferSource)1505 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_opaqueBufferSource) {
1506 initializeRenderEngine();
1507 fillBufferCheckersRotate90<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1508 }
1509
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_opaqueBufferSource)1510 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_opaqueBufferSource) {
1511 initializeRenderEngine();
1512 fillBufferCheckersRotate180<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1513 }
1514
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_opaqueBufferSource)1515 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_opaqueBufferSource) {
1516 initializeRenderEngine();
1517 fillBufferCheckersRotate270<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1518 }
1519
TEST_P(RenderEngineTest,drawLayers_fillBufferLayerTransform_opaqueBufferSource)1520 TEST_P(RenderEngineTest, drawLayers_fillBufferLayerTransform_opaqueBufferSource) {
1521 initializeRenderEngine();
1522 fillBufferLayerTransform<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1523 }
1524
TEST_P(RenderEngineTest,drawLayers_fillBufferColorTransform_opaqueBufferSource)1525 TEST_P(RenderEngineTest, drawLayers_fillBufferColorTransform_opaqueBufferSource) {
1526 initializeRenderEngine();
1527 fillBufferColorTransform<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1528 }
1529
TEST_P(RenderEngineTest,drawLayers_fillBufferRoundedCorners_opaqueBufferSource)1530 TEST_P(RenderEngineTest, drawLayers_fillBufferRoundedCorners_opaqueBufferSource) {
1531 initializeRenderEngine();
1532 fillBufferWithRoundedCorners<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1533 }
1534
TEST_P(RenderEngineTest,drawLayers_fillBufferColorTransformZeroLayerAlpha_opaqueBufferSource)1535 TEST_P(RenderEngineTest, drawLayers_fillBufferColorTransformZeroLayerAlpha_opaqueBufferSource) {
1536 initializeRenderEngine();
1537 fillBufferColorTransformZeroLayerAlpha<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1538 }
1539
TEST_P(RenderEngineTest,drawLayers_fillBufferAndBlurBackground_opaqueBufferSource)1540 TEST_P(RenderEngineTest, drawLayers_fillBufferAndBlurBackground_opaqueBufferSource) {
1541 initializeRenderEngine();
1542 fillBufferAndBlurBackground<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1543 }
1544
TEST_P(RenderEngineTest,drawLayers_fillSmallLayerAndBlurBackground_opaqueBufferSource)1545 TEST_P(RenderEngineTest, drawLayers_fillSmallLayerAndBlurBackground_opaqueBufferSource) {
1546 initializeRenderEngine();
1547 fillSmallLayerAndBlurBackground<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1548 }
1549
TEST_P(RenderEngineTest,drawLayers_overlayCorners_opaqueBufferSource)1550 TEST_P(RenderEngineTest, drawLayers_overlayCorners_opaqueBufferSource) {
1551 initializeRenderEngine();
1552 overlayCorners<BufferSourceVariant<ForceOpaqueBufferVariant>>();
1553 }
1554
TEST_P(RenderEngineTest,drawLayers_fillRedBuffer_bufferSource)1555 TEST_P(RenderEngineTest, drawLayers_fillRedBuffer_bufferSource) {
1556 initializeRenderEngine();
1557 fillRedBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1558 }
1559
TEST_P(RenderEngineTest,drawLayers_fillGreenBuffer_bufferSource)1560 TEST_P(RenderEngineTest, drawLayers_fillGreenBuffer_bufferSource) {
1561 initializeRenderEngine();
1562 fillGreenBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1563 }
1564
TEST_P(RenderEngineTest,drawLayers_fillBlueBuffer_bufferSource)1565 TEST_P(RenderEngineTest, drawLayers_fillBlueBuffer_bufferSource) {
1566 initializeRenderEngine();
1567 fillBlueBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1568 }
1569
TEST_P(RenderEngineTest,drawLayers_fillRedTransparentBuffer_bufferSource)1570 TEST_P(RenderEngineTest, drawLayers_fillRedTransparentBuffer_bufferSource) {
1571 initializeRenderEngine();
1572 fillRedTransparentBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1573 }
1574
TEST_P(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_bufferSource)1575 TEST_P(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_bufferSource) {
1576 initializeRenderEngine();
1577 fillBufferPhysicalOffset<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1578 }
1579
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_bufferSource)1580 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_bufferSource) {
1581 initializeRenderEngine();
1582 fillBufferCheckersRotate0<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1583 }
1584
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_bufferSource)1585 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_bufferSource) {
1586 initializeRenderEngine();
1587 fillBufferCheckersRotate90<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1588 }
1589
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_bufferSource)1590 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_bufferSource) {
1591 initializeRenderEngine();
1592 fillBufferCheckersRotate180<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1593 }
1594
TEST_P(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_bufferSource)1595 TEST_P(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_bufferSource) {
1596 initializeRenderEngine();
1597 fillBufferCheckersRotate270<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1598 }
1599
TEST_P(RenderEngineTest,drawLayers_fillBufferLayerTransform_bufferSource)1600 TEST_P(RenderEngineTest, drawLayers_fillBufferLayerTransform_bufferSource) {
1601 initializeRenderEngine();
1602 fillBufferLayerTransform<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1603 }
1604
TEST_P(RenderEngineTest,drawLayers_fillBufferColorTransform_bufferSource)1605 TEST_P(RenderEngineTest, drawLayers_fillBufferColorTransform_bufferSource) {
1606 initializeRenderEngine();
1607 fillBufferColorTransform<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1608 }
1609
TEST_P(RenderEngineTest,drawLayers_fillBufferRoundedCorners_bufferSource)1610 TEST_P(RenderEngineTest, drawLayers_fillBufferRoundedCorners_bufferSource) {
1611 initializeRenderEngine();
1612 fillBufferWithRoundedCorners<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1613 }
1614
TEST_P(RenderEngineTest,drawLayers_fillBufferColorTransformZeroLayerAlpha_bufferSource)1615 TEST_P(RenderEngineTest, drawLayers_fillBufferColorTransformZeroLayerAlpha_bufferSource) {
1616 initializeRenderEngine();
1617 fillBufferColorTransformZeroLayerAlpha<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1618 }
1619
TEST_P(RenderEngineTest,drawLayers_fillBufferAndBlurBackground_bufferSource)1620 TEST_P(RenderEngineTest, drawLayers_fillBufferAndBlurBackground_bufferSource) {
1621 initializeRenderEngine();
1622 fillBufferAndBlurBackground<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1623 }
1624
TEST_P(RenderEngineTest,drawLayers_fillSmallLayerAndBlurBackground_bufferSource)1625 TEST_P(RenderEngineTest, drawLayers_fillSmallLayerAndBlurBackground_bufferSource) {
1626 initializeRenderEngine();
1627 fillSmallLayerAndBlurBackground<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1628 }
1629
TEST_P(RenderEngineTest,drawLayers_overlayCorners_bufferSource)1630 TEST_P(RenderEngineTest, drawLayers_overlayCorners_bufferSource) {
1631 initializeRenderEngine();
1632 overlayCorners<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
1633 }
1634
TEST_P(RenderEngineTest,drawLayers_fillBufferTextureTransform)1635 TEST_P(RenderEngineTest, drawLayers_fillBufferTextureTransform) {
1636 initializeRenderEngine();
1637 fillBufferTextureTransform();
1638 }
1639
TEST_P(RenderEngineTest,drawLayers_fillBuffer_premultipliesAlpha)1640 TEST_P(RenderEngineTest, drawLayers_fillBuffer_premultipliesAlpha) {
1641 initializeRenderEngine();
1642 fillBufferWithPremultiplyAlpha();
1643 }
1644
TEST_P(RenderEngineTest,drawLayers_fillBuffer_withoutPremultiplyingAlpha)1645 TEST_P(RenderEngineTest, drawLayers_fillBuffer_withoutPremultiplyingAlpha) {
1646 initializeRenderEngine();
1647 fillBufferWithoutPremultiplyAlpha();
1648 }
1649
TEST_P(RenderEngineTest,drawLayers_clearRegion)1650 TEST_P(RenderEngineTest, drawLayers_clearRegion) {
1651 initializeRenderEngine();
1652 clearRegion();
1653 }
1654
TEST_P(RenderEngineTest,drawLayers_fillShadow_castsWithoutCasterLayer)1655 TEST_P(RenderEngineTest, drawLayers_fillShadow_castsWithoutCasterLayer) {
1656 initializeRenderEngine();
1657
1658 const ubyte4 backgroundColor(255, 255, 255, 255);
1659 const float shadowLength = 5.0f;
1660 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1661 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1662 renderengine::ShadowSettings settings =
1663 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1664 false /* casterIsTranslucent */);
1665
1666 drawShadowWithoutCaster(casterBounds.toFloatRect(), settings, backgroundColor);
1667 expectShadowColorWithoutCaster(casterBounds.toFloatRect(), settings, backgroundColor);
1668 }
1669
TEST_P(RenderEngineTest,drawLayers_fillShadow_casterLayerMinSize)1670 TEST_P(RenderEngineTest, drawLayers_fillShadow_casterLayerMinSize) {
1671 initializeRenderEngine();
1672
1673 const ubyte4 casterColor(255, 0, 0, 255);
1674 const ubyte4 backgroundColor(255, 255, 255, 255);
1675 const float shadowLength = 5.0f;
1676 Rect casterBounds(1, 1);
1677 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1678 renderengine::LayerSettings castingLayer;
1679 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1680 castingLayer.alpha = 1.0f;
1681 renderengine::ShadowSettings settings =
1682 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1683 false /* casterIsTranslucent */);
1684
1685 drawShadow<ColorSourceVariant>(castingLayer, settings, casterColor, backgroundColor);
1686 expectShadowColor(castingLayer, settings, casterColor, backgroundColor);
1687 }
1688
TEST_P(RenderEngineTest,drawLayers_fillShadow_casterColorLayer)1689 TEST_P(RenderEngineTest, drawLayers_fillShadow_casterColorLayer) {
1690 initializeRenderEngine();
1691
1692 const ubyte4 casterColor(255, 0, 0, 255);
1693 const ubyte4 backgroundColor(255, 255, 255, 255);
1694 const float shadowLength = 5.0f;
1695 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1696 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1697 renderengine::LayerSettings castingLayer;
1698 castingLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1699 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1700 castingLayer.alpha = 1.0f;
1701 renderengine::ShadowSettings settings =
1702 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1703 false /* casterIsTranslucent */);
1704
1705 drawShadow<ColorSourceVariant>(castingLayer, settings, casterColor, backgroundColor);
1706 expectShadowColor(castingLayer, settings, casterColor, backgroundColor);
1707 }
1708
TEST_P(RenderEngineTest,drawLayers_fillShadow_casterOpaqueBufferLayer)1709 TEST_P(RenderEngineTest, drawLayers_fillShadow_casterOpaqueBufferLayer) {
1710 initializeRenderEngine();
1711
1712 const ubyte4 casterColor(255, 0, 0, 255);
1713 const ubyte4 backgroundColor(255, 255, 255, 255);
1714 const float shadowLength = 5.0f;
1715 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1716 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1717 renderengine::LayerSettings castingLayer;
1718 castingLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1719 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1720 castingLayer.alpha = 1.0f;
1721 renderengine::ShadowSettings settings =
1722 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1723 false /* casterIsTranslucent */);
1724
1725 drawShadow<BufferSourceVariant<ForceOpaqueBufferVariant>>(castingLayer, settings, casterColor,
1726 backgroundColor);
1727 expectShadowColor(castingLayer, settings, casterColor, backgroundColor);
1728 }
1729
TEST_P(RenderEngineTest,drawLayers_fillShadow_casterWithRoundedCorner)1730 TEST_P(RenderEngineTest, drawLayers_fillShadow_casterWithRoundedCorner) {
1731 initializeRenderEngine();
1732
1733 const ubyte4 casterColor(255, 0, 0, 255);
1734 const ubyte4 backgroundColor(255, 255, 255, 255);
1735 const float shadowLength = 5.0f;
1736 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1737 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1738 renderengine::LayerSettings castingLayer;
1739 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1740 castingLayer.geometry.roundedCornersRadius = 3.0f;
1741 castingLayer.geometry.roundedCornersCrop = casterBounds.toFloatRect();
1742 castingLayer.alpha = 1.0f;
1743 renderengine::ShadowSettings settings =
1744 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1745 false /* casterIsTranslucent */);
1746
1747 drawShadow<BufferSourceVariant<ForceOpaqueBufferVariant>>(castingLayer, settings, casterColor,
1748 backgroundColor);
1749 expectShadowColor(castingLayer, settings, casterColor, backgroundColor);
1750 }
1751
TEST_P(RenderEngineTest,drawLayers_fillShadow_translucentCasterWithAlpha)1752 TEST_P(RenderEngineTest, drawLayers_fillShadow_translucentCasterWithAlpha) {
1753 initializeRenderEngine();
1754
1755 const ubyte4 casterColor(255, 0, 0, 255);
1756 const ubyte4 backgroundColor(255, 255, 255, 255);
1757 const float shadowLength = 5.0f;
1758 Rect casterBounds(DEFAULT_DISPLAY_WIDTH / 3.0f, DEFAULT_DISPLAY_HEIGHT / 3.0f);
1759 casterBounds.offsetBy(shadowLength + 1, shadowLength + 1);
1760 renderengine::LayerSettings castingLayer;
1761 castingLayer.geometry.boundaries = casterBounds.toFloatRect();
1762 castingLayer.alpha = 0.5f;
1763 renderengine::ShadowSettings settings =
1764 getShadowSettings(vec2(casterBounds.left, casterBounds.top), shadowLength,
1765 true /* casterIsTranslucent */);
1766
1767 drawShadow<BufferSourceVariant<RelaxOpaqueBufferVariant>>(castingLayer, settings, casterColor,
1768 backgroundColor);
1769
1770 // verify only the background since the shadow will draw behind the caster
1771 const float shadowInset = settings.length * -1.0f;
1772 const Rect casterWithShadow =
1773 Rect(casterBounds).inset(shadowInset, shadowInset, shadowInset, shadowInset);
1774 const Region backgroundRegion = Region(fullscreenRect()).subtractSelf(casterWithShadow);
1775 expectBufferColor(backgroundRegion, backgroundColor.r, backgroundColor.g, backgroundColor.b,
1776 backgroundColor.a);
1777 }
1778
TEST_P(RenderEngineTest,cleanupPostRender_cleansUpOnce)1779 TEST_P(RenderEngineTest, cleanupPostRender_cleansUpOnce) {
1780 initializeRenderEngine();
1781
1782 renderengine::DisplaySettings settings;
1783 settings.physicalDisplay = fullscreenRect();
1784 settings.clip = fullscreenRect();
1785 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1786
1787 std::vector<const renderengine::LayerSettings*> layers;
1788 renderengine::LayerSettings layer;
1789 layer.geometry.boundaries = fullscreenRect().toFloatRect();
1790 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
1791 layer.alpha = 1.0;
1792 layers.push_back(&layer);
1793
1794 base::unique_fd fenceOne;
1795 mRE->drawLayers(settings, layers, mBuffer, true, base::unique_fd(), &fenceOne);
1796 base::unique_fd fenceTwo;
1797 mRE->drawLayers(settings, layers, mBuffer, true, std::move(fenceOne), &fenceTwo);
1798
1799 const int fd = fenceTwo.get();
1800 if (fd >= 0) {
1801 sync_wait(fd, -1);
1802 }
1803 // Only cleanup the first time.
1804 EXPECT_FALSE(mRE->canSkipPostRenderCleanup());
1805 mRE->cleanupPostRender();
1806 EXPECT_TRUE(mRE->canSkipPostRenderCleanup());
1807 }
1808
TEST_P(RenderEngineTest,testRoundedCornersCrop)1809 TEST_P(RenderEngineTest, testRoundedCornersCrop) {
1810 initializeRenderEngine();
1811
1812 renderengine::DisplaySettings settings;
1813 settings.physicalDisplay = fullscreenRect();
1814 settings.clip = fullscreenRect();
1815 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1816
1817 std::vector<const renderengine::LayerSettings*> layers;
1818
1819 renderengine::LayerSettings redLayer;
1820 redLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1821 redLayer.geometry.boundaries = fullscreenRect().toFloatRect();
1822 redLayer.geometry.roundedCornersRadius = 5.0f;
1823 redLayer.geometry.roundedCornersCrop = fullscreenRect().toFloatRect();
1824 // Red background.
1825 redLayer.source.solidColor = half3(1.0f, 0.0f, 0.0f);
1826 redLayer.alpha = 1.0f;
1827
1828 layers.push_back(&redLayer);
1829
1830 // Green layer with 1/3 size.
1831 renderengine::LayerSettings greenLayer;
1832 greenLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1833 greenLayer.geometry.boundaries = fullscreenRect().toFloatRect();
1834 greenLayer.geometry.roundedCornersRadius = 5.0f;
1835 // Bottom right corner is not going to be rounded.
1836 greenLayer.geometry.roundedCornersCrop =
1837 Rect(DEFAULT_DISPLAY_WIDTH / 3, DEFAULT_DISPLAY_HEIGHT / 3, DEFAULT_DISPLAY_HEIGHT,
1838 DEFAULT_DISPLAY_HEIGHT)
1839 .toFloatRect();
1840 greenLayer.source.solidColor = half3(0.0f, 1.0f, 0.0f);
1841 greenLayer.alpha = 1.0f;
1842
1843 layers.push_back(&greenLayer);
1844
1845 invokeDraw(settings, layers);
1846
1847 // Corners should be ignored...
1848 // Screen size: width is 128, height is 256.
1849 expectBufferColor(Rect(0, 0, 1, 1), 0, 0, 0, 0);
1850 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH - 1, 0, DEFAULT_DISPLAY_WIDTH, 1), 0, 0, 0, 0);
1851 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT - 1, 1, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 0);
1852 // Bottom right corner is kept out of the clipping, and it's green.
1853 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH - 1, DEFAULT_DISPLAY_HEIGHT - 1,
1854 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
1855 0, 255, 0, 255);
1856 }
1857
TEST_P(RenderEngineTest,testRoundedCornersParentCrop)1858 TEST_P(RenderEngineTest, testRoundedCornersParentCrop) {
1859 initializeRenderEngine();
1860
1861 renderengine::DisplaySettings settings;
1862 settings.physicalDisplay = fullscreenRect();
1863 settings.clip = fullscreenRect();
1864 settings.outputDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1865
1866 std::vector<const renderengine::LayerSettings*> layers;
1867
1868 renderengine::LayerSettings redLayer;
1869 redLayer.sourceDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1870 redLayer.geometry.boundaries = fullscreenRect().toFloatRect();
1871 redLayer.geometry.roundedCornersRadius = 5.0f;
1872 redLayer.geometry.roundedCornersCrop = fullscreenRect().toFloatRect();
1873 // Red background.
1874 redLayer.source.solidColor = half3(1.0f, 0.0f, 0.0f);
1875 redLayer.alpha = 1.0f;
1876
1877 layers.push_back(&redLayer);
1878
1879 // Green layer with 1/2 size with parent crop rect.
1880 renderengine::LayerSettings greenLayer = redLayer;
1881 greenLayer.geometry.boundaries =
1882 FloatRect(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT / 2);
1883 greenLayer.source.solidColor = half3(0.0f, 1.0f, 0.0f);
1884
1885 layers.push_back(&greenLayer);
1886
1887 invokeDraw(settings, layers);
1888
1889 // Due to roundedCornersRadius, the corners are untouched.
1890 expectBufferColor(Point(0, 0), 0, 0, 0, 0);
1891 expectBufferColor(Point(DEFAULT_DISPLAY_WIDTH - 1, 0), 0, 0, 0, 0);
1892 expectBufferColor(Point(0, DEFAULT_DISPLAY_HEIGHT - 1), 0, 0, 0, 0);
1893 expectBufferColor(Point(DEFAULT_DISPLAY_WIDTH - 1, DEFAULT_DISPLAY_HEIGHT - 1), 0, 0, 0, 0);
1894
1895 // top middle should be green and the bottom middle red
1896 expectBufferColor(Point(DEFAULT_DISPLAY_WIDTH / 2, 0), 0, 255, 0, 255);
1897 expectBufferColor(Point(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 255, 0, 0, 255);
1898
1899 // the bottom edge of the green layer should not be rounded
1900 expectBufferColor(Point(0, (DEFAULT_DISPLAY_HEIGHT / 2) - 1), 0, 255, 0, 255);
1901 }
1902
TEST_P(RenderEngineTest,testClear)1903 TEST_P(RenderEngineTest, testClear) {
1904 initializeRenderEngine();
1905
1906 const auto rect = fullscreenRect();
1907 const renderengine::DisplaySettings display{
1908 .physicalDisplay = rect,
1909 .clip = rect,
1910 };
1911
1912 const renderengine::LayerSettings redLayer{
1913 .geometry.boundaries = rect.toFloatRect(),
1914 .source.solidColor = half3(1.0f, 0.0f, 0.0f),
1915 .alpha = 1.0f,
1916 };
1917
1918 // This mimics prepareClearClientComposition. This layer should overwrite
1919 // the redLayer, so that the buffer is transparent, rather than red.
1920 const renderengine::LayerSettings clearLayer{
1921 .geometry.boundaries = rect.toFloatRect(),
1922 .source.solidColor = half3(0.0f, 0.0f, 0.0f),
1923 .alpha = 0.0f,
1924 .disableBlending = true,
1925 };
1926
1927 std::vector<const renderengine::LayerSettings*> layers{&redLayer, &clearLayer};
1928 invokeDraw(display, layers);
1929 expectBufferColor(rect, 0, 0, 0, 0);
1930 }
1931
TEST_P(RenderEngineTest,testDisableBlendingBuffer)1932 TEST_P(RenderEngineTest, testDisableBlendingBuffer) {
1933 initializeRenderEngine();
1934
1935 const auto rect = Rect(0, 0, 1, 1);
1936 const renderengine::DisplaySettings display{
1937 .physicalDisplay = rect,
1938 .clip = rect,
1939 };
1940
1941 const renderengine::LayerSettings redLayer{
1942 .geometry.boundaries = rect.toFloatRect(),
1943 .source.solidColor = half3(1.0f, 0.0f, 0.0f),
1944 .alpha = 1.0f,
1945 };
1946
1947 // The next layer will overwrite redLayer with a GraphicBuffer that is green
1948 // applied with a translucent alpha.
1949 const auto buf = allocateSourceBuffer(1, 1);
1950 {
1951 uint8_t* pixels;
1952 buf->getBuffer()->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
1953 reinterpret_cast<void**>(&pixels));
1954 pixels[0] = 0;
1955 pixels[1] = 255;
1956 pixels[2] = 0;
1957 pixels[3] = 255;
1958 buf->getBuffer()->unlock();
1959 }
1960
1961 const renderengine::LayerSettings greenLayer{
1962 .geometry.boundaries = rect.toFloatRect(),
1963 .source =
1964 renderengine::PixelSource{
1965 .buffer =
1966 renderengine::Buffer{
1967 .buffer = buf,
1968 .usePremultipliedAlpha = true,
1969 },
1970 },
1971 .alpha = 0.5f,
1972 .disableBlending = true,
1973 };
1974
1975 std::vector<const renderengine::LayerSettings*> layers{&redLayer, &greenLayer};
1976 invokeDraw(display, layers);
1977 expectBufferColor(rect, 0, 128, 0, 128);
1978 }
1979
TEST_P(RenderEngineTest,test_isOpaque)1980 TEST_P(RenderEngineTest, test_isOpaque) {
1981 initializeRenderEngine();
1982
1983 const auto rect = Rect(0, 0, 1, 1);
1984 const renderengine::DisplaySettings display{
1985 .physicalDisplay = rect,
1986 .clip = rect,
1987 .outputDataspace = ui::Dataspace::DISPLAY_P3,
1988 };
1989
1990 // Create an unpremul buffer that is green with no alpha. Using isOpaque
1991 // should make the green show.
1992 const auto buf = allocateSourceBuffer(1, 1);
1993 {
1994 uint8_t* pixels;
1995 buf->getBuffer()->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
1996 reinterpret_cast<void**>(&pixels));
1997 pixels[0] = 0;
1998 pixels[1] = 255;
1999 pixels[2] = 0;
2000 pixels[3] = 0;
2001 buf->getBuffer()->unlock();
2002 }
2003
2004 const renderengine::LayerSettings greenLayer{
2005 .geometry.boundaries = rect.toFloatRect(),
2006 .source =
2007 renderengine::PixelSource{
2008 .buffer =
2009 renderengine::Buffer{
2010 .buffer = buf,
2011 // Although the pixels are not
2012 // premultiplied in practice, this
2013 // matches the input we see.
2014 .usePremultipliedAlpha = true,
2015 .isOpaque = true,
2016 },
2017 },
2018 .alpha = 1.0f,
2019 };
2020
2021 std::vector<const renderengine::LayerSettings*> layers{&greenLayer};
2022 invokeDraw(display, layers);
2023
2024 if (GetParam()->useColorManagement()) {
2025 expectBufferColor(rect, 117, 251, 76, 255);
2026 } else {
2027 expectBufferColor(rect, 0, 255, 0, 255);
2028 }
2029 }
2030 } // namespace renderengine
2031 } // namespace android
2032
2033 // TODO(b/129481165): remove the #pragma below and fix conversion issues
2034 #pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
2035