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 #include <gtest/gtest.h>
18
19 #include <renderengine/RenderEngine.h>
20 #include <sync/sync.h>
21 #include <ui/PixelFormat.h>
22 #include "../gl/GLESRenderEngine.h"
23
24 constexpr int DEFAULT_DISPLAY_WIDTH = 128;
25 constexpr int DEFAULT_DISPLAY_HEIGHT = 256;
26 constexpr int DEFAULT_DISPLAY_OFFSET = 64;
27
28 namespace android {
29
30 struct RenderEngineTest : public ::testing::Test {
SetUpTestSuiteandroid::RenderEngineTest31 static void SetUpTestSuite() {
32 sRE = renderengine::gl::GLESRenderEngine::create(static_cast<int32_t>(
33 ui::PixelFormat::RGBA_8888),
34 0, 1);
35 }
36
TearDownTestSuiteandroid::RenderEngineTest37 static void TearDownTestSuite() {
38 // The ordering here is important - sCurrentBuffer must live longer
39 // than RenderEngine to avoid a null reference on tear-down.
40 sRE = nullptr;
41 sCurrentBuffer = nullptr;
42 }
43
allocateDefaultBufferandroid::RenderEngineTest44 static sp<GraphicBuffer> allocateDefaultBuffer() {
45 return new GraphicBuffer(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT,
46 HAL_PIXEL_FORMAT_RGBA_8888, 1,
47 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
48 GRALLOC_USAGE_HW_RENDER,
49 "output");
50 }
51
52 // Allocates a 1x1 buffer to fill with a solid color
allocateSourceBufferandroid::RenderEngineTest53 static sp<GraphicBuffer> allocateSourceBuffer(uint32_t width, uint32_t height) {
54 return new GraphicBuffer(width, height, HAL_PIXEL_FORMAT_RGBA_8888, 1,
55 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
56 GRALLOC_USAGE_HW_TEXTURE,
57 "input");
58 }
59
RenderEngineTestandroid::RenderEngineTest60 RenderEngineTest() { mBuffer = allocateDefaultBuffer(); }
61
~RenderEngineTestandroid::RenderEngineTest62 ~RenderEngineTest() {
63 for (uint32_t texName : mTexNames) {
64 sRE->deleteTextures(1, &texName);
65 }
66 }
67
expectBufferColorandroid::RenderEngineTest68 void expectBufferColor(const Rect& region, uint8_t r, uint8_t g, uint8_t b, uint8_t a,
69 uint8_t tolerance = 0) {
70 uint8_t* pixels;
71 mBuffer->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
72 reinterpret_cast<void**>(&pixels));
73
74 auto colorCompare = [tolerance](uint8_t a, uint8_t b) {
75 uint8_t tmp = a >= b ? a - b : b - a;
76 return tmp <= tolerance;
77 };
78 int32_t maxFails = 10;
79 int32_t fails = 0;
80 for (int32_t j = 0; j < region.getHeight(); j++) {
81 const uint8_t* src =
82 pixels + (mBuffer->getStride() * (region.top + j) + region.left) * 4;
83 for (int32_t i = 0; i < region.getWidth(); i++) {
84 const uint8_t expected[4] = {r, g, b, a};
85 bool equal = std::equal(src, src + 4, expected, colorCompare);
86 EXPECT_TRUE(equal)
87 << "pixel @ (" << region.left + i << ", " << region.top + j << "): "
88 << "expected (" << static_cast<uint32_t>(r) << ", "
89 << static_cast<uint32_t>(g) << ", " << static_cast<uint32_t>(b) << ", "
90 << static_cast<uint32_t>(a) << "), "
91 << "got (" << static_cast<uint32_t>(src[0]) << ", "
92 << static_cast<uint32_t>(src[1]) << ", " << static_cast<uint32_t>(src[2])
93 << ", " << static_cast<uint32_t>(src[3]) << ")";
94 src += 4;
95 if (!equal && ++fails >= maxFails) {
96 break;
97 }
98 }
99 if (fails >= maxFails) {
100 break;
101 }
102 }
103 mBuffer->unlock();
104 }
105
fullscreenRectandroid::RenderEngineTest106 static Rect fullscreenRect() { return Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT); }
107
offsetRectandroid::RenderEngineTest108 static Rect offsetRect() {
109 return Rect(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_WIDTH,
110 DEFAULT_DISPLAY_HEIGHT);
111 }
112
offsetRectAtZeroandroid::RenderEngineTest113 static Rect offsetRectAtZero() {
114 return Rect(DEFAULT_DISPLAY_WIDTH - DEFAULT_DISPLAY_OFFSET,
115 DEFAULT_DISPLAY_HEIGHT - DEFAULT_DISPLAY_OFFSET);
116 }
117
invokeDrawandroid::RenderEngineTest118 void invokeDraw(renderengine::DisplaySettings settings,
119 std::vector<renderengine::LayerSettings> layers, sp<GraphicBuffer> buffer) {
120 base::unique_fd fence;
121 status_t status = sRE->drawLayers(settings, layers, buffer->getNativeBuffer(), true,
122 base::unique_fd(), &fence);
123 sCurrentBuffer = buffer;
124
125 int fd = fence.release();
126 if (fd >= 0) {
127 sync_wait(fd, -1);
128 close(fd);
129 }
130
131 ASSERT_EQ(NO_ERROR, status);
132 if (layers.size() > 0) {
133 ASSERT_TRUE(sRE->isFramebufferImageCachedForTesting(buffer->getId()));
134 }
135 }
136
drawEmptyLayersandroid::RenderEngineTest137 void drawEmptyLayers() {
138 renderengine::DisplaySettings settings;
139 std::vector<renderengine::LayerSettings> layers;
140 // Meaningless buffer since we don't do any drawing
141 sp<GraphicBuffer> buffer = new GraphicBuffer();
142 invokeDraw(settings, layers, buffer);
143 }
144
145 template <typename SourceVariant>
146 void fillBuffer(half r, half g, half b, half a);
147
148 template <typename SourceVariant>
149 void fillRedBuffer();
150
151 template <typename SourceVariant>
152 void fillGreenBuffer();
153
154 template <typename SourceVariant>
155 void fillBlueBuffer();
156
157 template <typename SourceVariant>
158 void fillRedTransparentBuffer();
159
160 template <typename SourceVariant>
161 void fillRedOffsetBuffer();
162
163 template <typename SourceVariant>
164 void fillBufferPhysicalOffset();
165
166 template <typename SourceVariant>
167 void fillBufferCheckers(mat4 transform);
168
169 template <typename SourceVariant>
170 void fillBufferCheckersRotate0();
171
172 template <typename SourceVariant>
173 void fillBufferCheckersRotate90();
174
175 template <typename SourceVariant>
176 void fillBufferCheckersRotate180();
177
178 template <typename SourceVariant>
179 void fillBufferCheckersRotate270();
180
181 template <typename SourceVariant>
182 void fillBufferWithLayerTransform();
183
184 template <typename SourceVariant>
185 void fillBufferLayerTransform();
186
187 template <typename SourceVariant>
188 void fillBufferWithColorTransform();
189
190 template <typename SourceVariant>
191 void fillBufferColorTransform();
192
193 template <typename SourceVariant>
194 void fillRedBufferWithRoundedCorners();
195
196 template <typename SourceVariant>
197 void fillBufferWithRoundedCorners();
198
199 template <typename SourceVariant>
200 void overlayCorners();
201
202 void fillRedBufferTextureTransform();
203
204 void fillBufferTextureTransform();
205
206 void fillRedBufferWithPremultiplyAlpha();
207
208 void fillBufferWithPremultiplyAlpha();
209
210 void fillRedBufferWithoutPremultiplyAlpha();
211
212 void fillBufferWithoutPremultiplyAlpha();
213
214 void fillGreenColorBufferThenClearRegion();
215
216 void clearLeftRegion();
217
218 void clearRegion();
219
220 // Keep around the same renderengine object to save on initialization time.
221 // For now, exercise the GL backend directly so that some caching specifics
222 // can be tested without changing the interface.
223 static std::unique_ptr<renderengine::gl::GLESRenderEngine> sRE;
224 // Dumb hack to avoid NPE in the EGL driver: the GraphicBuffer needs to
225 // be freed *after* RenderEngine is destroyed, so that the EGL image is
226 // destroyed first.
227 static sp<GraphicBuffer> sCurrentBuffer;
228
229 sp<GraphicBuffer> mBuffer;
230
231 std::vector<uint32_t> mTexNames;
232 };
233
234 std::unique_ptr<renderengine::gl::GLESRenderEngine> RenderEngineTest::sRE = nullptr;
235 sp<GraphicBuffer> RenderEngineTest::sCurrentBuffer = nullptr;
236
237 struct ColorSourceVariant {
fillColorandroid::ColorSourceVariant238 static void fillColor(renderengine::LayerSettings& layer, half r, half g, half b,
239 RenderEngineTest* /*fixture*/) {
240 layer.source.solidColor = half3(r, g, b);
241 }
242 };
243
244 struct RelaxOpaqueBufferVariant {
setOpaqueBitandroid::RelaxOpaqueBufferVariant245 static void setOpaqueBit(renderengine::LayerSettings& layer) {
246 layer.source.buffer.isOpaque = false;
247 }
248
getAlphaChannelandroid::RelaxOpaqueBufferVariant249 static uint8_t getAlphaChannel() { return 255; }
250 };
251
252 struct ForceOpaqueBufferVariant {
setOpaqueBitandroid::ForceOpaqueBufferVariant253 static void setOpaqueBit(renderengine::LayerSettings& layer) {
254 layer.source.buffer.isOpaque = true;
255 }
256
getAlphaChannelandroid::ForceOpaqueBufferVariant257 static uint8_t getAlphaChannel() {
258 // The isOpaque bit will override the alpha channel, so this should be
259 // arbitrary.
260 return 10;
261 }
262 };
263
264 template <typename OpaquenessVariant>
265 struct BufferSourceVariant {
fillColorandroid::BufferSourceVariant266 static void fillColor(renderengine::LayerSettings& layer, half r, half g, half b,
267 RenderEngineTest* fixture) {
268 sp<GraphicBuffer> buf = RenderEngineTest::allocateSourceBuffer(1, 1);
269 uint32_t texName;
270 fixture->sRE->genTextures(1, &texName);
271 fixture->mTexNames.push_back(texName);
272
273 uint8_t* pixels;
274 buf->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
275 reinterpret_cast<void**>(&pixels));
276
277 for (int32_t j = 0; j < buf->getHeight(); j++) {
278 uint8_t* iter = pixels + (buf->getStride() * j) * 4;
279 for (int32_t i = 0; i < buf->getWidth(); i++) {
280 iter[0] = uint8_t(r * 255);
281 iter[1] = uint8_t(g * 255);
282 iter[2] = uint8_t(b * 255);
283 iter[3] = OpaquenessVariant::getAlphaChannel();
284 iter += 4;
285 }
286 }
287
288 buf->unlock();
289
290 layer.source.buffer.buffer = buf;
291 layer.source.buffer.textureName = texName;
292 OpaquenessVariant::setOpaqueBit(layer);
293 }
294 };
295
296 template <typename SourceVariant>
fillBuffer(half r,half g,half b,half a)297 void RenderEngineTest::fillBuffer(half r, half g, half b, half a) {
298 renderengine::DisplaySettings settings;
299 settings.physicalDisplay = fullscreenRect();
300 settings.clip = fullscreenRect();
301
302 std::vector<renderengine::LayerSettings> layers;
303
304 renderengine::LayerSettings layer;
305 layer.geometry.boundaries = fullscreenRect().toFloatRect();
306 SourceVariant::fillColor(layer, r, g, b, this);
307 layer.alpha = a;
308
309 layers.push_back(layer);
310
311 invokeDraw(settings, layers, mBuffer);
312 }
313
314 template <typename SourceVariant>
fillRedBuffer()315 void RenderEngineTest::fillRedBuffer() {
316 fillBuffer<SourceVariant>(1.0f, 0.0f, 0.0f, 1.0f);
317 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
318 }
319
320 template <typename SourceVariant>
fillGreenBuffer()321 void RenderEngineTest::fillGreenBuffer() {
322 fillBuffer<SourceVariant>(0.0f, 1.0f, 0.0f, 1.0f);
323 expectBufferColor(fullscreenRect(), 0, 255, 0, 255);
324 }
325
326 template <typename SourceVariant>
fillBlueBuffer()327 void RenderEngineTest::fillBlueBuffer() {
328 fillBuffer<SourceVariant>(0.0f, 0.0f, 1.0f, 1.0f);
329 expectBufferColor(fullscreenRect(), 0, 0, 255, 255);
330 }
331
332 template <typename SourceVariant>
fillRedTransparentBuffer()333 void RenderEngineTest::fillRedTransparentBuffer() {
334 fillBuffer<SourceVariant>(1.0f, 0.0f, 0.0f, .2f);
335 expectBufferColor(fullscreenRect(), 51, 0, 0, 51);
336 }
337
338 template <typename SourceVariant>
fillRedOffsetBuffer()339 void RenderEngineTest::fillRedOffsetBuffer() {
340 renderengine::DisplaySettings settings;
341 settings.physicalDisplay = offsetRect();
342 settings.clip = offsetRectAtZero();
343
344 std::vector<renderengine::LayerSettings> layers;
345
346 renderengine::LayerSettings layer;
347 layer.geometry.boundaries = offsetRectAtZero().toFloatRect();
348 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
349 layer.alpha = 1.0f;
350
351 layers.push_back(layer);
352 invokeDraw(settings, layers, mBuffer);
353 }
354
355 template <typename SourceVariant>
fillBufferPhysicalOffset()356 void RenderEngineTest::fillBufferPhysicalOffset() {
357 fillRedOffsetBuffer<SourceVariant>();
358
359 expectBufferColor(Rect(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_WIDTH,
360 DEFAULT_DISPLAY_HEIGHT),
361 255, 0, 0, 255);
362 Rect offsetRegionLeft(DEFAULT_DISPLAY_OFFSET, DEFAULT_DISPLAY_HEIGHT);
363 Rect offsetRegionTop(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_OFFSET);
364
365 expectBufferColor(offsetRegionLeft, 0, 0, 0, 0);
366 expectBufferColor(offsetRegionTop, 0, 0, 0, 0);
367 }
368
369 template <typename SourceVariant>
fillBufferCheckers(mat4 transform)370 void RenderEngineTest::fillBufferCheckers(mat4 transform) {
371 renderengine::DisplaySettings settings;
372 settings.physicalDisplay = fullscreenRect();
373 // Here logical space is 2x2
374 settings.clip = Rect(2, 2);
375 settings.globalTransform = transform;
376
377 std::vector<renderengine::LayerSettings> layers;
378
379 renderengine::LayerSettings layerOne;
380 Rect rectOne(0, 0, 1, 1);
381 layerOne.geometry.boundaries = rectOne.toFloatRect();
382 SourceVariant::fillColor(layerOne, 1.0f, 0.0f, 0.0f, this);
383 layerOne.alpha = 1.0f;
384
385 renderengine::LayerSettings layerTwo;
386 Rect rectTwo(0, 1, 1, 2);
387 layerTwo.geometry.boundaries = rectTwo.toFloatRect();
388 SourceVariant::fillColor(layerTwo, 0.0f, 1.0f, 0.0f, this);
389 layerTwo.alpha = 1.0f;
390
391 renderengine::LayerSettings layerThree;
392 Rect rectThree(1, 0, 2, 1);
393 layerThree.geometry.boundaries = rectThree.toFloatRect();
394 SourceVariant::fillColor(layerThree, 0.0f, 0.0f, 1.0f, this);
395 layerThree.alpha = 1.0f;
396
397 layers.push_back(layerOne);
398 layers.push_back(layerTwo);
399 layers.push_back(layerThree);
400
401 invokeDraw(settings, layers, mBuffer);
402 }
403
404 template <typename SourceVariant>
fillBufferCheckersRotate0()405 void RenderEngineTest::fillBufferCheckersRotate0() {
406 fillBufferCheckers<SourceVariant>(mat4());
407 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 255, 0, 0,
408 255);
409 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
410 DEFAULT_DISPLAY_HEIGHT / 2),
411 0, 0, 255, 255);
412 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
413 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
414 0, 0, 0, 0);
415 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
416 DEFAULT_DISPLAY_HEIGHT),
417 0, 255, 0, 255);
418 }
419
420 template <typename SourceVariant>
fillBufferCheckersRotate90()421 void RenderEngineTest::fillBufferCheckersRotate90() {
422 mat4 matrix = mat4(0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 1);
423 fillBufferCheckers<SourceVariant>(matrix);
424 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 255, 0,
425 255);
426 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
427 DEFAULT_DISPLAY_HEIGHT / 2),
428 255, 0, 0, 255);
429 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
430 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
431 0, 0, 255, 255);
432 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
433 DEFAULT_DISPLAY_HEIGHT),
434 0, 0, 0, 0);
435 }
436
437 template <typename SourceVariant>
fillBufferCheckersRotate180()438 void RenderEngineTest::fillBufferCheckersRotate180() {
439 mat4 matrix = mat4(-1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 2, 2, 0, 1);
440 fillBufferCheckers<SourceVariant>(matrix);
441 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 0,
442 0);
443 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
444 DEFAULT_DISPLAY_HEIGHT / 2),
445 0, 255, 0, 255);
446 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
447 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
448 255, 0, 0, 255);
449 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
450 DEFAULT_DISPLAY_HEIGHT),
451 0, 0, 255, 255);
452 }
453
454 template <typename SourceVariant>
fillBufferCheckersRotate270()455 void RenderEngineTest::fillBufferCheckersRotate270() {
456 mat4 matrix = mat4(0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 1);
457 fillBufferCheckers<SourceVariant>(matrix);
458 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 255,
459 255);
460 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
461 DEFAULT_DISPLAY_HEIGHT / 2),
462 0, 0, 0, 0);
463 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
464 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
465 0, 255, 0, 255);
466 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT / 2, DEFAULT_DISPLAY_WIDTH / 2,
467 DEFAULT_DISPLAY_HEIGHT),
468 255, 0, 0, 255);
469 }
470
471 template <typename SourceVariant>
fillBufferWithLayerTransform()472 void RenderEngineTest::fillBufferWithLayerTransform() {
473 renderengine::DisplaySettings settings;
474 settings.physicalDisplay = fullscreenRect();
475 // Here logical space is 2x2
476 settings.clip = Rect(2, 2);
477
478 std::vector<renderengine::LayerSettings> layers;
479
480 renderengine::LayerSettings layer;
481 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
482 // Translate one pixel diagonally
483 layer.geometry.positionTransform = mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1);
484 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
485 layer.source.solidColor = half3(1.0f, 0.0f, 0.0f);
486 layer.alpha = 1.0f;
487
488 layers.push_back(layer);
489
490 invokeDraw(settings, layers, mBuffer);
491 }
492
493 template <typename SourceVariant>
fillBufferLayerTransform()494 void RenderEngineTest::fillBufferLayerTransform() {
495 fillBufferWithLayerTransform<SourceVariant>();
496 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT / 2), 0, 0, 0, 0);
497 expectBufferColor(Rect(0, 0, DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 0);
498 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT / 2,
499 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
500 255, 0, 0, 255);
501 }
502
503 template <typename SourceVariant>
fillBufferWithColorTransform()504 void RenderEngineTest::fillBufferWithColorTransform() {
505 renderengine::DisplaySettings settings;
506 settings.physicalDisplay = fullscreenRect();
507 settings.clip = Rect(1, 1);
508
509 std::vector<renderengine::LayerSettings> layers;
510
511 renderengine::LayerSettings layer;
512 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
513 SourceVariant::fillColor(layer, 0.5f, 0.25f, 0.125f, this);
514 layer.alpha = 1.0f;
515
516 // construct a fake color matrix
517 // annihilate green and blue channels
518 settings.colorTransform = mat4::scale(vec4(1, 0, 0, 1));
519 // set red channel to red + green
520 layer.colorTransform = mat4(1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
521
522 layer.alpha = 1.0f;
523 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
524
525 layers.push_back(layer);
526
527 invokeDraw(settings, layers, mBuffer);
528 }
529
530 template <typename SourceVariant>
fillBufferColorTransform()531 void RenderEngineTest::fillBufferColorTransform() {
532 fillBufferWithColorTransform<SourceVariant>();
533 expectBufferColor(fullscreenRect(), 191, 0, 0, 255);
534 }
535
536 template <typename SourceVariant>
fillRedBufferWithRoundedCorners()537 void RenderEngineTest::fillRedBufferWithRoundedCorners() {
538 renderengine::DisplaySettings settings;
539 settings.physicalDisplay = fullscreenRect();
540 settings.clip = fullscreenRect();
541
542 std::vector<renderengine::LayerSettings> layers;
543
544 renderengine::LayerSettings layer;
545 layer.geometry.boundaries = fullscreenRect().toFloatRect();
546 layer.geometry.roundedCornersRadius = 5.0f;
547 layer.geometry.roundedCornersCrop = fullscreenRect().toFloatRect();
548 SourceVariant::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
549 layer.alpha = 1.0f;
550
551 layers.push_back(layer);
552
553 invokeDraw(settings, layers, mBuffer);
554 }
555
556 template <typename SourceVariant>
fillBufferWithRoundedCorners()557 void RenderEngineTest::fillBufferWithRoundedCorners() {
558 fillRedBufferWithRoundedCorners<SourceVariant>();
559 // Corners should be ignored...
560 expectBufferColor(Rect(0, 0, 1, 1), 0, 0, 0, 0);
561 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH - 1, 0, DEFAULT_DISPLAY_WIDTH, 1), 0, 0, 0, 0);
562 expectBufferColor(Rect(0, DEFAULT_DISPLAY_HEIGHT - 1, 1, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 0);
563 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH - 1, DEFAULT_DISPLAY_HEIGHT - 1,
564 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
565 0, 0, 0, 0);
566 // ...And the non-rounded portion should be red.
567 // Other pixels may be anti-aliased, so let's not check those.
568 expectBufferColor(Rect(5, 5, DEFAULT_DISPLAY_WIDTH - 5, DEFAULT_DISPLAY_HEIGHT - 5), 255, 0, 0,
569 255);
570 }
571
572 template <typename SourceVariant>
overlayCorners()573 void RenderEngineTest::overlayCorners() {
574 renderengine::DisplaySettings settings;
575 settings.physicalDisplay = fullscreenRect();
576 settings.clip = fullscreenRect();
577
578 std::vector<renderengine::LayerSettings> layersFirst;
579
580 renderengine::LayerSettings layerOne;
581 layerOne.geometry.boundaries =
582 FloatRect(0, 0, DEFAULT_DISPLAY_WIDTH / 3.0, DEFAULT_DISPLAY_HEIGHT / 3.0);
583 SourceVariant::fillColor(layerOne, 1.0f, 0.0f, 0.0f, this);
584 layerOne.alpha = 0.2;
585
586 layersFirst.push_back(layerOne);
587 invokeDraw(settings, layersFirst, mBuffer);
588 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3, DEFAULT_DISPLAY_HEIGHT / 3), 51, 0, 0, 51);
589 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3 + 1, DEFAULT_DISPLAY_HEIGHT / 3 + 1,
590 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
591 0, 0, 0, 0);
592
593 std::vector<renderengine::LayerSettings> layersSecond;
594 renderengine::LayerSettings layerTwo;
595 layerTwo.geometry.boundaries =
596 FloatRect(DEFAULT_DISPLAY_WIDTH / 3.0, DEFAULT_DISPLAY_HEIGHT / 3.0,
597 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
598 SourceVariant::fillColor(layerTwo, 0.0f, 1.0f, 0.0f, this);
599 layerTwo.alpha = 1.0f;
600
601 layersSecond.push_back(layerTwo);
602 invokeDraw(settings, layersSecond, mBuffer);
603
604 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3, DEFAULT_DISPLAY_HEIGHT / 3), 0, 0, 0, 0);
605 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 3 + 1, DEFAULT_DISPLAY_HEIGHT / 3 + 1,
606 DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
607 0, 255, 0, 255);
608 }
609
fillRedBufferTextureTransform()610 void RenderEngineTest::fillRedBufferTextureTransform() {
611 renderengine::DisplaySettings settings;
612 settings.physicalDisplay = fullscreenRect();
613 settings.clip = Rect(1, 1);
614
615 std::vector<renderengine::LayerSettings> layers;
616
617 renderengine::LayerSettings layer;
618 // Here will allocate a checker board texture, but transform texture
619 // coordinates so that only the upper left is applied.
620 sp<GraphicBuffer> buf = allocateSourceBuffer(2, 2);
621 uint32_t texName;
622 RenderEngineTest::sRE->genTextures(1, &texName);
623 this->mTexNames.push_back(texName);
624
625 uint8_t* pixels;
626 buf->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
627 reinterpret_cast<void**>(&pixels));
628 // Red top left, Green top right, Blue bottom left, Black bottom right
629 pixels[0] = 255;
630 pixels[1] = 0;
631 pixels[2] = 0;
632 pixels[3] = 255;
633 pixels[4] = 0;
634 pixels[5] = 255;
635 pixels[6] = 0;
636 pixels[7] = 255;
637 pixels[8] = 0;
638 pixels[9] = 0;
639 pixels[10] = 255;
640 pixels[11] = 255;
641 buf->unlock();
642
643 layer.source.buffer.buffer = buf;
644 layer.source.buffer.textureName = texName;
645 // Transform coordinates to only be inside the red quadrant.
646 layer.source.buffer.textureTransform = mat4::scale(vec4(0.2, 0.2, 1, 1));
647 layer.alpha = 1.0f;
648 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
649
650 layers.push_back(layer);
651
652 invokeDraw(settings, layers, mBuffer);
653 }
654
fillBufferTextureTransform()655 void RenderEngineTest::fillBufferTextureTransform() {
656 fillRedBufferTextureTransform();
657 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
658 }
659
fillRedBufferWithPremultiplyAlpha()660 void RenderEngineTest::fillRedBufferWithPremultiplyAlpha() {
661 renderengine::DisplaySettings settings;
662 settings.physicalDisplay = fullscreenRect();
663 // Here logical space is 1x1
664 settings.clip = Rect(1, 1);
665
666 std::vector<renderengine::LayerSettings> layers;
667
668 renderengine::LayerSettings layer;
669 sp<GraphicBuffer> buf = allocateSourceBuffer(1, 1);
670 uint32_t texName;
671 RenderEngineTest::sRE->genTextures(1, &texName);
672 this->mTexNames.push_back(texName);
673
674 uint8_t* pixels;
675 buf->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
676 reinterpret_cast<void**>(&pixels));
677 pixels[0] = 255;
678 pixels[1] = 0;
679 pixels[2] = 0;
680 pixels[3] = 255;
681 buf->unlock();
682
683 layer.source.buffer.buffer = buf;
684 layer.source.buffer.textureName = texName;
685 layer.source.buffer.usePremultipliedAlpha = true;
686 layer.alpha = 0.5f;
687 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
688
689 layers.push_back(layer);
690
691 invokeDraw(settings, layers, mBuffer);
692 }
693
fillBufferWithPremultiplyAlpha()694 void RenderEngineTest::fillBufferWithPremultiplyAlpha() {
695 fillRedBufferWithPremultiplyAlpha();
696 expectBufferColor(fullscreenRect(), 128, 0, 0, 128);
697 }
698
fillRedBufferWithoutPremultiplyAlpha()699 void RenderEngineTest::fillRedBufferWithoutPremultiplyAlpha() {
700 renderengine::DisplaySettings settings;
701 settings.physicalDisplay = fullscreenRect();
702 // Here logical space is 1x1
703 settings.clip = Rect(1, 1);
704
705 std::vector<renderengine::LayerSettings> layers;
706
707 renderengine::LayerSettings layer;
708 sp<GraphicBuffer> buf = allocateSourceBuffer(1, 1);
709 uint32_t texName;
710 RenderEngineTest::sRE->genTextures(1, &texName);
711 this->mTexNames.push_back(texName);
712
713 uint8_t* pixels;
714 buf->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
715 reinterpret_cast<void**>(&pixels));
716 pixels[0] = 255;
717 pixels[1] = 0;
718 pixels[2] = 0;
719 pixels[3] = 255;
720 buf->unlock();
721
722 layer.source.buffer.buffer = buf;
723 layer.source.buffer.textureName = texName;
724 layer.source.buffer.usePremultipliedAlpha = false;
725 layer.alpha = 0.5f;
726 layer.geometry.boundaries = Rect(1, 1).toFloatRect();
727
728 layers.push_back(layer);
729
730 invokeDraw(settings, layers, mBuffer);
731 }
732
fillBufferWithoutPremultiplyAlpha()733 void RenderEngineTest::fillBufferWithoutPremultiplyAlpha() {
734 fillRedBufferWithoutPremultiplyAlpha();
735 expectBufferColor(fullscreenRect(), 128, 0, 0, 64, 1);
736 }
737
clearLeftRegion()738 void RenderEngineTest::clearLeftRegion() {
739 renderengine::DisplaySettings settings;
740 settings.physicalDisplay = fullscreenRect();
741 // Here logical space is 4x4
742 settings.clip = Rect(4, 4);
743 settings.globalTransform = mat4::scale(vec4(2, 4, 0, 1));
744 settings.clearRegion = Region(Rect(1, 1));
745 std::vector<renderengine::LayerSettings> layers;
746 // dummy layer, without bounds should not render anything
747 renderengine::LayerSettings layer;
748 layers.push_back(layer);
749 invokeDraw(settings, layers, mBuffer);
750 }
751
clearRegion()752 void RenderEngineTest::clearRegion() {
753 // Reuse mBuffer
754 clearLeftRegion();
755 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, DEFAULT_DISPLAY_HEIGHT), 0, 0, 0, 255);
756 expectBufferColor(Rect(DEFAULT_DISPLAY_WIDTH / 2, 0, DEFAULT_DISPLAY_WIDTH,
757 DEFAULT_DISPLAY_HEIGHT),
758 0, 0, 0, 0);
759 }
760
TEST_F(RenderEngineTest,drawLayers_noLayersToDraw)761 TEST_F(RenderEngineTest, drawLayers_noLayersToDraw) {
762 drawEmptyLayers();
763 }
764
TEST_F(RenderEngineTest,drawLayers_nullOutputBuffer)765 TEST_F(RenderEngineTest, drawLayers_nullOutputBuffer) {
766 renderengine::DisplaySettings settings;
767 std::vector<renderengine::LayerSettings> layers;
768 renderengine::LayerSettings layer;
769 layer.geometry.boundaries = fullscreenRect().toFloatRect();
770 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
771 layers.push_back(layer);
772 base::unique_fd fence;
773 status_t status = sRE->drawLayers(settings, layers, nullptr, true, base::unique_fd(), &fence);
774
775 ASSERT_EQ(BAD_VALUE, status);
776 }
777
TEST_F(RenderEngineTest,drawLayers_nullOutputFence)778 TEST_F(RenderEngineTest, drawLayers_nullOutputFence) {
779 renderengine::DisplaySettings settings;
780 settings.physicalDisplay = fullscreenRect();
781 settings.clip = fullscreenRect();
782
783 std::vector<renderengine::LayerSettings> layers;
784 renderengine::LayerSettings layer;
785 layer.geometry.boundaries = fullscreenRect().toFloatRect();
786 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
787 layer.alpha = 1.0;
788 layers.push_back(layer);
789
790 status_t status = sRE->drawLayers(settings, layers, mBuffer->getNativeBuffer(), true,
791 base::unique_fd(), nullptr);
792 sCurrentBuffer = mBuffer;
793 ASSERT_EQ(NO_ERROR, status);
794 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
795 }
796
TEST_F(RenderEngineTest,drawLayers_doesNotCacheFramebuffer)797 TEST_F(RenderEngineTest, drawLayers_doesNotCacheFramebuffer) {
798 renderengine::DisplaySettings settings;
799 settings.physicalDisplay = fullscreenRect();
800 settings.clip = fullscreenRect();
801
802 std::vector<renderengine::LayerSettings> layers;
803 renderengine::LayerSettings layer;
804 layer.geometry.boundaries = fullscreenRect().toFloatRect();
805 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
806 layer.alpha = 1.0;
807 layers.push_back(layer);
808
809 status_t status = sRE->drawLayers(settings, layers, mBuffer->getNativeBuffer(), false,
810 base::unique_fd(), nullptr);
811 sCurrentBuffer = mBuffer;
812 ASSERT_EQ(NO_ERROR, status);
813 ASSERT_FALSE(sRE->isFramebufferImageCachedForTesting(mBuffer->getId()));
814 expectBufferColor(fullscreenRect(), 255, 0, 0, 255);
815 }
816
TEST_F(RenderEngineTest,drawLayers_fillRedBuffer_colorSource)817 TEST_F(RenderEngineTest, drawLayers_fillRedBuffer_colorSource) {
818 fillRedBuffer<ColorSourceVariant>();
819 }
820
TEST_F(RenderEngineTest,drawLayers_fillGreenBuffer_colorSource)821 TEST_F(RenderEngineTest, drawLayers_fillGreenBuffer_colorSource) {
822 fillGreenBuffer<ColorSourceVariant>();
823 }
824
TEST_F(RenderEngineTest,drawLayers_fillBlueBuffer_colorSource)825 TEST_F(RenderEngineTest, drawLayers_fillBlueBuffer_colorSource) {
826 fillBlueBuffer<ColorSourceVariant>();
827 }
828
TEST_F(RenderEngineTest,drawLayers_fillRedTransparentBuffer_colorSource)829 TEST_F(RenderEngineTest, drawLayers_fillRedTransparentBuffer_colorSource) {
830 fillRedTransparentBuffer<ColorSourceVariant>();
831 }
832
TEST_F(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_colorSource)833 TEST_F(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_colorSource) {
834 fillBufferPhysicalOffset<ColorSourceVariant>();
835 }
836
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_colorSource)837 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_colorSource) {
838 fillBufferCheckersRotate0<ColorSourceVariant>();
839 }
840
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_colorSource)841 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_colorSource) {
842 fillBufferCheckersRotate90<ColorSourceVariant>();
843 }
844
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_colorSource)845 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_colorSource) {
846 fillBufferCheckersRotate180<ColorSourceVariant>();
847 }
848
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_colorSource)849 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_colorSource) {
850 fillBufferCheckersRotate270<ColorSourceVariant>();
851 }
852
TEST_F(RenderEngineTest,drawLayers_fillBufferLayerTransform_colorSource)853 TEST_F(RenderEngineTest, drawLayers_fillBufferLayerTransform_colorSource) {
854 fillBufferLayerTransform<ColorSourceVariant>();
855 }
856
TEST_F(RenderEngineTest,drawLayers_fillBufferColorTransform_colorSource)857 TEST_F(RenderEngineTest, drawLayers_fillBufferColorTransform_colorSource) {
858 fillBufferLayerTransform<ColorSourceVariant>();
859 }
860
TEST_F(RenderEngineTest,drawLayers_fillBufferRoundedCorners_colorSource)861 TEST_F(RenderEngineTest, drawLayers_fillBufferRoundedCorners_colorSource) {
862 fillBufferWithRoundedCorners<ColorSourceVariant>();
863 }
864
TEST_F(RenderEngineTest,drawLayers_overlayCorners_colorSource)865 TEST_F(RenderEngineTest, drawLayers_overlayCorners_colorSource) {
866 overlayCorners<ColorSourceVariant>();
867 }
868
TEST_F(RenderEngineTest,drawLayers_fillRedBuffer_opaqueBufferSource)869 TEST_F(RenderEngineTest, drawLayers_fillRedBuffer_opaqueBufferSource) {
870 fillRedBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
871 }
872
TEST_F(RenderEngineTest,drawLayers_fillGreenBuffer_opaqueBufferSource)873 TEST_F(RenderEngineTest, drawLayers_fillGreenBuffer_opaqueBufferSource) {
874 fillGreenBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
875 }
876
TEST_F(RenderEngineTest,drawLayers_fillBlueBuffer_opaqueBufferSource)877 TEST_F(RenderEngineTest, drawLayers_fillBlueBuffer_opaqueBufferSource) {
878 fillBlueBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
879 }
880
TEST_F(RenderEngineTest,drawLayers_fillRedTransparentBuffer_opaqueBufferSource)881 TEST_F(RenderEngineTest, drawLayers_fillRedTransparentBuffer_opaqueBufferSource) {
882 fillRedTransparentBuffer<BufferSourceVariant<ForceOpaqueBufferVariant>>();
883 }
884
TEST_F(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_opaqueBufferSource)885 TEST_F(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_opaqueBufferSource) {
886 fillBufferPhysicalOffset<BufferSourceVariant<ForceOpaqueBufferVariant>>();
887 }
888
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_opaqueBufferSource)889 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_opaqueBufferSource) {
890 fillBufferCheckersRotate0<BufferSourceVariant<ForceOpaqueBufferVariant>>();
891 }
892
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_opaqueBufferSource)893 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_opaqueBufferSource) {
894 fillBufferCheckersRotate90<BufferSourceVariant<ForceOpaqueBufferVariant>>();
895 }
896
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_opaqueBufferSource)897 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_opaqueBufferSource) {
898 fillBufferCheckersRotate180<BufferSourceVariant<ForceOpaqueBufferVariant>>();
899 }
900
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_opaqueBufferSource)901 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_opaqueBufferSource) {
902 fillBufferCheckersRotate270<BufferSourceVariant<ForceOpaqueBufferVariant>>();
903 }
904
TEST_F(RenderEngineTest,drawLayers_fillBufferLayerTransform_opaqueBufferSource)905 TEST_F(RenderEngineTest, drawLayers_fillBufferLayerTransform_opaqueBufferSource) {
906 fillBufferLayerTransform<BufferSourceVariant<ForceOpaqueBufferVariant>>();
907 }
908
TEST_F(RenderEngineTest,drawLayers_fillBufferColorTransform_opaqueBufferSource)909 TEST_F(RenderEngineTest, drawLayers_fillBufferColorTransform_opaqueBufferSource) {
910 fillBufferLayerTransform<BufferSourceVariant<ForceOpaqueBufferVariant>>();
911 }
912
TEST_F(RenderEngineTest,drawLayers_fillBufferRoundedCorners_opaqueBufferSource)913 TEST_F(RenderEngineTest, drawLayers_fillBufferRoundedCorners_opaqueBufferSource) {
914 fillBufferWithRoundedCorners<BufferSourceVariant<ForceOpaqueBufferVariant>>();
915 }
916
TEST_F(RenderEngineTest,drawLayers_overlayCorners_opaqueBufferSource)917 TEST_F(RenderEngineTest, drawLayers_overlayCorners_opaqueBufferSource) {
918 overlayCorners<BufferSourceVariant<ForceOpaqueBufferVariant>>();
919 }
920
TEST_F(RenderEngineTest,drawLayers_fillRedBuffer_bufferSource)921 TEST_F(RenderEngineTest, drawLayers_fillRedBuffer_bufferSource) {
922 fillRedBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
923 }
924
TEST_F(RenderEngineTest,drawLayers_fillGreenBuffer_bufferSource)925 TEST_F(RenderEngineTest, drawLayers_fillGreenBuffer_bufferSource) {
926 fillGreenBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
927 }
928
TEST_F(RenderEngineTest,drawLayers_fillBlueBuffer_bufferSource)929 TEST_F(RenderEngineTest, drawLayers_fillBlueBuffer_bufferSource) {
930 fillBlueBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
931 }
932
TEST_F(RenderEngineTest,drawLayers_fillRedTransparentBuffer_bufferSource)933 TEST_F(RenderEngineTest, drawLayers_fillRedTransparentBuffer_bufferSource) {
934 fillRedTransparentBuffer<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
935 }
936
TEST_F(RenderEngineTest,drawLayers_fillBufferPhysicalOffset_bufferSource)937 TEST_F(RenderEngineTest, drawLayers_fillBufferPhysicalOffset_bufferSource) {
938 fillBufferPhysicalOffset<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
939 }
940
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate0_bufferSource)941 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate0_bufferSource) {
942 fillBufferCheckersRotate0<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
943 }
944
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate90_bufferSource)945 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate90_bufferSource) {
946 fillBufferCheckersRotate90<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
947 }
948
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate180_bufferSource)949 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate180_bufferSource) {
950 fillBufferCheckersRotate180<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
951 }
952
TEST_F(RenderEngineTest,drawLayers_fillBufferCheckersRotate270_bufferSource)953 TEST_F(RenderEngineTest, drawLayers_fillBufferCheckersRotate270_bufferSource) {
954 fillBufferCheckersRotate270<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
955 }
956
TEST_F(RenderEngineTest,drawLayers_fillBufferLayerTransform_bufferSource)957 TEST_F(RenderEngineTest, drawLayers_fillBufferLayerTransform_bufferSource) {
958 fillBufferLayerTransform<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
959 }
960
TEST_F(RenderEngineTest,drawLayers_fillBufferColorTransform_bufferSource)961 TEST_F(RenderEngineTest, drawLayers_fillBufferColorTransform_bufferSource) {
962 fillBufferLayerTransform<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
963 }
964
TEST_F(RenderEngineTest,drawLayers_fillBufferRoundedCorners_bufferSource)965 TEST_F(RenderEngineTest, drawLayers_fillBufferRoundedCorners_bufferSource) {
966 fillBufferWithRoundedCorners<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
967 }
968
TEST_F(RenderEngineTest,drawLayers_overlayCorners_bufferSource)969 TEST_F(RenderEngineTest, drawLayers_overlayCorners_bufferSource) {
970 overlayCorners<BufferSourceVariant<RelaxOpaqueBufferVariant>>();
971 }
972
TEST_F(RenderEngineTest,drawLayers_fillBufferTextureTransform)973 TEST_F(RenderEngineTest, drawLayers_fillBufferTextureTransform) {
974 fillBufferTextureTransform();
975 }
976
TEST_F(RenderEngineTest,drawLayers_fillBuffer_premultipliesAlpha)977 TEST_F(RenderEngineTest, drawLayers_fillBuffer_premultipliesAlpha) {
978 fillBufferWithPremultiplyAlpha();
979 }
980
TEST_F(RenderEngineTest,drawLayers_fillBuffer_withoutPremultiplyingAlpha)981 TEST_F(RenderEngineTest, drawLayers_fillBuffer_withoutPremultiplyingAlpha) {
982 fillBufferWithoutPremultiplyAlpha();
983 }
984
TEST_F(RenderEngineTest,drawLayers_clearRegion)985 TEST_F(RenderEngineTest, drawLayers_clearRegion) {
986 clearRegion();
987 }
988
TEST_F(RenderEngineTest,drawLayers_fillsBufferAndCachesImages)989 TEST_F(RenderEngineTest, drawLayers_fillsBufferAndCachesImages) {
990 renderengine::DisplaySettings settings;
991 settings.physicalDisplay = fullscreenRect();
992 settings.clip = fullscreenRect();
993
994 std::vector<renderengine::LayerSettings> layers;
995
996 renderengine::LayerSettings layer;
997 layer.geometry.boundaries = fullscreenRect().toFloatRect();
998 BufferSourceVariant<ForceOpaqueBufferVariant>::fillColor(layer, 1.0f, 0.0f, 0.0f, this);
999
1000 layers.push_back(layer);
1001 invokeDraw(settings, layers, mBuffer);
1002 uint64_t bufferId = layer.source.buffer.buffer->getId();
1003 EXPECT_TRUE(sRE->isImageCachedForTesting(bufferId));
1004 sRE->unbindExternalTextureBuffer(bufferId);
1005 EXPECT_FALSE(sRE->isImageCachedForTesting(bufferId));
1006 }
1007
TEST_F(RenderEngineTest,drawLayers_bindExternalBufferWithNullBuffer)1008 TEST_F(RenderEngineTest, drawLayers_bindExternalBufferWithNullBuffer) {
1009 status_t result = sRE->bindExternalTextureBuffer(0, nullptr, nullptr);
1010 ASSERT_EQ(BAD_VALUE, result);
1011 }
1012
TEST_F(RenderEngineTest,drawLayers_bindExternalBufferCachesImages)1013 TEST_F(RenderEngineTest, drawLayers_bindExternalBufferCachesImages) {
1014 sp<GraphicBuffer> buf = allocateSourceBuffer(1, 1);
1015 uint32_t texName;
1016 sRE->genTextures(1, &texName);
1017 mTexNames.push_back(texName);
1018
1019 sRE->bindExternalTextureBuffer(texName, buf, nullptr);
1020 uint64_t bufferId = buf->getId();
1021 EXPECT_TRUE(sRE->isImageCachedForTesting(bufferId));
1022 sRE->unbindExternalTextureBuffer(bufferId);
1023 EXPECT_FALSE(sRE->isImageCachedForTesting(bufferId));
1024 }
1025
TEST_F(RenderEngineTest,drawLayers_cacheExternalBufferWithNullBuffer)1026 TEST_F(RenderEngineTest, drawLayers_cacheExternalBufferWithNullBuffer) {
1027 status_t result = sRE->cacheExternalTextureBuffer(nullptr);
1028 ASSERT_EQ(BAD_VALUE, result);
1029 }
1030
TEST_F(RenderEngineTest,drawLayers_cacheExternalBufferCachesImages)1031 TEST_F(RenderEngineTest, drawLayers_cacheExternalBufferCachesImages) {
1032 sp<GraphicBuffer> buf = allocateSourceBuffer(1, 1);
1033 uint64_t bufferId = buf->getId();
1034 sRE->cacheExternalTextureBuffer(buf);
1035 EXPECT_TRUE(sRE->isImageCachedForTesting(bufferId));
1036 sRE->unbindExternalTextureBuffer(bufferId);
1037 EXPECT_FALSE(sRE->isImageCachedForTesting(bufferId));
1038 }
1039
1040 } // namespace android
1041