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