blob: ad03ed30735474cd7fa74d5b9327e566e8632232 [file] [log] [blame]
Valerie Hau9cfc6d82019-09-23 13:54:07 -07001/*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16#ifndef ANDROID_TRANSACTION_TEST_HARNESSES
17#define ANDROID_TRANSACTION_TEST_HARNESSES
18
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080019#include <ui/DisplayState.h>
Valerie Hau9cfc6d82019-09-23 13:54:07 -070020
Valerie Hau9cfc6d82019-09-23 13:54:07 -070021#include "LayerTransactionTest.h"
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080022
Valerie Hau9cfc6d82019-09-23 13:54:07 -070023namespace android {
24
25using android::hardware::graphics::common::V1_1::BufferUsage;
26
27class LayerRenderPathTestHarness {
28public:
29 LayerRenderPathTestHarness(LayerTransactionTest* delegate, RenderPath renderPath)
30 : mDelegate(delegate), mRenderPath(renderPath) {}
31
32 std::unique_ptr<ScreenCapture> getScreenCapture() {
33 switch (mRenderPath) {
34 case RenderPath::SCREENSHOT:
35 return mDelegate->screenshot();
36 case RenderPath::VIRTUAL_DISPLAY:
37
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080038 const auto displayToken = SurfaceComposerClient::getInternalDisplayToken();
39
40 ui::DisplayState displayState;
41 SurfaceComposerClient::getDisplayState(displayToken, &displayState);
42
Marin Shalamanova7fe3042021-01-29 21:02:08 +010043 ui::DisplayMode displayMode;
44 SurfaceComposerClient::getActiveDisplayMode(displayToken, &displayMode);
45 const ui::Size& resolution = displayMode.resolution;
Valerie Hau9cfc6d82019-09-23 13:54:07 -070046
47 sp<IBinder> vDisplay;
48 sp<IGraphicBufferProducer> producer;
49 sp<IGraphicBufferConsumer> consumer;
50 sp<BufferItemConsumer> itemConsumer;
51 BufferQueue::createBufferQueue(&producer, &consumer);
52
53 consumer->setConsumerName(String8("Virtual disp consumer"));
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080054 consumer->setDefaultBufferSize(resolution.getWidth(), resolution.getHeight());
Valerie Hau9cfc6d82019-09-23 13:54:07 -070055
Ady Abrahamd11bade2022-08-01 16:18:03 -070056 itemConsumer = sp<BufferItemConsumer>::make(consumer,
57 // Sample usage bits from screenrecord
58 GRALLOC_USAGE_HW_VIDEO_ENCODER |
59 GRALLOC_USAGE_SW_READ_OFTEN);
60 sp<BufferListener> listener = sp<BufferListener>::make(this);
Arthur Hung58144272021-01-16 03:43:53 +000061 itemConsumer->setFrameAvailableListener(listener);
Valerie Hau9cfc6d82019-09-23 13:54:07 -070062
63 vDisplay = SurfaceComposerClient::createDisplay(String8("VirtualDisplay"),
64 false /*secure*/);
65
66 SurfaceComposerClient::Transaction t;
67 t.setDisplaySurface(vDisplay, producer);
Dominik Laskowski29fa1462021-04-27 15:51:50 -070068 t.setDisplayLayerStack(vDisplay, ui::DEFAULT_LAYER_STACK);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080069 t.setDisplayProjection(vDisplay, displayState.orientation,
Marin Shalamanov6ad317c2020-07-29 23:34:07 +020070 Rect(displayState.layerStackSpaceRect), Rect(resolution));
Valerie Hau9cfc6d82019-09-23 13:54:07 -070071 t.apply();
72 SurfaceComposerClient::Transaction().apply(true);
Arthur Hung58144272021-01-16 03:43:53 +000073
74 std::unique_lock lock(mMutex);
75 mAvailable = false;
76 // Wait for frame buffer ready.
77 mCondition.wait_for(lock, std::chrono::seconds(2),
78 [this]() NO_THREAD_SAFETY_ANALYSIS { return mAvailable; });
79
Valerie Hau9cfc6d82019-09-23 13:54:07 -070080 BufferItem item;
81 itemConsumer->acquireBuffer(&item, 0, true);
Alec Mouri14d5b862022-04-27 21:20:04 +000082 constexpr bool kContainsHdr = false;
83 auto sc = std::make_unique<ScreenCapture>(item.mGraphicBuffer, kContainsHdr);
Valerie Hau9cfc6d82019-09-23 13:54:07 -070084 itemConsumer->releaseBuffer(item);
85 SurfaceComposerClient::destroyDisplay(vDisplay);
86 return sc;
87 }
88 }
89
90protected:
91 LayerTransactionTest* mDelegate;
92 RenderPath mRenderPath;
Arthur Hung58144272021-01-16 03:43:53 +000093 std::mutex mMutex;
94 std::condition_variable mCondition;
95 bool mAvailable = false;
96
97 void onFrameAvailable() {
98 std::unique_lock lock(mMutex);
99 mAvailable = true;
100 mCondition.notify_all();
101 }
102
103 class BufferListener : public ConsumerBase::FrameAvailableListener {
104 public:
105 BufferListener(LayerRenderPathTestHarness* owner) : mOwner(owner) {}
106 LayerRenderPathTestHarness* mOwner;
107
108 void onFrameAvailable(const BufferItem& /*item*/) { mOwner->onFrameAvailable(); }
109 };
Valerie Hau9cfc6d82019-09-23 13:54:07 -0700110};
111
112class LayerTypeTransactionHarness : public LayerTransactionTest {
113public:
114 LayerTypeTransactionHarness(uint32_t layerType) : mLayerType(layerType) {}
115
116 sp<SurfaceControl> createLayer(const char* name, uint32_t width, uint32_t height,
Valerie Hau1acd6962019-10-28 16:35:48 -0700117 uint32_t flags = 0, SurfaceControl* parent = nullptr,
chaviwdebadb82020-03-26 14:57:24 -0700118 uint32_t* outTransformHint = nullptr,
119 PixelFormat format = PIXEL_FORMAT_RGBA_8888) {
Valerie Hau9cfc6d82019-09-23 13:54:07 -0700120 // if the flags already have a layer type specified, return an error
121 if (flags & ISurfaceComposerClient::eFXSurfaceMask) {
122 return nullptr;
123 }
Valerie Hau1acd6962019-10-28 16:35:48 -0700124 return LayerTransactionTest::createLayer(name, width, height, flags | mLayerType, parent,
chaviwdebadb82020-03-26 14:57:24 -0700125 outTransformHint, format);
Valerie Hau9cfc6d82019-09-23 13:54:07 -0700126 }
127
Marin Shalamanov46084422020-10-13 12:33:42 +0200128 void fillLayerColor(const sp<SurfaceControl>& layer, const Color& color, uint32_t bufferWidth,
129 uint32_t bufferHeight) {
Valerie Hau9cfc6d82019-09-23 13:54:07 -0700130 ASSERT_NO_FATAL_FAILURE(LayerTransactionTest::fillLayerColor(mLayerType, layer, color,
131 bufferWidth, bufferHeight));
132 }
133
Marin Shalamanov46084422020-10-13 12:33:42 +0200134 void fillLayerQuadrant(const sp<SurfaceControl>& layer, uint32_t bufferWidth,
135 uint32_t bufferHeight, const Color& topLeft, const Color& topRight,
Valerie Hau9cfc6d82019-09-23 13:54:07 -0700136 const Color& bottomLeft, const Color& bottomRight) {
137 ASSERT_NO_FATAL_FAILURE(LayerTransactionTest::fillLayerQuadrant(mLayerType, layer,
138 bufferWidth, bufferHeight,
139 topLeft, topRight,
140 bottomLeft, bottomRight));
141 }
142
143protected:
144 uint32_t mLayerType;
145};
146} // namespace android
147#endif