blob: c4d3f5cedfa8eabb3740adf03b5e6ecfaae5f894 [file] [log] [blame]
Stan Iliev500a0c32016-10-26 10:30:09 -04001/*
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 "SkiaOpenGLPipeline.h"
18
Alec Mouri3afb3972022-05-27 22:03:11 +000019#include <GrBackendSurface.h>
20#include <SkBlendMode.h>
21#include <SkImageInfo.h>
22#include <cutils/properties.h>
rnleece9762b2021-05-21 15:40:53 -070023#include <gui/TraceUtils.h>
Alec Mouri3afb3972022-05-27 22:03:11 +000024#include <strings.h>
25
Stan Iliev500a0c32016-10-26 10:30:09 -040026#include "DeferredLayerUpdater.h"
Alec Mouri3afb3972022-05-27 22:03:11 +000027#include "FrameInfo.h"
Derek Sollenbergerc4fbada2016-11-07 16:05:41 -050028#include "LayerDrawable.h"
Fedor Kudasov90df0562019-06-19 11:41:34 +010029#include "LightingInfo.h"
Matt Sarettcf2c05c2016-10-26 11:03:23 -040030#include "SkiaPipeline.h"
31#include "SkiaProfileRenderer.h"
John Reck1bcacfd2017-11-03 10:12:19 -070032#include "hwui/Bitmap.h"
Derek Sollenberger28a4d992018-09-20 13:37:24 -040033#include "private/hwui/DrawGlInfo.h"
John Reck1bcacfd2017-11-03 10:12:19 -070034#include "renderstate/RenderState.h"
35#include "renderthread/EglManager.h"
36#include "renderthread/Frame.h"
Alec Mouri3afb3972022-05-27 22:03:11 +000037#include "renderthread/IRenderPipeline.h"
John Reckd9d7f122018-05-03 14:40:56 -070038#include "utils/GLUtils.h"
Stan Iliev500a0c32016-10-26 10:30:09 -040039
Stan Iliev500a0c32016-10-26 10:30:09 -040040using namespace android::uirenderer::renderthread;
41
42namespace android {
43namespace uirenderer {
44namespace skiapipeline {
45
46SkiaOpenGLPipeline::SkiaOpenGLPipeline(RenderThread& thread)
Derek Sollenberger5a5a6482018-09-19 13:52:13 -040047 : SkiaPipeline(thread), mEglManager(thread.eglManager()) {
48 thread.renderState().registerContextCallback(this);
49}
50
51SkiaOpenGLPipeline::~SkiaOpenGLPipeline() {
52 mRenderThread.renderState().removeContextCallback(this);
53}
Stan Iliev500a0c32016-10-26 10:30:09 -040054
55MakeCurrentResult SkiaOpenGLPipeline::makeCurrent() {
Shih-Hsin Li4a012f52021-09-21 18:11:23 -070056 bool wasSurfaceless = mEglManager.isCurrent(EGL_NO_SURFACE);
57
Derek Sollenbergerb8307722022-08-30 14:24:22 -040058 // In case the surface was destroyed (e.g. a previous trimMemory call) we
59 // need to recreate it here.
Nader Jawada3521852023-01-30 20:23:46 -080060 if (mHardwareBuffer) {
61 mRenderThread.requireGlContext();
62 } else if (!isSurfaceReady() && mNativeWindow) {
Derek Sollenbergerb8307722022-08-30 14:24:22 -040063 setSurface(mNativeWindow.get(), mSwapBehavior);
64 }
65
Stan Iliev500a0c32016-10-26 10:30:09 -040066 EGLint error = 0;
67 if (!mEglManager.makeCurrent(mEglSurface, &error)) {
68 return MakeCurrentResult::AlreadyCurrent;
69 }
Shih-Hsin Li4a012f52021-09-21 18:11:23 -070070
71 // Make sure read/draw buffer state of default framebuffer is GL_BACK. Vendor implementations
72 // disagree on the draw/read buffer state if the default framebuffer transitions from a surface
73 // to EGL_NO_SURFACE and vice-versa. There was a related discussion within Khronos on this topic.
74 // See https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13534.
75 // The discussion was not resolved with a clear consensus
76 if (error == 0 && wasSurfaceless && mEglSurface != EGL_NO_SURFACE) {
77 GLint curReadFB = 0;
78 GLint curDrawFB = 0;
79 glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &curReadFB);
80 glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &curDrawFB);
81
82 GLint buffer = GL_NONE;
83 glBindFramebuffer(GL_FRAMEBUFFER, 0);
84 glGetIntegerv(GL_DRAW_BUFFER0, &buffer);
85 if (buffer == GL_NONE) {
86 const GLenum drawBuffer = GL_BACK;
87 glDrawBuffers(1, &drawBuffer);
88 }
89
90 glGetIntegerv(GL_READ_BUFFER, &buffer);
91 if (buffer == GL_NONE) {
92 glReadBuffer(GL_BACK);
93 }
94
95 glBindFramebuffer(GL_READ_FRAMEBUFFER, curReadFB);
96 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, curDrawFB);
97
98 GL_CHECKPOINT(LOW);
99 }
100
Stan Iliev500a0c32016-10-26 10:30:09 -0400101 return error ? MakeCurrentResult::Failed : MakeCurrentResult::Succeeded;
102}
103
104Frame SkiaOpenGLPipeline::getFrame() {
Nader Jawad24617222023-03-30 12:29:01 -0700105 LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE,
106 "drawRenderNode called on a context with no surface!");
107 return mEglManager.beginFrame(mEglSurface);
Stan Iliev500a0c32016-10-26 10:30:09 -0400108}
109
Alec Mouri3afb3972022-05-27 22:03:11 +0000110IRenderPipeline::DrawResult SkiaOpenGLPipeline::draw(
111 const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
112 const LightGeometry& lightGeometry, LayerUpdateQueue* layerUpdateQueue,
113 const Rect& contentDrawBounds, bool opaque, const LightInfo& lightInfo,
Nader Jawada3521852023-01-30 20:23:46 -0800114 const std::vector<sp<RenderNode>>& renderNodes, FrameInfoVisualizer* profiler,
115 const HardwareBufferRenderParams& bufferParams) {
116 if (!isCapturingSkp() && !mHardwareBuffer) {
John Reck76005182021-06-09 22:43:05 -0400117 mEglManager.damageFrame(frame, dirty);
118 }
Stan Iliev500a0c32016-10-26 10:30:09 -0400119
Peiyong Lin1f6aa122018-09-10 16:28:08 -0700120 SkColorType colorType = getSurfaceColorType();
Stan Iliev500a0c32016-10-26 10:30:09 -0400121 // setup surface for fbo0
Greg Danielac2d2322017-07-12 11:30:15 -0400122 GrGLFramebufferInfo fboInfo;
123 fboInfo.fFBOID = 0;
Peiyong Lin1f6aa122018-09-10 16:28:08 -0700124 if (colorType == kRGBA_F16_SkColorType) {
Greg Danielc9da8e82018-03-21 10:50:24 -0400125 fboInfo.fFormat = GL_RGBA16F;
Peiyong Lin1f6aa122018-09-10 16:28:08 -0700126 } else if (colorType == kN32_SkColorType) {
127 // Note: The default preference of pixel format is RGBA_8888, when other
128 // pixel format is available, we should branch out and do more check.
Greg Danielc9da8e82018-03-21 10:50:24 -0400129 fboInfo.fFormat = GL_RGBA8;
John Reckb36bfdd2020-07-23 13:47:49 -0700130 } else if (colorType == kRGBA_1010102_SkColorType) {
131 fboInfo.fFormat = GL_RGB10_A2;
Leon Scroggins IIIe157ee82021-11-30 14:12:42 -0500132 } else if (colorType == kAlpha_8_SkColorType) {
133 fboInfo.fFormat = GL_R8;
Peiyong Lin1f6aa122018-09-10 16:28:08 -0700134 } else {
135 LOG_ALWAYS_FATAL("Unsupported color type.");
Greg Danielc9da8e82018-03-21 10:50:24 -0400136 }
Greg Danielac2d2322017-07-12 11:30:15 -0400137
Greg Danielc9da8e82018-03-21 10:50:24 -0400138 GrBackendRenderTarget backendRT(frame.width(), frame.height(), 0, STENCIL_BUFFER_SIZE, fboInfo);
Stan Iliev500a0c32016-10-26 10:30:09 -0400139
John Reckb026f352023-04-05 13:19:15 -0400140 SkSurfaceProps props(mColorMode == ColorMode::Default ? 0 : SkSurfaceProps::kAlwaysDither_Flag,
141 kUnknown_SkPixelGeometry);
Stan Iliev500a0c32016-10-26 10:30:09 -0400142
143 SkASSERT(mRenderThread.getGrContext() != nullptr);
Nader Jawada3521852023-01-30 20:23:46 -0800144 sk_sp<SkSurface> surface;
145 SkMatrix preTransform;
146 if (mHardwareBuffer) {
147 surface = getBufferSkSurface(bufferParams);
148 preTransform = bufferParams.getTransform();
149 } else {
150 surface = SkSurface::MakeFromBackendRenderTarget(mRenderThread.getGrContext(), backendRT,
151 getSurfaceOrigin(), colorType,
152 mSurfaceColorSpace, &props);
153 preTransform = SkMatrix::I();
154 }
Stan Iliev500a0c32016-10-26 10:30:09 -0400155
Nader Jawada3521852023-01-30 20:23:46 -0800156 SkPoint lightCenter = preTransform.mapXY(lightGeometry.center.x, lightGeometry.center.y);
157 LightGeometry localGeometry = lightGeometry;
158 localGeometry.center.x = lightCenter.fX;
159 localGeometry.center.y = lightCenter.fY;
160 LightingInfo::updateLighting(localGeometry, lightInfo);
Greg Danielc4076782019-01-08 16:01:18 -0500161 renderFrame(*layerUpdateQueue, dirty, renderNodes, opaque, contentDrawBounds, surface,
Nader Jawada3521852023-01-30 20:23:46 -0800162 preTransform);
Matt Sarettcf2c05c2016-10-26 11:03:23 -0400163
164 // Draw visual debugging features
John Reck1bcacfd2017-11-03 10:12:19 -0700165 if (CC_UNLIKELY(Properties::showDirtyRegions ||
166 ProfileType::None != Properties::getProfileType())) {
Matt Sarettcf2c05c2016-10-26 11:03:23 -0400167 SkCanvas* profileCanvas = surface->getCanvas();
John Reckc30836d2022-08-12 14:28:31 -0400168 SkiaProfileRenderer profileRenderer(profileCanvas, frame.width(), frame.height());
Matt Sarettcf2c05c2016-10-26 11:03:23 -0400169 profiler->draw(profileRenderer);
Matt Sarettcf2c05c2016-10-26 11:03:23 -0400170 }
171
Greg Danielbe2803a2021-02-19 18:32:16 -0500172 {
173 ATRACE_NAME("flush commands");
174 surface->flushAndSubmit();
175 }
176 layerUpdateQueue->clear();
177
Matt Sarett4bda6bf2016-11-07 15:43:41 -0500178 // Log memory statistics
179 if (CC_UNLIKELY(Properties::debugLevel != kDebugDisabled)) {
180 dumpResourceCacheUsage();
181 }
182
Alec Mouri3afb3972022-05-27 22:03:11 +0000183 return {true, IRenderPipeline::DrawResult::kUnknownTime};
Stan Iliev500a0c32016-10-26 10:30:09 -0400184}
185
John Reck1bcacfd2017-11-03 10:12:19 -0700186bool SkiaOpenGLPipeline::swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty,
187 FrameInfo* currentFrameInfo, bool* requireSwap) {
Stan Iliev500a0c32016-10-26 10:30:09 -0400188 GL_CHECKPOINT(LOW);
189
190 // Even if we decided to cancel the frame, from the perspective of jank
191 // metrics the frame was swapped at this point
192 currentFrameInfo->markSwapBuffers();
193
Nader Jawada3521852023-01-30 20:23:46 -0800194 if (mHardwareBuffer) {
195 return false;
196 }
197
Stan Iliev500a0c32016-10-26 10:30:09 -0400198 *requireSwap = drew || mEglManager.damageRequiresSwap();
199
200 if (*requireSwap && (CC_UNLIKELY(!mEglManager.swapBuffers(frame, screenDirty)))) {
201 return false;
202 }
203
204 return *requireSwap;
205}
206
Stan Iliev500a0c32016-10-26 10:30:09 -0400207DeferredLayerUpdater* SkiaOpenGLPipeline::createTextureLayer() {
John Reck1e510712018-04-23 08:15:03 -0700208 mRenderThread.requireGlContext();
Stan Iliev564ca3e2018-09-04 22:00:00 +0000209 return new DeferredLayerUpdater(mRenderThread.renderState());
Stan Iliev500a0c32016-10-26 10:30:09 -0400210}
211
Derek Sollenberger5a5a6482018-09-19 13:52:13 -0400212void SkiaOpenGLPipeline::onContextDestroyed() {
213 if (mEglSurface != EGL_NO_SURFACE) {
214 mEglManager.destroySurface(mEglSurface);
215 mEglSurface = EGL_NO_SURFACE;
216 }
217}
218
Stan Iliev500a0c32016-10-26 10:30:09 -0400219void SkiaOpenGLPipeline::onStop() {
220 if (mEglManager.isCurrent(mEglSurface)) {
221 mEglManager.makeCurrent(EGL_NO_SURFACE);
222 }
223}
224
John Reck8ddbc592020-05-07 16:11:18 -0700225bool SkiaOpenGLPipeline::setSurface(ANativeWindow* surface, SwapBehavior swapBehavior) {
Derek Sollenbergerb8307722022-08-30 14:24:22 -0400226 mNativeWindow = surface;
227 mSwapBehavior = swapBehavior;
228
Stan Iliev500a0c32016-10-26 10:30:09 -0400229 if (mEglSurface != EGL_NO_SURFACE) {
230 mEglManager.destroySurface(mEglSurface);
231 mEglSurface = EGL_NO_SURFACE;
232 }
233
234 if (surface) {
John Reck1e510712018-04-23 08:15:03 -0700235 mRenderThread.requireGlContext();
Derek Sollenberger1863d942020-02-05 15:41:51 -0500236 auto newSurface = mEglManager.createSurface(surface, mColorMode, mSurfaceColorSpace);
John Reck8e539ca2018-11-15 15:21:29 -0800237 if (!newSurface) {
238 return false;
239 }
240 mEglSurface = newSurface.unwrap();
Stan Iliev500a0c32016-10-26 10:30:09 -0400241 }
242
243 if (mEglSurface != EGL_NO_SURFACE) {
244 const bool preserveBuffer = (swapBehavior != SwapBehavior::kSwap_discardBuffer);
Derek Sollenbergerb8307722022-08-30 14:24:22 -0400245 const bool isPreserved = mEglManager.setPreserveBuffer(mEglSurface, preserveBuffer);
246 ALOGE_IF(preserveBuffer != isPreserved, "Unable to match the desired swap behavior.");
Stan Iliev500a0c32016-10-26 10:30:09 -0400247 return true;
248 }
249
250 return false;
251}
252
Nader Jawada3521852023-01-30 20:23:46 -0800253[[nodiscard]] android::base::unique_fd SkiaOpenGLPipeline::flush() {
254 int fence = -1;
255 EGLSyncKHR sync = EGL_NO_SYNC_KHR;
256 mEglManager.createReleaseFence(true, &sync, &fence);
257 // If a sync object is returned here then the device does not support native
258 // fences, we block on the returned sync and return -1 as a file descriptor
259 if (sync != EGL_NO_SYNC_KHR) {
260 EGLDisplay display = mEglManager.eglDisplay();
261 EGLint result = eglClientWaitSyncKHR(display, sync, 0, 1000000000);
262 if (result == EGL_FALSE) {
263 ALOGE("EglManager::createReleaseFence: error waiting for previous fence: %#x",
264 eglGetError());
265 } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
266 ALOGE("EglManager::createReleaseFence: timeout waiting for previous fence");
267 }
268 eglDestroySyncKHR(display, sync);
269 }
270 return android::base::unique_fd(fence);
271}
272
Stan Iliev500a0c32016-10-26 10:30:09 -0400273bool SkiaOpenGLPipeline::isSurfaceReady() {
274 return CC_UNLIKELY(mEglSurface != EGL_NO_SURFACE);
275}
276
277bool SkiaOpenGLPipeline::isContextReady() {
278 return CC_LIKELY(mEglManager.hasEglContext());
279}
280
281void SkiaOpenGLPipeline::invokeFunctor(const RenderThread& thread, Functor* functor) {
282 DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext;
283 if (thread.eglManager().hasEglContext()) {
284 mode = DrawGlInfo::kModeProcess;
285 }
286
287 (*functor)(mode, nullptr);
288
289 // If there's no context we don't need to reset as there's no gl state to save/restore
290 if (mode != DrawGlInfo::kModeProcessNoContext) {
291 thread.getGrContext()->resetContext();
292 }
293}
294
Stan Iliev500a0c32016-10-26 10:30:09 -0400295} /* namespace skiapipeline */
296} /* namespace uirenderer */
297} /* namespace android */