SkiaVulkanPipeline.cpp revision 3e9999bd866fac71c72e6b484a9836c87c328a08
1/* 2 * Copyright (C) 2016 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 "SkiaVulkanPipeline.h" 18 19#include "DeferredLayerUpdater.h" 20#include "renderthread/Frame.h" 21#include "Readback.h" 22#include "renderstate/RenderState.h" 23#include "SkiaPipeline.h" 24#include "SkiaProfileRenderer.h" 25#include "VkLayer.h" 26 27#include <SkSurface.h> 28#include <SkTypes.h> 29 30#include <GrContext.h> 31#include <GrTypes.h> 32#include <vk/GrVkTypes.h> 33 34#include <android/native_window.h> 35#include <cutils/properties.h> 36#include <strings.h> 37 38using namespace android::uirenderer::renderthread; 39 40namespace android { 41namespace uirenderer { 42namespace skiapipeline { 43 44SkiaVulkanPipeline::SkiaVulkanPipeline(renderthread::RenderThread& thread) 45 : SkiaPipeline(thread) 46 , mVkManager(thread.vulkanManager()) {} 47 48MakeCurrentResult SkiaVulkanPipeline::makeCurrent() { 49 return MakeCurrentResult::AlreadyCurrent; 50} 51 52Frame SkiaVulkanPipeline::getFrame() { 53 LOG_ALWAYS_FATAL_IF(mVkSurface == nullptr, 54 "drawRenderNode called on a context with no surface!"); 55 56 SkSurface* backBuffer = mVkManager.getBackbufferSurface(mVkSurface); 57 if (backBuffer == nullptr) { 58 SkDebugf("failed to get backbuffer"); 59 return Frame(-1, -1, 0); 60 } 61 62 Frame frame(backBuffer->width(), backBuffer->height(), mVkManager.getAge(mVkSurface)); 63 return frame; 64} 65 66bool SkiaVulkanPipeline::draw(const Frame& frame, const SkRect& screenDirty, 67 const SkRect& dirty, 68 const FrameBuilder::LightGeometry& lightGeometry, 69 LayerUpdateQueue* layerUpdateQueue, 70 const Rect& contentDrawBounds, bool opaque, 71 const BakedOpRenderer::LightInfo& lightInfo, 72 const std::vector<sp<RenderNode>>& renderNodes, 73 FrameInfoVisualizer* profiler) { 74 75 sk_sp<SkSurface> backBuffer = mVkSurface->getBackBufferSurface(); 76 if (backBuffer.get() == nullptr) { 77 return false; 78 } 79 SkiaPipeline::updateLighting(lightGeometry, lightInfo); 80 renderFrame(*layerUpdateQueue, dirty, renderNodes, opaque, contentDrawBounds, backBuffer); 81 layerUpdateQueue->clear(); 82 83 // Draw visual debugging features 84 if (CC_UNLIKELY(Properties::showDirtyRegions 85 || ProfileType::None != Properties::getProfileType())) { 86 SkCanvas* profileCanvas = backBuffer->getCanvas(); 87 SkiaProfileRenderer profileRenderer(profileCanvas); 88 profiler->draw(profileRenderer); 89 profileCanvas->flush(); 90 } 91 92 // Log memory statistics 93 if (CC_UNLIKELY(Properties::debugLevel != kDebugDisabled)) { 94 dumpResourceCacheUsage(); 95 } 96 97 return true; 98} 99 100bool SkiaVulkanPipeline::swapBuffers(const Frame& frame, bool drew, 101 const SkRect& screenDirty, FrameInfo* currentFrameInfo, bool* requireSwap) { 102 103 *requireSwap = drew; 104 105 // Even if we decided to cancel the frame, from the perspective of jank 106 // metrics the frame was swapped at this point 107 currentFrameInfo->markSwapBuffers(); 108 109 if (*requireSwap) { 110 mVkManager.swapBuffers(mVkSurface); 111 } 112 113 return *requireSwap; 114} 115 116bool SkiaVulkanPipeline::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) { 117 // TODO: implement copyLayerInto for vulkan. 118 return false; 119} 120 121static Layer* createLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight, 122 SkColorFilter* colorFilter, int alpha, SkBlendMode mode, bool blend) { 123 return new VkLayer(renderState, layerWidth, layerHeight, colorFilter, alpha, mode, blend); 124} 125 126DeferredLayerUpdater* SkiaVulkanPipeline::createTextureLayer() { 127 mVkManager.initialize(); 128 129 return new DeferredLayerUpdater(mRenderThread.renderState(), createLayer, Layer::Api::Vulkan); 130} 131 132void SkiaVulkanPipeline::onStop() { 133} 134 135bool SkiaVulkanPipeline::setSurface(Surface* surface, SwapBehavior swapBehavior) { 136 if (mVkSurface) { 137 mVkManager.destroySurface(mVkSurface); 138 mVkSurface = nullptr; 139 } 140 141 if (surface) { 142 mVkSurface = mVkManager.createSurface(surface); 143 } 144 145 return mVkSurface != nullptr; 146} 147 148bool SkiaVulkanPipeline::isSurfaceReady() { 149 return CC_UNLIKELY(mVkSurface != nullptr); 150} 151 152bool SkiaVulkanPipeline::isContextReady() { 153 return CC_LIKELY(mVkManager.hasVkContext()); 154} 155 156void SkiaVulkanPipeline::invokeFunctor(const RenderThread& thread, Functor* functor) { 157 // TODO: we currently don't support OpenGL WebView's 158 DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext; 159 (*functor)(mode, nullptr); 160} 161 162} /* namespace skiapipeline */ 163} /* namespace uirenderer */ 164} /* namespace android */ 165