Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 1 | /* |
| 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 Laskowski | 3cb3d4e | 2019-11-21 11:14:45 -0800 | [diff] [blame] | 19 | #include <ui/DisplayState.h> |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 20 | |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 21 | #include "LayerTransactionTest.h" |
Dominik Laskowski | 3cb3d4e | 2019-11-21 11:14:45 -0800 | [diff] [blame] | 22 | |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 23 | namespace android { |
| 24 | |
| 25 | using android::hardware::graphics::common::V1_1::BufferUsage; |
| 26 | |
| 27 | class LayerRenderPathTestHarness { |
| 28 | public: |
| 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 Laskowski | 3cb3d4e | 2019-11-21 11:14:45 -0800 | [diff] [blame] | 38 | const auto displayToken = SurfaceComposerClient::getInternalDisplayToken(); |
| 39 | |
| 40 | ui::DisplayState displayState; |
| 41 | SurfaceComposerClient::getDisplayState(displayToken, &displayState); |
| 42 | |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame^] | 43 | ui::DisplayMode displayMode; |
| 44 | SurfaceComposerClient::getActiveDisplayMode(displayToken, &displayMode); |
| 45 | const ui::Size& resolution = displayMode.resolution; |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 46 | |
| 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 Laskowski | 3cb3d4e | 2019-11-21 11:14:45 -0800 | [diff] [blame] | 54 | consumer->setDefaultBufferSize(resolution.getWidth(), resolution.getHeight()); |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 55 | |
| 56 | itemConsumer = new BufferItemConsumer(consumer, |
| 57 | // Sample usage bits from screenrecord |
| 58 | GRALLOC_USAGE_HW_VIDEO_ENCODER | |
| 59 | GRALLOC_USAGE_SW_READ_OFTEN); |
Arthur Hung | 5814427 | 2021-01-16 03:43:53 +0000 | [diff] [blame] | 60 | sp<BufferListener> listener = new BufferListener(this); |
| 61 | itemConsumer->setFrameAvailableListener(listener); |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 62 | |
| 63 | vDisplay = SurfaceComposerClient::createDisplay(String8("VirtualDisplay"), |
| 64 | false /*secure*/); |
| 65 | |
| 66 | SurfaceComposerClient::Transaction t; |
| 67 | t.setDisplaySurface(vDisplay, producer); |
| 68 | t.setDisplayLayerStack(vDisplay, 0); |
Dominik Laskowski | 3cb3d4e | 2019-11-21 11:14:45 -0800 | [diff] [blame] | 69 | t.setDisplayProjection(vDisplay, displayState.orientation, |
Marin Shalamanov | 6ad317c | 2020-07-29 23:34:07 +0200 | [diff] [blame] | 70 | Rect(displayState.layerStackSpaceRect), Rect(resolution)); |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 71 | t.apply(); |
| 72 | SurfaceComposerClient::Transaction().apply(true); |
Arthur Hung | 5814427 | 2021-01-16 03:43:53 +0000 | [diff] [blame] | 73 | |
| 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 Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 80 | BufferItem item; |
| 81 | itemConsumer->acquireBuffer(&item, 0, true); |
| 82 | auto sc = std::make_unique<ScreenCapture>(item.mGraphicBuffer); |
| 83 | itemConsumer->releaseBuffer(item); |
| 84 | SurfaceComposerClient::destroyDisplay(vDisplay); |
| 85 | return sc; |
| 86 | } |
| 87 | } |
| 88 | |
| 89 | protected: |
| 90 | LayerTransactionTest* mDelegate; |
| 91 | RenderPath mRenderPath; |
Arthur Hung | 5814427 | 2021-01-16 03:43:53 +0000 | [diff] [blame] | 92 | std::mutex mMutex; |
| 93 | std::condition_variable mCondition; |
| 94 | bool mAvailable = false; |
| 95 | |
| 96 | void onFrameAvailable() { |
| 97 | std::unique_lock lock(mMutex); |
| 98 | mAvailable = true; |
| 99 | mCondition.notify_all(); |
| 100 | } |
| 101 | |
| 102 | class BufferListener : public ConsumerBase::FrameAvailableListener { |
| 103 | public: |
| 104 | BufferListener(LayerRenderPathTestHarness* owner) : mOwner(owner) {} |
| 105 | LayerRenderPathTestHarness* mOwner; |
| 106 | |
| 107 | void onFrameAvailable(const BufferItem& /*item*/) { mOwner->onFrameAvailable(); } |
| 108 | }; |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 109 | }; |
| 110 | |
| 111 | class LayerTypeTransactionHarness : public LayerTransactionTest { |
| 112 | public: |
| 113 | LayerTypeTransactionHarness(uint32_t layerType) : mLayerType(layerType) {} |
| 114 | |
| 115 | sp<SurfaceControl> createLayer(const char* name, uint32_t width, uint32_t height, |
Valerie Hau | 1acd696 | 2019-10-28 16:35:48 -0700 | [diff] [blame] | 116 | uint32_t flags = 0, SurfaceControl* parent = nullptr, |
chaviw | debadb8 | 2020-03-26 14:57:24 -0700 | [diff] [blame] | 117 | uint32_t* outTransformHint = nullptr, |
| 118 | PixelFormat format = PIXEL_FORMAT_RGBA_8888) { |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 119 | // if the flags already have a layer type specified, return an error |
| 120 | if (flags & ISurfaceComposerClient::eFXSurfaceMask) { |
| 121 | return nullptr; |
| 122 | } |
Valerie Hau | 1acd696 | 2019-10-28 16:35:48 -0700 | [diff] [blame] | 123 | return LayerTransactionTest::createLayer(name, width, height, flags | mLayerType, parent, |
chaviw | debadb8 | 2020-03-26 14:57:24 -0700 | [diff] [blame] | 124 | outTransformHint, format); |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 125 | } |
| 126 | |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 127 | void fillLayerColor(const sp<SurfaceControl>& layer, const Color& color, uint32_t bufferWidth, |
| 128 | uint32_t bufferHeight) { |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 129 | ASSERT_NO_FATAL_FAILURE(LayerTransactionTest::fillLayerColor(mLayerType, layer, color, |
| 130 | bufferWidth, bufferHeight)); |
| 131 | } |
| 132 | |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 133 | void fillLayerQuadrant(const sp<SurfaceControl>& layer, uint32_t bufferWidth, |
| 134 | uint32_t bufferHeight, const Color& topLeft, const Color& topRight, |
Valerie Hau | 9cfc6d8 | 2019-09-23 13:54:07 -0700 | [diff] [blame] | 135 | const Color& bottomLeft, const Color& bottomRight) { |
| 136 | ASSERT_NO_FATAL_FAILURE(LayerTransactionTest::fillLayerQuadrant(mLayerType, layer, |
| 137 | bufferWidth, bufferHeight, |
| 138 | topLeft, topRight, |
| 139 | bottomLeft, bottomRight)); |
| 140 | } |
| 141 | |
| 142 | protected: |
| 143 | uint32_t mLayerType; |
| 144 | }; |
| 145 | } // namespace android |
| 146 | #endif |