Home | History | Annotate | Download | only in skia 
      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 "Readback.h"
     21 #include "SkiaPipeline.h"
     22 #include "SkiaProfileRenderer.h"
     23 #include "VkLayer.h"
     24 #include "renderstate/RenderState.h"
     25 #include "renderthread/Frame.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 <cutils/properties.h>
     35 #include <strings.h>
     36 
     37 using namespace android::uirenderer::renderthread;
     38 
     39 namespace android {
     40 namespace uirenderer {
     41 namespace skiapipeline {
     42 
     43 SkiaVulkanPipeline::SkiaVulkanPipeline(renderthread::RenderThread& thread)
     44         : SkiaPipeline(thread), mVkManager(thread.vulkanManager()) {}
     45 
     46 MakeCurrentResult SkiaVulkanPipeline::makeCurrent() {
     47     return MakeCurrentResult::AlreadyCurrent;
     48 }
     49 
     50 Frame SkiaVulkanPipeline::getFrame() {
     51     LOG_ALWAYS_FATAL_IF(mVkSurface == nullptr,
     52                         "drawRenderNode called on a context with no surface!");
     53 
     54     SkSurface* backBuffer = mVkManager.getBackbufferSurface(mVkSurface);
     55     if (backBuffer == nullptr) {
     56         SkDebugf("failed to get backbuffer");
     57         return Frame(-1, -1, 0);
     58     }
     59 
     60     Frame frame(backBuffer->width(), backBuffer->height(), mVkManager.getAge(mVkSurface));
     61     return frame;
     62 }
     63 
     64 bool SkiaVulkanPipeline::draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
     65                               const FrameBuilder::LightGeometry& lightGeometry,
     66                               LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
     67                               bool opaque, bool wideColorGamut,
     68                               const BakedOpRenderer::LightInfo& lightInfo,
     69                               const std::vector<sp<RenderNode>>& renderNodes,
     70                               FrameInfoVisualizer* profiler) {
     71     sk_sp<SkSurface> backBuffer = mVkSurface->getBackBufferSurface();
     72     if (backBuffer.get() == nullptr) {
     73         return false;
     74     }
     75     SkiaPipeline::updateLighting(lightGeometry, lightInfo);
     76     renderFrame(*layerUpdateQueue, dirty, renderNodes, opaque, wideColorGamut, contentDrawBounds,
     77                 backBuffer);
     78     layerUpdateQueue->clear();
     79 
     80     // Draw visual debugging features
     81     if (CC_UNLIKELY(Properties::showDirtyRegions ||
     82                     ProfileType::None != Properties::getProfileType())) {
     83         SkCanvas* profileCanvas = backBuffer->getCanvas();
     84         SkiaProfileRenderer profileRenderer(profileCanvas);
     85         profiler->draw(profileRenderer);
     86         profileCanvas->flush();
     87     }
     88 
     89     // Log memory statistics
     90     if (CC_UNLIKELY(Properties::debugLevel != kDebugDisabled)) {
     91         dumpResourceCacheUsage();
     92     }
     93 
     94     return true;
     95 }
     96 
     97 bool SkiaVulkanPipeline::swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty,
     98                                      FrameInfo* currentFrameInfo, bool* requireSwap) {
     99     *requireSwap = drew;
    100 
    101     // Even if we decided to cancel the frame, from the perspective of jank
    102     // metrics the frame was swapped at this point
    103     currentFrameInfo->markSwapBuffers();
    104 
    105     if (*requireSwap) {
    106         mVkManager.swapBuffers(mVkSurface);
    107     }
    108 
    109     return *requireSwap;
    110 }
    111 
    112 bool SkiaVulkanPipeline::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) {
    113     // TODO: implement copyLayerInto for vulkan.
    114     return false;
    115 }
    116 
    117 static Layer* createLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
    118                           sk_sp<SkColorFilter> colorFilter, int alpha, SkBlendMode mode,
    119                           bool blend) {
    120     return new VkLayer(renderState, layerWidth, layerHeight, colorFilter, alpha, mode, blend);
    121 }
    122 
    123 DeferredLayerUpdater* SkiaVulkanPipeline::createTextureLayer() {
    124     mVkManager.initialize();
    125 
    126     return new DeferredLayerUpdater(mRenderThread.renderState(), createLayer, Layer::Api::Vulkan);
    127 }
    128 
    129 void SkiaVulkanPipeline::onStop() {}
    130 
    131 bool SkiaVulkanPipeline::setSurface(Surface* surface, SwapBehavior swapBehavior,
    132                                     ColorMode colorMode) {
    133     if (mVkSurface) {
    134         mVkManager.destroySurface(mVkSurface);
    135         mVkSurface = nullptr;
    136     }
    137 
    138     if (surface) {
    139         // TODO: handle color mode
    140         mVkSurface = mVkManager.createSurface(surface);
    141     }
    142 
    143     return mVkSurface != nullptr;
    144 }
    145 
    146 bool SkiaVulkanPipeline::isSurfaceReady() {
    147     return CC_UNLIKELY(mVkSurface != nullptr);
    148 }
    149 
    150 bool SkiaVulkanPipeline::isContextReady() {
    151     return CC_LIKELY(mVkManager.hasVkContext());
    152 }
    153 
    154 void SkiaVulkanPipeline::invokeFunctor(const RenderThread& thread, Functor* functor) {
    155     // TODO: we currently don't support OpenGL WebView's
    156     DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext;
    157     (*functor)(mode, nullptr);
    158 }
    159 
    160 sk_sp<Bitmap> SkiaVulkanPipeline::allocateHardwareBitmap(renderthread::RenderThread& renderThread,
    161                                                          SkBitmap& skBitmap) {
    162     // TODO: implement this function for Vulkan pipeline
    163     // code below is a hack to avoid crashing because of missing HW Bitmap support
    164     sp<GraphicBuffer> buffer = new GraphicBuffer(
    165             skBitmap.info().width(), skBitmap.info().height(), PIXEL_FORMAT_RGBA_8888,
    166             GraphicBuffer::USAGE_HW_TEXTURE | GraphicBuffer::USAGE_SW_WRITE_NEVER |
    167                     GraphicBuffer::USAGE_SW_READ_NEVER,
    168             std::string("SkiaVulkanPipeline::allocateHardwareBitmap pid [") +
    169                     std::to_string(getpid()) + "]");
    170     status_t error = buffer->initCheck();
    171     if (error < 0) {
    172         ALOGW("SkiaVulkanPipeline::allocateHardwareBitmap() failed in GraphicBuffer.create()");
    173         return nullptr;
    174     }
    175     return sk_sp<Bitmap>(new Bitmap(buffer.get(), skBitmap.info()));
    176 }
    177 
    178 } /* namespace skiapipeline */
    179 } /* namespace uirenderer */
    180 } /* namespace android */
    181