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 19 #include <com_android_graphics_libgui_flags.h> 20 #include <ui/DisplayState.h> 21 22 #include "LayerTransactionTest.h" 23 #include "ui/LayerStack.h" 24 25 namespace android { 26 27 using android::hardware::graphics::common::V1_1::BufferUsage; 28 29 class LayerRenderPathTestHarness { 30 public: LayerRenderPathTestHarness(LayerTransactionTest * delegate,RenderPath renderPath)31 LayerRenderPathTestHarness(LayerTransactionTest* delegate, RenderPath renderPath) 32 : mDelegate(delegate), mRenderPath(renderPath) {} 33 getScreenCapture()34 std::unique_ptr<ScreenCapture> getScreenCapture() { 35 switch (mRenderPath) { 36 case RenderPath::SCREENSHOT: 37 return mDelegate->screenshot(); 38 case RenderPath::VIRTUAL_DISPLAY: 39 40 const auto ids = SurfaceComposerClient::getPhysicalDisplayIds(); 41 const PhysicalDisplayId displayId = ids.front(); 42 const auto displayToken = ids.empty() 43 ? nullptr 44 : SurfaceComposerClient::getPhysicalDisplayToken(displayId); 45 46 ui::DisplayState displayState; 47 SurfaceComposerClient::getDisplayState(displayToken, &displayState); 48 49 ui::DisplayMode displayMode; 50 SurfaceComposerClient::getActiveDisplayMode(displayToken, &displayMode); 51 const ui::Size& resolution = displayMode.resolution; 52 53 sp<IBinder> vDisplay; 54 55 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ) 56 sp<BufferItemConsumer> itemConsumer = sp<BufferItemConsumer>::make( 57 // Sample usage bits from screenrecord 58 GRALLOC_USAGE_HW_VIDEO_ENCODER | GRALLOC_USAGE_SW_READ_OFTEN); 59 sp<BufferListener> listener = sp<BufferListener>::make(this); 60 itemConsumer->setFrameAvailableListener(listener); 61 itemConsumer->setName(String8("Virtual disp consumer (TransactionTest)")); 62 itemConsumer->setDefaultBufferSize(resolution.getWidth(), resolution.getHeight()); 63 #else 64 sp<IGraphicBufferProducer> producer; 65 sp<IGraphicBufferConsumer> consumer; 66 sp<BufferItemConsumer> itemConsumer; 67 BufferQueue::createBufferQueue(&producer, &consumer); 68 69 consumer->setConsumerName(String8("Virtual disp consumer (TransactionTest)")); 70 consumer->setDefaultBufferSize(resolution.getWidth(), resolution.getHeight()); 71 72 itemConsumer = sp<BufferItemConsumer>::make(consumer, 73 // Sample usage bits from screenrecord 74 GRALLOC_USAGE_HW_VIDEO_ENCODER | 75 GRALLOC_USAGE_SW_READ_OFTEN); 76 sp<BufferListener> listener = sp<BufferListener>::make(this); 77 itemConsumer->setFrameAvailableListener(listener); 78 #endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ) 79 80 static const std::string kDisplayName("VirtualDisplay"); 81 vDisplay = SurfaceComposerClient::createVirtualDisplay(kDisplayName, 82 false /*isSecure*/); 83 84 constexpr ui::LayerStack layerStack{ 85 848472}; // ASCII for TTH (TransactionTestHarnesses) 86 sp<SurfaceControl> mirrorSc = 87 SurfaceComposerClient::getDefault()->mirrorDisplay(displayId); 88 89 SurfaceComposerClient::Transaction t; 90 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ) 91 t.setDisplaySurface(vDisplay, 92 itemConsumer->getSurface()->getIGraphicBufferProducer()); 93 #else 94 t.setDisplaySurface(vDisplay, producer); 95 #endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ) 96 t.setDisplayProjection(vDisplay, displayState.orientation, 97 Rect(displayState.layerStackSpaceRect), Rect(resolution)); 98 t.setDisplayLayerStack(vDisplay, layerStack); 99 t.setLayerStack(mirrorSc, layerStack); 100 t.apply(); 101 SurfaceComposerClient::Transaction().apply(true); 102 103 std::unique_lock lock(mMutex); 104 mAvailable = false; 105 // Wait for frame buffer ready. 106 mCondition.wait_for(lock, std::chrono::seconds(2), 107 [this]() NO_THREAD_SAFETY_ANALYSIS { return mAvailable; }); 108 109 BufferItem item; 110 itemConsumer->acquireBuffer(&item, 0, true); 111 constexpr bool kContainsHdr = false; 112 auto sc = std::make_unique<ScreenCapture>(item.mGraphicBuffer, kContainsHdr); 113 itemConsumer->releaseBuffer(item); 114 115 // Possible race condition with destroying virtual displays, in which 116 // CompositionEngine::present may attempt to be called on the same 117 // display multiple times. The layerStack is set to invalid here so 118 // that the display is ignored if that scenario occurs. 119 t.setLayerStack(mirrorSc, ui::INVALID_LAYER_STACK); 120 t.apply(true); 121 SurfaceComposerClient::destroyVirtualDisplay(vDisplay); 122 return sc; 123 } 124 } 125 126 protected: 127 LayerTransactionTest* mDelegate; 128 RenderPath mRenderPath; 129 std::mutex mMutex; 130 std::condition_variable mCondition; 131 bool mAvailable = false; 132 onFrameAvailable()133 void onFrameAvailable() { 134 std::unique_lock lock(mMutex); 135 mAvailable = true; 136 mCondition.notify_all(); 137 } 138 139 class BufferListener : public ConsumerBase::FrameAvailableListener { 140 public: BufferListener(LayerRenderPathTestHarness * owner)141 BufferListener(LayerRenderPathTestHarness* owner) : mOwner(owner) {} 142 LayerRenderPathTestHarness* mOwner; 143 onFrameAvailable(const BufferItem &)144 void onFrameAvailable(const BufferItem& /*item*/) { mOwner->onFrameAvailable(); } 145 }; 146 }; 147 148 class LayerTypeTransactionHarness : public LayerTransactionTest { 149 public: LayerTypeTransactionHarness(uint32_t layerType)150 LayerTypeTransactionHarness(uint32_t layerType) : mLayerType(layerType) {} 151 152 sp<SurfaceControl> createLayer(const char* name, uint32_t width, uint32_t height, 153 uint32_t flags = 0, SurfaceControl* parent = nullptr, 154 uint32_t* outTransformHint = nullptr, 155 PixelFormat format = PIXEL_FORMAT_RGBA_8888) { 156 // if the flags already have a layer type specified, return an error 157 if (flags & ISurfaceComposerClient::eFXSurfaceMask) { 158 return nullptr; 159 } 160 return LayerTransactionTest::createLayer(name, width, height, flags | mLayerType, parent, 161 outTransformHint, format); 162 } 163 fillLayerColor(const sp<SurfaceControl> & layer,const Color & color,uint32_t bufferWidth,uint32_t bufferHeight)164 void fillLayerColor(const sp<SurfaceControl>& layer, const Color& color, uint32_t bufferWidth, 165 uint32_t bufferHeight) { 166 ASSERT_NO_FATAL_FAILURE(LayerTransactionTest::fillLayerColor(mLayerType, layer, color, 167 bufferWidth, bufferHeight)); 168 } 169 fillLayerQuadrant(const sp<SurfaceControl> & layer,uint32_t bufferWidth,uint32_t bufferHeight,const Color & topLeft,const Color & topRight,const Color & bottomLeft,const Color & bottomRight)170 void fillLayerQuadrant(const sp<SurfaceControl>& layer, uint32_t bufferWidth, 171 uint32_t bufferHeight, const Color& topLeft, const Color& topRight, 172 const Color& bottomLeft, const Color& bottomRight) { 173 ASSERT_NO_FATAL_FAILURE(LayerTransactionTest::fillLayerQuadrant(mLayerType, layer, 174 bufferWidth, bufferHeight, 175 topLeft, topRight, 176 bottomLeft, bottomRight)); 177 } 178 179 protected: 180 uint32_t mLayerType; 181 }; 182 } // namespace android 183 #endif 184