| /* | |
| * Copyright (C) 2016 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| #include "SkiaOpenGLPipeline.h" | |
| #include "DeferredLayerUpdater.h" | |
| #include "GlLayer.h" | |
| #include "LayerDrawable.h" | |
| #include "SkiaPipeline.h" | |
| #include "SkiaProfileRenderer.h" | |
| #include "hwui/Bitmap.h" | |
| #include "renderstate/RenderState.h" | |
| #include "renderthread/EglManager.h" | |
| #include "renderthread/Frame.h" | |
| #include "utils/GLUtils.h" | |
| #include "utils/TraceUtils.h" | |
| #include <GrBackendSurface.h> | |
| #include <SkBlendMode.h> | |
| #include <SkImageInfo.h> | |
| #include <cutils/properties.h> | |
| #include <strings.h> | |
| using namespace android::uirenderer::renderthread; | |
| namespace android { | |
| namespace uirenderer { | |
| namespace skiapipeline { | |
| SkiaOpenGLPipeline::SkiaOpenGLPipeline(RenderThread& thread) | |
| : SkiaPipeline(thread), mEglManager(thread.eglManager()) {} | |
| MakeCurrentResult SkiaOpenGLPipeline::makeCurrent() { | |
| // TODO: Figure out why this workaround is needed, see b/13913604 | |
| // In the meantime this matches the behavior of GLRenderer, so it is not a regression | |
| EGLint error = 0; | |
| if (!mEglManager.makeCurrent(mEglSurface, &error)) { | |
| return MakeCurrentResult::AlreadyCurrent; | |
| } | |
| return error ? MakeCurrentResult::Failed : MakeCurrentResult::Succeeded; | |
| } | |
| Frame SkiaOpenGLPipeline::getFrame() { | |
| LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE, | |
| "drawRenderNode called on a context with no surface!"); | |
| return mEglManager.beginFrame(mEglSurface); | |
| } | |
| bool SkiaOpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty, | |
| const LightGeometry& lightGeometry, | |
| LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds, | |
| bool opaque, bool wideColorGamut, const LightInfo& lightInfo, | |
| const std::vector<sp<RenderNode>>& renderNodes, | |
| FrameInfoVisualizer* profiler) { | |
| mEglManager.damageFrame(frame, dirty); | |
| SkColorType colorType; | |
| // setup surface for fbo0 | |
| GrGLFramebufferInfo fboInfo; | |
| fboInfo.fFBOID = 0; | |
| if (wideColorGamut) { | |
| fboInfo.fFormat = GL_RGBA16F; | |
| colorType = kRGBA_F16_SkColorType; | |
| } else { | |
| fboInfo.fFormat = GL_RGBA8; | |
| colorType = kN32_SkColorType; | |
| } | |
| GrBackendRenderTarget backendRT(frame.width(), frame.height(), 0, STENCIL_BUFFER_SIZE, fboInfo); | |
| SkSurfaceProps props(0, kUnknown_SkPixelGeometry); | |
| SkASSERT(mRenderThread.getGrContext() != nullptr); | |
| sk_sp<SkSurface> surface(SkSurface::MakeFromBackendRenderTarget( | |
| mRenderThread.getGrContext(), backendRT, kBottomLeft_GrSurfaceOrigin, colorType, | |
| nullptr, &props)); | |
| SkiaPipeline::updateLighting(lightGeometry, lightInfo); | |
| renderFrame(*layerUpdateQueue, dirty, renderNodes, opaque, wideColorGamut, contentDrawBounds, | |
| surface); | |
| layerUpdateQueue->clear(); | |
| // Draw visual debugging features | |
| if (CC_UNLIKELY(Properties::showDirtyRegions || | |
| ProfileType::None != Properties::getProfileType())) { | |
| SkCanvas* profileCanvas = surface->getCanvas(); | |
| SkiaProfileRenderer profileRenderer(profileCanvas); | |
| profiler->draw(profileRenderer); | |
| profileCanvas->flush(); | |
| } | |
| // Log memory statistics | |
| if (CC_UNLIKELY(Properties::debugLevel != kDebugDisabled)) { | |
| dumpResourceCacheUsage(); | |
| } | |
| return true; | |
| } | |
| bool SkiaOpenGLPipeline::swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty, | |
| FrameInfo* currentFrameInfo, bool* requireSwap) { | |
| GL_CHECKPOINT(LOW); | |
| // Even if we decided to cancel the frame, from the perspective of jank | |
| // metrics the frame was swapped at this point | |
| currentFrameInfo->markSwapBuffers(); | |
| *requireSwap = drew || mEglManager.damageRequiresSwap(); | |
| if (*requireSwap && (CC_UNLIKELY(!mEglManager.swapBuffers(frame, screenDirty)))) { | |
| return false; | |
| } | |
| return *requireSwap; | |
| } | |
| bool SkiaOpenGLPipeline::copyLayerInto(DeferredLayerUpdater* deferredLayer, SkBitmap* bitmap) { | |
| if (!mRenderThread.getGrContext()) { | |
| return false; | |
| } | |
| // acquire most recent buffer for drawing | |
| deferredLayer->updateTexImage(); | |
| deferredLayer->apply(); | |
| // drop the colorSpace as we only support readback into sRGB or extended sRGB | |
| SkImageInfo surfaceInfo = bitmap->info().makeColorSpace(nullptr); | |
| /* This intermediate surface is present to work around a bug in SwiftShader that | |
| * prevents us from reading the contents of the layer's texture directly. The | |
| * workaround involves first rendering that texture into an intermediate buffer and | |
| * then reading from the intermediate buffer into the bitmap. | |
| */ | |
| sk_sp<SkSurface> tmpSurface = SkSurface::MakeRenderTarget(mRenderThread.getGrContext(), | |
| SkBudgeted::kYes, surfaceInfo); | |
| if (!tmpSurface.get()) { | |
| surfaceInfo = surfaceInfo.makeColorType(SkColorType::kN32_SkColorType); | |
| tmpSurface = SkSurface::MakeRenderTarget(mRenderThread.getGrContext(), SkBudgeted::kYes, | |
| surfaceInfo); | |
| if (!tmpSurface.get()) { | |
| ALOGW("Unable to readback GPU contents into the provided bitmap"); | |
| return false; | |
| } | |
| } | |
| Layer* layer = deferredLayer->backingLayer(); | |
| const SkRect dstRect = SkRect::MakeIWH(bitmap->width(), bitmap->height()); | |
| if (LayerDrawable::DrawLayer(mRenderThread.getGrContext(), tmpSurface->getCanvas(), layer, | |
| &dstRect)) { | |
| sk_sp<SkImage> tmpImage = tmpSurface->makeImageSnapshot(); | |
| if (tmpImage->readPixels(surfaceInfo, bitmap->getPixels(), bitmap->rowBytes(), 0, 0)) { | |
| bitmap->notifyPixelsChanged(); | |
| return true; | |
| } | |
| // if we fail to readback from the GPU directly (e.g. 565) then we attempt to read into 8888 | |
| // and then draw that into the destination format before giving up. | |
| SkBitmap tmpBitmap; | |
| SkImageInfo bitmapInfo = | |
| SkImageInfo::MakeN32(bitmap->width(), bitmap->height(), bitmap->alphaType()); | |
| if (tmpBitmap.tryAllocPixels(bitmapInfo) && | |
| tmpImage->readPixels(bitmapInfo, tmpBitmap.getPixels(), tmpBitmap.rowBytes(), 0, 0)) { | |
| SkCanvas canvas(*bitmap); | |
| SkPaint paint; | |
| paint.setBlendMode(SkBlendMode::kSrc); | |
| canvas.drawBitmap(tmpBitmap, 0, 0, &paint); | |
| bitmap->notifyPixelsChanged(); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| static Layer* createLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight, | |
| sk_sp<SkColorFilter> colorFilter, int alpha, SkBlendMode mode, | |
| bool blend) { | |
| GlLayer* layer = | |
| new GlLayer(renderState, layerWidth, layerHeight, colorFilter, alpha, mode, blend); | |
| layer->generateTexture(); | |
| return layer; | |
| } | |
| DeferredLayerUpdater* SkiaOpenGLPipeline::createTextureLayer() { | |
| mRenderThread.requireGlContext(); | |
| return new DeferredLayerUpdater(mRenderThread.renderState(), createLayer, Layer::Api::OpenGL); | |
| } | |
| void SkiaOpenGLPipeline::onStop() { | |
| if (mEglManager.isCurrent(mEglSurface)) { | |
| mEglManager.makeCurrent(EGL_NO_SURFACE); | |
| } | |
| } | |
| bool SkiaOpenGLPipeline::setSurface(Surface* surface, SwapBehavior swapBehavior, | |
| ColorMode colorMode) { | |
| if (mEglSurface != EGL_NO_SURFACE) { | |
| mEglManager.destroySurface(mEglSurface); | |
| mEglSurface = EGL_NO_SURFACE; | |
| } | |
| if (surface) { | |
| mRenderThread.requireGlContext(); | |
| const bool wideColorGamut = colorMode == ColorMode::WideColorGamut; | |
| mEglSurface = mEglManager.createSurface(surface, wideColorGamut); | |
| } | |
| if (mEglSurface != EGL_NO_SURFACE) { | |
| const bool preserveBuffer = (swapBehavior != SwapBehavior::kSwap_discardBuffer); | |
| mBufferPreserved = mEglManager.setPreserveBuffer(mEglSurface, preserveBuffer); | |
| return true; | |
| } | |
| return false; | |
| } | |
| bool SkiaOpenGLPipeline::isSurfaceReady() { | |
| return CC_UNLIKELY(mEglSurface != EGL_NO_SURFACE); | |
| } | |
| bool SkiaOpenGLPipeline::isContextReady() { | |
| return CC_LIKELY(mEglManager.hasEglContext()); | |
| } | |
| void SkiaOpenGLPipeline::invokeFunctor(const RenderThread& thread, Functor* functor) { | |
| DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext; | |
| if (thread.eglManager().hasEglContext()) { | |
| mode = DrawGlInfo::kModeProcess; | |
| } | |
| (*functor)(mode, nullptr); | |
| // If there's no context we don't need to reset as there's no gl state to save/restore | |
| if (mode != DrawGlInfo::kModeProcessNoContext) { | |
| thread.getGrContext()->resetContext(); | |
| } | |
| } | |
| } /* namespace skiapipeline */ | |
| } /* namespace uirenderer */ | |
| } /* namespace android */ |