blob: 75a7fcb3d65d36e499e44e46af5c21f8202fa5bd [file] [log] [blame]
John Reck67b1e2b2020-08-26 13:17:24 -07001/*
2 * Copyright 2020 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
John Reck67b1e2b2020-08-26 13:17:24 -070017#undef LOG_TAG
18#define LOG_TAG "RenderEngine"
19#define ATRACE_TAG ATRACE_TAG_GRAPHICS
20
rnleec6a73642021-06-04 14:16:42 -070021#include "SkiaRenderEngine.h"
22
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070023#include <GrBackendSemaphore.h>
24#include <GrContextOptions.h>
Kevin Lubick4011eb92023-09-12 14:18:19 +000025#include <GrTypes.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070026#include <SkBlendMode.h>
27#include <SkCanvas.h>
28#include <SkColor.h>
29#include <SkColorFilter.h>
30#include <SkColorMatrix.h>
31#include <SkColorSpace.h>
32#include <SkData.h>
33#include <SkGraphics.h>
34#include <SkImage.h>
35#include <SkImageFilters.h>
36#include <SkImageInfo.h>
37#include <SkM44.h>
38#include <SkMatrix.h>
39#include <SkPaint.h>
40#include <SkPath.h>
41#include <SkPoint.h>
42#include <SkPoint3.h>
Alec Mouri0e7d8fd2023-05-03 23:58:43 +000043#include <SkRRect.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070044#include <SkRect.h>
45#include <SkRefCnt.h>
46#include <SkRegion.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070047#include <SkRuntimeEffect.h>
48#include <SkSamplingOptions.h>
49#include <SkScalar.h>
50#include <SkShader.h>
51#include <SkShadowUtils.h>
52#include <SkString.h>
53#include <SkSurface.h>
54#include <SkTileMode.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070055#include <android-base/stringprintf.h>
Leon Scroggins IIIdf8166e2024-01-25 15:50:56 -050056#include <common/FlagManager.h>
Alec Mouri0e7d8fd2023-05-03 23:58:43 +000057#include <gui/FenceMonitor.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070058#include <gui/TraceUtils.h>
Sally Qif6918d42023-08-07 15:28:30 -070059#include <include/gpu/ganesh/SkSurfaceGanesh.h>
Alec Mouri0e7d8fd2023-05-03 23:58:43 +000060#include <pthread.h>
61#include <src/core/SkTraceEventCommon.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070062#include <sync/sync.h>
63#include <ui/BlurRegion.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070064#include <ui/DebugUtils.h>
65#include <ui/GraphicBuffer.h>
Sally Qif6918d42023-08-07 15:28:30 -070066#include <ui/HdrRenderTypeUtils.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070067#include <utils/Trace.h>
68
69#include <cmath>
70#include <cstdint>
Alec Mouri0e7d8fd2023-05-03 23:58:43 +000071#include <deque>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070072#include <memory>
73#include <numeric>
74
75#include "Cache.h"
76#include "ColorSpaces.h"
Nolan Scobiefc125ec2024-03-11 20:08:27 -040077#include "compat/SkiaGpuContext.h"
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070078#include "filters/BlurFilter.h"
79#include "filters/GaussianBlurFilter.h"
80#include "filters/KawaseBlurFilter.h"
81#include "filters/LinearEffect.h"
82#include "log/log_main.h"
Nolan Scobieca050282024-03-15 13:27:06 -040083#include "skia/compat/SkiaBackendTexture.h"
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070084#include "skia/debug/SkiaCapture.h"
85#include "skia/debug/SkiaMemoryReporter.h"
86#include "skia/filters/StretchShaderFactory.h"
87#include "system/graphics-base-v1.0.h"
88
89namespace {
90
91// Debugging settings
92static const bool kPrintLayerSettings = false;
Nolan Scobie1e06f2d2024-03-21 14:56:38 -040093static const bool kGaneshFlushAfterEveryLayer = kPrintLayerSettings;
John Reck5b02fc42023-06-14 14:41:10 -040094static constexpr bool kEnableLayerBrightening = true;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070095
96} // namespace
97
98// Utility functions related to SkRect
99
100namespace {
101
102static inline SkRect getSkRect(const android::FloatRect& rect) {
103 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
104}
105
106static inline SkRect getSkRect(const android::Rect& rect) {
107 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
108}
109
110/**
111 * Verifies that common, simple bounds + clip combinations can be converted into
112 * a single RRect draw call returning true if possible. If true the radii parameter
113 * will be filled with the correct radii values that combined with bounds param will
114 * produce the insected roundRect. If false, the returned state of the radii param is undefined.
115 */
116static bool intersectionIsRoundRect(const SkRect& bounds, const SkRect& crop,
117 const SkRect& insetCrop, const android::vec2& cornerRadius,
118 SkVector radii[4]) {
119 const bool leftEqual = bounds.fLeft == crop.fLeft;
120 const bool topEqual = bounds.fTop == crop.fTop;
121 const bool rightEqual = bounds.fRight == crop.fRight;
122 const bool bottomEqual = bounds.fBottom == crop.fBottom;
123
124 // In the event that the corners of the bounds only partially align with the crop we
125 // need to ensure that the resulting shape can still be represented as a round rect.
126 // In particular the round rect implementation will scale the value of all corner radii
127 // if the sum of the radius along any edge is greater than the length of that edge.
128 // See https://www.w3.org/TR/css-backgrounds-3/#corner-overlap
129 const bool requiredWidth = bounds.width() > (cornerRadius.x * 2);
130 const bool requiredHeight = bounds.height() > (cornerRadius.y * 2);
131 if (!requiredWidth || !requiredHeight) {
132 return false;
133 }
134
135 // Check each cropped corner to ensure that it exactly matches the crop or its corner is
136 // contained within the cropped shape and does not need rounded.
137 // compute the UpperLeft corner radius
138 if (leftEqual && topEqual) {
139 radii[0].set(cornerRadius.x, cornerRadius.y);
140 } else if ((leftEqual && bounds.fTop >= insetCrop.fTop) ||
141 (topEqual && bounds.fLeft >= insetCrop.fLeft)) {
142 radii[0].set(0, 0);
143 } else {
144 return false;
145 }
146 // compute the UpperRight corner radius
147 if (rightEqual && topEqual) {
148 radii[1].set(cornerRadius.x, cornerRadius.y);
149 } else if ((rightEqual && bounds.fTop >= insetCrop.fTop) ||
150 (topEqual && bounds.fRight <= insetCrop.fRight)) {
151 radii[1].set(0, 0);
152 } else {
153 return false;
154 }
155 // compute the BottomRight corner radius
156 if (rightEqual && bottomEqual) {
157 radii[2].set(cornerRadius.x, cornerRadius.y);
158 } else if ((rightEqual && bounds.fBottom <= insetCrop.fBottom) ||
159 (bottomEqual && bounds.fRight <= insetCrop.fRight)) {
160 radii[2].set(0, 0);
161 } else {
162 return false;
163 }
164 // compute the BottomLeft corner radius
165 if (leftEqual && bottomEqual) {
166 radii[3].set(cornerRadius.x, cornerRadius.y);
167 } else if ((leftEqual && bounds.fBottom <= insetCrop.fBottom) ||
168 (bottomEqual && bounds.fLeft >= insetCrop.fLeft)) {
169 radii[3].set(0, 0);
170 } else {
171 return false;
172 }
173
174 return true;
175}
176
177static inline std::pair<SkRRect, SkRRect> getBoundsAndClip(const android::FloatRect& boundsRect,
178 const android::FloatRect& cropRect,
179 const android::vec2& cornerRadius) {
180 const SkRect bounds = getSkRect(boundsRect);
181 const SkRect crop = getSkRect(cropRect);
182
183 SkRRect clip;
184 if (cornerRadius.x > 0 && cornerRadius.y > 0) {
185 // it the crop and the bounds are equivalent or there is no crop then we don't need a clip
186 if (bounds == crop || crop.isEmpty()) {
187 return {SkRRect::MakeRectXY(bounds, cornerRadius.x, cornerRadius.y), clip};
188 }
189
190 // This makes an effort to speed up common, simple bounds + clip combinations by
191 // converting them to a single RRect draw. It is possible there are other cases
192 // that can be converted.
193 if (crop.contains(bounds)) {
194 const auto insetCrop = crop.makeInset(cornerRadius.x, cornerRadius.y);
195 if (insetCrop.contains(bounds)) {
196 return {SkRRect::MakeRect(bounds), clip}; // clip is empty - no rounding required
197 }
198
199 SkVector radii[4];
200 if (intersectionIsRoundRect(bounds, crop, insetCrop, cornerRadius, radii)) {
201 SkRRect intersectionBounds;
202 intersectionBounds.setRectRadii(bounds, radii);
203 return {intersectionBounds, clip};
204 }
205 }
206
207 // we didn't hit any of our fast paths so set the clip to the cropRect
208 clip.setRectXY(crop, cornerRadius.x, cornerRadius.y);
209 }
210
211 // if we hit this point then we either don't have rounded corners or we are going to rely
212 // on the clip to round the corners for us
213 return {SkRRect::MakeRect(bounds), clip};
214}
215
216static inline bool layerHasBlur(const android::renderengine::LayerSettings& layer,
217 bool colorTransformModifiesAlpha) {
218 if (layer.backgroundBlurRadius > 0 || layer.blurRegions.size()) {
219 // return false if the content is opaque and would therefore occlude the blur
220 const bool opaqueContent = !layer.source.buffer.buffer || layer.source.buffer.isOpaque;
221 const bool opaqueAlpha = layer.alpha == 1.0f && !colorTransformModifiesAlpha;
222 return layer.skipContentDraw || !(opaqueContent && opaqueAlpha);
223 }
224 return false;
225}
226
227static inline SkColor getSkColor(const android::vec4& color) {
228 return SkColorSetARGB(color.a * 255, color.r * 255, color.g * 255, color.b * 255);
229}
230
231static inline SkM44 getSkM44(const android::mat4& matrix) {
232 return SkM44(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],
233 matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],
234 matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],
235 matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]);
236}
237
238static inline SkPoint3 getSkPoint3(const android::vec3& vector) {
239 return SkPoint3::Make(vector.x, vector.y, vector.z);
240}
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700241} // namespace
rnleec6a73642021-06-04 14:16:42 -0700242
John Reck67b1e2b2020-08-26 13:17:24 -0700243namespace android {
244namespace renderengine {
rnleec6a73642021-06-04 14:16:42 -0700245namespace skia {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700246
247using base::StringAppendF;
248
Bruno BELANYIb9b5b702023-10-13 13:25:11 +0000249std::future<void> SkiaRenderEngine::primeCache(bool shouldPrimeUltraHDR) {
250 Cache::primeShaderCache(this, shouldPrimeUltraHDR);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700251 return {};
252}
253
254sk_sp<SkData> SkiaRenderEngine::SkSLCacheMonitor::load(const SkData& key) {
255 // This "cache" does not actually cache anything. It just allows us to
256 // monitor Skia's internal cache. So this method always returns null.
257 return nullptr;
258}
259
260void SkiaRenderEngine::SkSLCacheMonitor::store(const SkData& key, const SkData& data,
261 const SkString& description) {
262 mShadersCachedSinceLastCall++;
263 mTotalShadersCompiled++;
264 ATRACE_FORMAT("SF cache: %i shaders", mTotalShadersCompiled);
265}
266
267int SkiaRenderEngine::reportShadersCompiled() {
268 return mSkSLCacheMonitor.totalShadersCompiled();
269}
Leon Scroggins IIIa37ca992022-02-02 18:08:20 -0500270
271void SkiaRenderEngine::setEnableTracing(bool tracingEnabled) {
272 SkAndroidFrameworkTraceUtil::setEnableTracing(tracingEnabled);
rnleec6a73642021-06-04 14:16:42 -0700273}
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700274
Leon Scroggins III696bf932024-01-24 15:21:05 -0500275SkiaRenderEngine::SkiaRenderEngine(Threaded threaded, PixelFormat pixelFormat,
Alec Mouri47bcb072023-08-15 02:02:49 +0000276 bool supportsBackgroundBlur)
Leon Scroggins III696bf932024-01-24 15:21:05 -0500277 : RenderEngine(threaded), mDefaultPixelFormat(pixelFormat) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700278 if (supportsBackgroundBlur) {
279 ALOGD("Background Blurs Enabled");
280 mBlurFilter = new KawaseBlurFilter();
281 }
282 mCapture = std::make_unique<SkiaCapture>();
283}
284
285SkiaRenderEngine::~SkiaRenderEngine() { }
286
287// To be called from backend dtors.
288void SkiaRenderEngine::finishRenderingAndAbandonContext() {
289 std::lock_guard<std::mutex> lock(mRenderingMutex);
290
291 if (mBlurFilter) {
292 delete mBlurFilter;
293 }
294
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400295 if (mContext) {
296 mContext->finishRenderingAndAbandonContext();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700297 }
298
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400299 if (mProtectedContext) {
300 mProtectedContext->finishRenderingAndAbandonContext();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700301 }
302}
303
304void SkiaRenderEngine::useProtectedContext(bool useProtectedContext) {
305 if (useProtectedContext == mInProtectedContext ||
306 (useProtectedContext && !supportsProtectedContent())) {
307 return;
308 }
309
310 // release any scratch resources before switching into a new mode
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400311 if (getActiveContext()) {
312 getActiveContext()->purgeUnlockedScratchResources();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700313 }
314
315 // Backend-specific way to switch to protected context
316 if (useProtectedContextImpl(
317 useProtectedContext ? GrProtected::kYes : GrProtected::kNo)) {
318 mInProtectedContext = useProtectedContext;
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400319 // given that we are sharing the same thread between two contexts we need to
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700320 // make sure that the thread state is reset when switching between the two.
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400321 if (getActiveContext()) {
322 getActiveContext()->resetContextIfApplicable();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700323 }
324 }
325}
326
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400327SkiaGpuContext* SkiaRenderEngine::getActiveContext() {
328 return mInProtectedContext ? mProtectedContext.get() : mContext.get();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700329}
330
331static float toDegrees(uint32_t transform) {
332 switch (transform) {
333 case ui::Transform::ROT_90:
334 return 90.0;
335 case ui::Transform::ROT_180:
336 return 180.0;
337 case ui::Transform::ROT_270:
338 return 270.0;
339 default:
340 return 0.0;
341 }
342}
343
344static SkColorMatrix toSkColorMatrix(const android::mat4& matrix) {
345 return SkColorMatrix(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0], 0, matrix[0][1],
346 matrix[1][1], matrix[2][1], matrix[3][1], 0, matrix[0][2], matrix[1][2],
347 matrix[2][2], matrix[3][2], 0, matrix[0][3], matrix[1][3], matrix[2][3],
348 matrix[3][3], 0);
349}
350
351static bool needsToneMapping(ui::Dataspace sourceDataspace, ui::Dataspace destinationDataspace) {
352 int64_t sourceTransfer = sourceDataspace & HAL_DATASPACE_TRANSFER_MASK;
353 int64_t destTransfer = destinationDataspace & HAL_DATASPACE_TRANSFER_MASK;
354
355 // Treat unsupported dataspaces as srgb
356 if (destTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
357 destTransfer != HAL_DATASPACE_TRANSFER_HLG &&
358 destTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
359 destTransfer = HAL_DATASPACE_TRANSFER_SRGB;
360 }
361
362 if (sourceTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
363 sourceTransfer != HAL_DATASPACE_TRANSFER_HLG &&
364 sourceTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
365 sourceTransfer = HAL_DATASPACE_TRANSFER_SRGB;
366 }
367
368 const bool isSourceLinear = sourceTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
369 const bool isSourceSRGB = sourceTransfer == HAL_DATASPACE_TRANSFER_SRGB;
370 const bool isDestLinear = destTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
371 const bool isDestSRGB = destTransfer == HAL_DATASPACE_TRANSFER_SRGB;
372
373 return !(isSourceLinear && isDestSRGB) && !(isSourceSRGB && isDestLinear) &&
374 sourceTransfer != destTransfer;
375}
376
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400377void SkiaRenderEngine::ensureContextsCreated() {
378 if (mContext) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700379 return;
380 }
381
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400382 std::tie(mContext, mProtectedContext) = createContexts();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700383}
384
385void SkiaRenderEngine::mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer,
386 bool isRenderable) {
Ian Elliott1f0911e2022-09-09 16:31:47 -0600387 // Only run this if RE is running on its own thread. This
Leon Scroggins III696bf932024-01-24 15:21:05 -0500388 // way the access to GL/VK operations is guaranteed to be happening on the
Ian Elliott1f0911e2022-09-09 16:31:47 -0600389 // same thread.
Leon Scroggins III696bf932024-01-24 15:21:05 -0500390 if (!isThreaded()) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700391 return;
392 }
Ian Elliott8506e362023-03-08 12:12:09 -0700393 // We don't attempt to map a buffer if the buffer contains protected content. In GL this is
394 // important because GPU resources for protected buffers are much more limited. (In Vk we
Robert Phillips59f71732023-08-23 15:18:27 -0400395 // simply match the existing behavior for protected buffers.) We also never cache any
396 // buffers while in a protected context.
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700397 const bool isProtectedBuffer = buffer->getUsage() & GRALLOC_USAGE_PROTECTED;
Alec Mouri07196db2023-09-12 23:33:49 +0000398 // Don't attempt to map buffers if we're not gpu sampleable. Callers shouldn't send a buffer
399 // over to RenderEngine.
400 const bool isGpuSampleable = buffer->getUsage() & GRALLOC_USAGE_HW_TEXTURE;
401 if (isProtectedBuffer || isProtected() || !isGpuSampleable) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700402 return;
403 }
404 ATRACE_CALL();
405
406 // If we were to support caching protected buffers then we will need to switch the
407 // currently bound context if we are not already using the protected context (and subsequently
Leon Scroggins IIIea458282023-09-05 16:17:04 -0400408 // switch back after the buffer is cached).
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400409 auto context = getActiveContext();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700410 auto& cache = mTextureCache;
411
412 std::lock_guard<std::mutex> lock(mRenderingMutex);
413 mGraphicBufferExternalRefs[buffer->getId()]++;
414
415 if (const auto& iter = cache.find(buffer->getId()); iter == cache.end()) {
Leon Scroggins IIIdf8166e2024-01-25 15:50:56 -0500416 if (FlagManager::getInstance().renderable_buffer_usage()) {
417 isRenderable = buffer->getUsage() & GRALLOC_USAGE_HW_RENDER;
418 }
Nolan Scobieca050282024-03-15 13:27:06 -0400419 std::unique_ptr<SkiaBackendTexture> backendTexture =
420 context->makeBackendTexture(buffer->toAHardwareBuffer(), isRenderable);
421 auto imageTextureRef =
422 std::make_shared<AutoBackendTexture::LocalRef>(std::move(backendTexture),
423 mTextureCleanupMgr);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700424 cache.insert({buffer->getId(), imageTextureRef});
425 }
426}
427
Alec Mouri92f89fa2023-02-24 00:05:06 +0000428void SkiaRenderEngine::unmapExternalTextureBuffer(sp<GraphicBuffer>&& buffer) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700429 ATRACE_CALL();
430 std::lock_guard<std::mutex> lock(mRenderingMutex);
431 if (const auto& iter = mGraphicBufferExternalRefs.find(buffer->getId());
432 iter != mGraphicBufferExternalRefs.end()) {
433 if (iter->second == 0) {
434 ALOGW("Attempted to unmap GraphicBuffer <id: %" PRId64
435 "> from RenderEngine texture, but the "
436 "ref count was already zero!",
437 buffer->getId());
438 mGraphicBufferExternalRefs.erase(buffer->getId());
439 return;
440 }
441
442 iter->second--;
443
444 // Swap contexts if needed prior to deleting this buffer
445 // See Issue 1 of
446 // https://www.khronos.org/registry/EGL/extensions/EXT/EGL_EXT_protected_content.txt: even
447 // when a protected context and an unprotected context are part of the same share group,
448 // protected surfaces may not be accessed by an unprotected context, implying that protected
449 // surfaces may only be freed when a protected context is active.
450 const bool inProtected = mInProtectedContext;
451 useProtectedContext(buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
452
453 if (iter->second == 0) {
454 mTextureCache.erase(buffer->getId());
455 mGraphicBufferExternalRefs.erase(buffer->getId());
456 }
457
458 // Swap back to the previous context so that cached values of isProtected in SurfaceFlinger
459 // are up-to-date.
460 if (inProtected != mInProtectedContext) {
461 useProtectedContext(inProtected);
462 }
463 }
464}
465
Ian Elliott8506e362023-03-08 12:12:09 -0700466std::shared_ptr<AutoBackendTexture::LocalRef> SkiaRenderEngine::getOrCreateBackendTexture(
467 const sp<GraphicBuffer>& buffer, bool isOutputBuffer) {
Robert Phillips59f71732023-08-23 15:18:27 -0400468 // Do not lookup the buffer in the cache for protected contexts
469 if (!isProtected()) {
Ian Elliott8506e362023-03-08 12:12:09 -0700470 if (const auto& it = mTextureCache.find(buffer->getId()); it != mTextureCache.end()) {
471 return it->second;
472 }
473 }
Nolan Scobieca050282024-03-15 13:27:06 -0400474 std::unique_ptr<SkiaBackendTexture> backendTexture =
475 getActiveContext()->makeBackendTexture(buffer->toAHardwareBuffer(), isOutputBuffer);
476 return std::make_shared<AutoBackendTexture::LocalRef>(std::move(backendTexture),
477 mTextureCleanupMgr);
Ian Elliott8506e362023-03-08 12:12:09 -0700478}
479
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700480bool SkiaRenderEngine::canSkipPostRenderCleanup() const {
481 std::lock_guard<std::mutex> lock(mRenderingMutex);
482 return mTextureCleanupMgr.isEmpty();
483}
484
485void SkiaRenderEngine::cleanupPostRender() {
486 ATRACE_CALL();
487 std::lock_guard<std::mutex> lock(mRenderingMutex);
488 mTextureCleanupMgr.cleanup();
489}
490
491sk_sp<SkShader> SkiaRenderEngine::createRuntimeEffectShader(
492 const RuntimeEffectShaderParameters& parameters) {
493 // The given surface will be stretched by HWUI via matrix transformation
494 // which gets similar results for most surfaces
495 // Determine later on if we need to leverage the stertch shader within
496 // surface flinger
497 const auto& stretchEffect = parameters.layer.stretchEffect;
498 auto shader = parameters.shader;
499 if (stretchEffect.hasEffect()) {
500 const auto targetBuffer = parameters.layer.source.buffer.buffer;
501 const auto graphicBuffer = targetBuffer ? targetBuffer->getBuffer() : nullptr;
502 if (graphicBuffer && parameters.shader) {
503 shader = mStretchShaderFactory.createSkShader(shader, stretchEffect);
504 }
505 }
506
507 if (parameters.requiresLinearEffect) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700508 auto effect =
Sally Qi628ef6e2023-03-30 14:49:03 -0700509 shaders::LinearEffect{.inputDataspace = parameters.layer.sourceDataspace,
510 .outputDataspace = parameters.outputDataSpace,
Alec Mourie0bb6f42023-08-02 22:41:52 +0000511 .undoPremultipliedAlpha = parameters.undoPremultipliedAlpha,
512 .fakeOutputDataspace = parameters.fakeOutputDataspace};
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700513
514 auto effectIter = mRuntimeEffects.find(effect);
515 sk_sp<SkRuntimeEffect> runtimeEffect = nullptr;
516 if (effectIter == mRuntimeEffects.end()) {
517 runtimeEffect = buildRuntimeEffect(effect);
518 mRuntimeEffects.insert({effect, runtimeEffect});
519 } else {
520 runtimeEffect = effectIter->second;
521 }
Alec Mouri3e5965f2023-04-07 18:00:58 +0000522
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700523 mat4 colorTransform = parameters.layer.colorTransform;
524
525 colorTransform *=
526 mat4::scale(vec4(parameters.layerDimmingRatio, parameters.layerDimmingRatio,
527 parameters.layerDimmingRatio, 1.f));
Alec Mouri3e5965f2023-04-07 18:00:58 +0000528
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700529 const auto targetBuffer = parameters.layer.source.buffer.buffer;
530 const auto graphicBuffer = targetBuffer ? targetBuffer->getBuffer() : nullptr;
531 const auto hardwareBuffer = graphicBuffer ? graphicBuffer->toAHardwareBuffer() : nullptr;
Alec Mouri3e5965f2023-04-07 18:00:58 +0000532 return createLinearEffectShader(parameters.shader, effect, runtimeEffect,
533 std::move(colorTransform), parameters.display.maxLuminance,
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700534 parameters.display.currentLuminanceNits,
535 parameters.layer.source.buffer.maxLuminanceNits,
536 hardwareBuffer, parameters.display.renderIntent);
537 }
538 return parameters.shader;
539}
540
541void SkiaRenderEngine::initCanvas(SkCanvas* canvas, const DisplaySettings& display) {
542 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
543 // Record display settings when capture is running.
544 std::stringstream displaySettings;
545 PrintTo(display, &displaySettings);
546 // Store the DisplaySettings in additional information.
547 canvas->drawAnnotation(SkRect::MakeEmpty(), "DisplaySettings",
548 SkData::MakeWithCString(displaySettings.str().c_str()));
549 }
550
551 // Before doing any drawing, let's make sure that we'll start at the origin of the display.
552 // Some displays don't start at 0,0 for example when we're mirroring the screen. Also, virtual
553 // displays might have different scaling when compared to the physical screen.
554
555 canvas->clipRect(getSkRect(display.physicalDisplay));
556 canvas->translate(display.physicalDisplay.left, display.physicalDisplay.top);
557
558 const auto clipWidth = display.clip.width();
559 const auto clipHeight = display.clip.height();
560 auto rotatedClipWidth = clipWidth;
561 auto rotatedClipHeight = clipHeight;
562 // Scale is contingent on the rotation result.
563 if (display.orientation & ui::Transform::ROT_90) {
564 std::swap(rotatedClipWidth, rotatedClipHeight);
565 }
566 const auto scaleX = static_cast<SkScalar>(display.physicalDisplay.width()) /
567 static_cast<SkScalar>(rotatedClipWidth);
568 const auto scaleY = static_cast<SkScalar>(display.physicalDisplay.height()) /
569 static_cast<SkScalar>(rotatedClipHeight);
570 canvas->scale(scaleX, scaleY);
571
572 // Canvas rotation is done by centering the clip window at the origin, rotating, translating
573 // back so that the top left corner of the clip is at (0, 0).
574 canvas->translate(rotatedClipWidth / 2, rotatedClipHeight / 2);
575 canvas->rotate(toDegrees(display.orientation));
576 canvas->translate(-clipWidth / 2, -clipHeight / 2);
577 canvas->translate(-display.clip.left, -display.clip.top);
578}
579
580class AutoSaveRestore {
581public:
582 AutoSaveRestore(SkCanvas* canvas) : mCanvas(canvas) { mSaveCount = canvas->save(); }
583 ~AutoSaveRestore() { restore(); }
584 void replace(SkCanvas* canvas) {
585 mCanvas = canvas;
586 mSaveCount = canvas->save();
587 }
588 void restore() {
589 if (mCanvas) {
590 mCanvas->restoreToCount(mSaveCount);
591 mCanvas = nullptr;
592 }
593 }
594
595private:
596 SkCanvas* mCanvas;
597 int mSaveCount;
598};
599
600static SkRRect getBlurRRect(const BlurRegion& region) {
601 const auto rect = SkRect::MakeLTRB(region.left, region.top, region.right, region.bottom);
602 const SkVector radii[4] = {SkVector::Make(region.cornerRadiusTL, region.cornerRadiusTL),
603 SkVector::Make(region.cornerRadiusTR, region.cornerRadiusTR),
604 SkVector::Make(region.cornerRadiusBR, region.cornerRadiusBR),
605 SkVector::Make(region.cornerRadiusBL, region.cornerRadiusBL)};
606 SkRRect roundedRect;
607 roundedRect.setRectRadii(rect, radii);
608 return roundedRect;
609}
610
611// Arbitrary default margin which should be close enough to zero.
612constexpr float kDefaultMargin = 0.0001f;
613static bool equalsWithinMargin(float expected, float value, float margin = kDefaultMargin) {
614 LOG_ALWAYS_FATAL_IF(margin < 0.f, "Margin is negative!");
615 return std::abs(expected - value) < margin;
616}
617
618namespace {
619template <typename T>
620void logSettings(const T& t) {
621 std::stringstream stream;
622 PrintTo(t, &stream);
623 auto string = stream.str();
624 size_t pos = 0;
625 // Perfetto ignores \n, so split up manually into separate ALOGD statements.
626 const size_t size = string.size();
627 while (pos < size) {
628 const size_t end = std::min(string.find("\n", pos), size);
629 ALOGD("%s", string.substr(pos, end - pos).c_str());
630 pos = end + 1;
631 }
632}
633} // namespace
634
635// Helper class intended to be used on the stack to ensure that texture cleanup
636// is deferred until after this class goes out of scope.
637class DeferTextureCleanup final {
638public:
639 DeferTextureCleanup(AutoBackendTexture::CleanupManager& mgr) : mMgr(mgr) {
640 mMgr.setDeferredStatus(true);
641 }
642 ~DeferTextureCleanup() { mMgr.setDeferredStatus(false); }
643
644private:
645 DISALLOW_COPY_AND_ASSIGN(DeferTextureCleanup);
646 AutoBackendTexture::CleanupManager& mMgr;
647};
648
649void SkiaRenderEngine::drawLayersInternal(
Patrick Williams2e9748f2022-08-09 22:48:18 +0000650 const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700651 const DisplaySettings& display, const std::vector<LayerSettings>& layers,
Alec Mourif29700f2023-08-17 21:53:31 +0000652 const std::shared_ptr<ExternalTexture>& buffer, base::unique_fd&& bufferFence) {
Leon Scroggins III5a655b82022-09-07 13:17:09 -0400653 ATRACE_FORMAT("%s for %s", __func__, display.namePlusId.c_str());
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700654
655 std::lock_guard<std::mutex> lock(mRenderingMutex);
656
657 if (buffer == nullptr) {
658 ALOGE("No output buffer provided. Aborting GPU composition.");
Patrick Williams2e9748f2022-08-09 22:48:18 +0000659 resultPromise->set_value(base::unexpected(BAD_VALUE));
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700660 return;
661 }
662
663 validateOutputBufferUsage(buffer->getBuffer());
664
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400665 auto context = getActiveContext();
Nolan Scobie17ffe902024-03-25 11:07:30 -0400666 LOG_ALWAYS_FATAL_IF(context->isAbandonedOrDeviceLost(),
667 "Context is abandoned/device lost at start of %s", __func__);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700668
669 // any AutoBackendTexture deletions will now be deferred until cleanupPostRender is called
670 DeferTextureCleanup dtc(mTextureCleanupMgr);
671
Ian Elliott8506e362023-03-08 12:12:09 -0700672 auto surfaceTextureRef = getOrCreateBackendTexture(buffer->getBuffer(), true);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700673
674 // wait on the buffer to be ready to use prior to using it
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400675 waitFence(context, bufferFence);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700676
Nolan Scobie17e25512024-03-13 18:02:48 -0400677 sk_sp<SkSurface> dstSurface = surfaceTextureRef->getOrCreateSurface(display.outputDataspace);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700678
679 SkCanvas* dstCanvas = mCapture->tryCapture(dstSurface.get());
680 if (dstCanvas == nullptr) {
681 ALOGE("Cannot acquire canvas from Skia.");
Patrick Williams2e9748f2022-08-09 22:48:18 +0000682 resultPromise->set_value(base::unexpected(BAD_VALUE));
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700683 return;
684 }
685
686 // setup color filter if necessary
687 sk_sp<SkColorFilter> displayColorTransform;
688 if (display.colorTransform != mat4() && !display.deviceHandlesColorTransform) {
689 displayColorTransform = SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform));
690 }
691 const bool ctModifiesAlpha =
692 displayColorTransform && !displayColorTransform->isAlphaUnchanged();
693
694 // Find the max layer white point to determine the max luminance of the scene...
695 const float maxLayerWhitePoint = std::transform_reduce(
696 layers.cbegin(), layers.cend(), 0.f,
697 [](float left, float right) { return std::max(left, right); },
698 [&](const auto& l) { return l.whitePointNits; });
699
700 // ...and compute the dimming ratio if dimming is requested
701 const float displayDimmingRatio = display.targetLuminanceNits > 0.f &&
John Reck5b02fc42023-06-14 14:41:10 -0400702 maxLayerWhitePoint > 0.f &&
703 (kEnableLayerBrightening || display.targetLuminanceNits > maxLayerWhitePoint)
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700704 ? maxLayerWhitePoint / display.targetLuminanceNits
705 : 1.f;
706
707 // Find if any layers have requested blur, we'll use that info to decide when to render to an
708 // offscreen buffer and when to render to the native buffer.
709 sk_sp<SkSurface> activeSurface(dstSurface);
710 SkCanvas* canvas = dstCanvas;
711 SkiaCapture::OffscreenState offscreenCaptureState;
712 const LayerSettings* blurCompositionLayer = nullptr;
Leon Scroggins IIIf31b4bc2023-08-25 10:40:27 -0400713 if (mBlurFilter) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700714 bool requiresCompositionLayer = false;
715 for (const auto& layer : layers) {
716 // if the layer doesn't have blur or it is not visible then continue
717 if (!layerHasBlur(layer, ctModifiesAlpha)) {
718 continue;
719 }
720 if (layer.backgroundBlurRadius > 0 &&
721 layer.backgroundBlurRadius < mBlurFilter->getMaxCrossFadeRadius()) {
722 requiresCompositionLayer = true;
723 }
724 for (auto region : layer.blurRegions) {
725 if (region.blurRadius < mBlurFilter->getMaxCrossFadeRadius()) {
726 requiresCompositionLayer = true;
727 }
728 }
729 if (requiresCompositionLayer) {
730 activeSurface = dstSurface->makeSurface(dstSurface->imageInfo());
731 canvas = mCapture->tryOffscreenCapture(activeSurface.get(), &offscreenCaptureState);
732 blurCompositionLayer = &layer;
733 break;
734 }
735 }
736 }
737
738 AutoSaveRestore surfaceAutoSaveRestore(canvas);
739 // Clear the entire canvas with a transparent black to prevent ghost images.
740 canvas->clear(SK_ColorTRANSPARENT);
741 initCanvas(canvas, display);
742
743 if (kPrintLayerSettings) {
744 logSettings(display);
745 }
746 for (const auto& layer : layers) {
747 ATRACE_FORMAT("DrawLayer: %s", layer.name.c_str());
748
749 if (kPrintLayerSettings) {
750 logSettings(layer);
751 }
752
753 sk_sp<SkImage> blurInput;
754 if (blurCompositionLayer == &layer) {
755 LOG_ALWAYS_FATAL_IF(activeSurface == dstSurface);
756 LOG_ALWAYS_FATAL_IF(canvas == dstCanvas);
757
758 // save a snapshot of the activeSurface to use as input to the blur shaders
759 blurInput = activeSurface->makeImageSnapshot();
760
Leon Scroggins III48a60cc2024-01-31 12:41:33 -0500761 // blit the offscreen framebuffer into the destination AHB. This ensures that
762 // even if the blurred image does not cover the screen (for example, during
763 // a rotation animation, or if blur regions are used), the entire screen is
764 // initialized.
765 if (layer.blurRegions.size() || FlagManager::getInstance().restore_blur_step()) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700766 SkPaint paint;
767 paint.setBlendMode(SkBlendMode::kSrc);
768 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
769 uint64_t id = mCapture->endOffscreenCapture(&offscreenCaptureState);
770 dstCanvas->drawAnnotation(SkRect::Make(dstCanvas->imageInfo().dimensions()),
771 String8::format("SurfaceID|%" PRId64, id).c_str(),
772 nullptr);
773 dstCanvas->drawImage(blurInput, 0, 0, SkSamplingOptions(), &paint);
774 } else {
775 activeSurface->draw(dstCanvas, 0, 0, SkSamplingOptions(), &paint);
776 }
777 }
778
779 // assign dstCanvas to canvas and ensure that the canvas state is up to date
780 canvas = dstCanvas;
781 surfaceAutoSaveRestore.replace(canvas);
782 initCanvas(canvas, display);
783
784 LOG_ALWAYS_FATAL_IF(activeSurface->getCanvas()->getSaveCount() !=
785 dstSurface->getCanvas()->getSaveCount());
786 LOG_ALWAYS_FATAL_IF(activeSurface->getCanvas()->getTotalMatrix() !=
787 dstSurface->getCanvas()->getTotalMatrix());
788
789 // assign dstSurface to activeSurface
790 activeSurface = dstSurface;
791 }
792
793 SkAutoCanvasRestore layerAutoSaveRestore(canvas, true);
794 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
795 // Record the name of the layer if the capture is running.
796 std::stringstream layerSettings;
797 PrintTo(layer, &layerSettings);
798 // Store the LayerSettings in additional information.
799 canvas->drawAnnotation(SkRect::MakeEmpty(), layer.name.c_str(),
800 SkData::MakeWithCString(layerSettings.str().c_str()));
801 }
802 // Layers have a local transform that should be applied to them
803 canvas->concat(getSkM44(layer.geometry.positionTransform).asM33());
804
805 const auto [bounds, roundRectClip] =
806 getBoundsAndClip(layer.geometry.boundaries, layer.geometry.roundedCornersCrop,
807 layer.geometry.roundedCornersRadius);
Leon Scroggins IIIf31b4bc2023-08-25 10:40:27 -0400808 if (mBlurFilter && layerHasBlur(layer, ctModifiesAlpha)) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700809 std::unordered_map<uint32_t, sk_sp<SkImage>> cachedBlurs;
810
811 // if multiple layers have blur, then we need to take a snapshot now because
812 // only the lowest layer will have blurImage populated earlier
813 if (!blurInput) {
814 blurInput = activeSurface->makeImageSnapshot();
815 }
Leon Scroggins IIIa09cddc2023-07-25 09:34:11 -0400816
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700817 // rect to be blurred in the coordinate space of blurInput
Leon Scroggins IIIa09cddc2023-07-25 09:34:11 -0400818 SkRect blurRect = canvas->getTotalMatrix().mapRect(bounds.rect());
819
820 // Some layers may be much bigger than the screen. If we used
821 // `blurRect` directly, this would allocate a large buffer with no
822 // benefit. Apply the clip, which already takes the display size
823 // into account. The clipped size will then be used to calculate the
824 // size of the buffer we will create for blurring.
825 if (!blurRect.intersect(SkRect::Make(canvas->getDeviceClipBounds()))) {
826 // This should not happen, but if it did, we would use the full
827 // sized layer, which should still be fine.
828 ALOGW("blur bounds does not intersect display clip!");
829 }
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700830
831 // if the clip needs to be applied then apply it now and make sure
832 // it is restored before we attempt to draw any shadows.
833 SkAutoCanvasRestore acr(canvas, true);
834 if (!roundRectClip.isEmpty()) {
835 canvas->clipRRect(roundRectClip, true);
836 }
837
838 // TODO(b/182216890): Filter out empty layers earlier
839 if (blurRect.width() > 0 && blurRect.height() > 0) {
840 if (layer.backgroundBlurRadius > 0) {
841 ATRACE_NAME("BackgroundBlur");
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400842 auto blurredImage = mBlurFilter->generate(context, layer.backgroundBlurRadius,
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700843 blurInput, blurRect);
844
845 cachedBlurs[layer.backgroundBlurRadius] = blurredImage;
846
847 mBlurFilter->drawBlurRegion(canvas, bounds, layer.backgroundBlurRadius, 1.0f,
848 blurRect, blurredImage, blurInput);
849 }
850
851 canvas->concat(getSkM44(layer.blurRegionTransform).asM33());
852 for (auto region : layer.blurRegions) {
853 if (cachedBlurs[region.blurRadius] == nullptr) {
854 ATRACE_NAME("BlurRegion");
855 cachedBlurs[region.blurRadius] =
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400856 mBlurFilter->generate(context, region.blurRadius, blurInput,
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700857 blurRect);
858 }
859
860 mBlurFilter->drawBlurRegion(canvas, getBlurRRect(region), region.blurRadius,
861 region.alpha, blurRect,
862 cachedBlurs[region.blurRadius], blurInput);
863 }
864 }
865 }
866
867 if (layer.shadow.length > 0) {
868 // This would require a new parameter/flag to SkShadowUtils::DrawShadow
869 LOG_ALWAYS_FATAL_IF(layer.disableBlending, "Cannot disableBlending with a shadow");
870
871 SkRRect shadowBounds, shadowClip;
872 if (layer.geometry.boundaries == layer.shadow.boundaries) {
873 shadowBounds = bounds;
874 shadowClip = roundRectClip;
875 } else {
876 std::tie(shadowBounds, shadowClip) =
877 getBoundsAndClip(layer.shadow.boundaries, layer.geometry.roundedCornersCrop,
878 layer.geometry.roundedCornersRadius);
879 }
880
881 // Technically, if bounds is a rect and roundRectClip is not empty,
882 // it means that the bounds and roundedCornersCrop were different
883 // enough that we should intersect them to find the proper shadow.
884 // In practice, this often happens when the two rectangles appear to
885 // not match due to rounding errors. Draw the rounded version, which
886 // looks more like the intent.
887 const auto& rrect =
888 shadowBounds.isRect() && !shadowClip.isEmpty() ? shadowClip : shadowBounds;
889 drawShadow(canvas, rrect, layer.shadow);
890 }
891
892 const float layerDimmingRatio = layer.whitePointNits <= 0.f
893 ? displayDimmingRatio
894 : (layer.whitePointNits / maxLayerWhitePoint) * displayDimmingRatio;
895
896 const bool dimInLinearSpace = display.dimmingStage !=
897 aidl::android::hardware::graphics::composer3::DimmingStage::GAMMA_OETF;
898
Sally Qi628ef6e2023-03-30 14:49:03 -0700899 const bool isExtendedHdr = (layer.sourceDataspace & ui::Dataspace::RANGE_MASK) ==
900 static_cast<int32_t>(ui::Dataspace::RANGE_EXTENDED) &&
901 (display.outputDataspace & ui::Dataspace::TRANSFER_MASK) ==
902 static_cast<int32_t>(ui::Dataspace::TRANSFER_SRGB);
903
Alec Mourie0bb6f42023-08-02 22:41:52 +0000904 const bool useFakeOutputDataspaceForRuntimeEffect = !dimInLinearSpace && isExtendedHdr;
905
906 const ui::Dataspace fakeDataspace = useFakeOutputDataspaceForRuntimeEffect
Sally Qi628ef6e2023-03-30 14:49:03 -0700907 ? static_cast<ui::Dataspace>(
908 (display.outputDataspace & ui::Dataspace::STANDARD_MASK) |
909 ui::Dataspace::TRANSFER_GAMMA2_2 |
910 (display.outputDataspace & ui::Dataspace::RANGE_MASK))
Alec Mourie0bb6f42023-08-02 22:41:52 +0000911 : ui::Dataspace::UNKNOWN;
Sally Qi628ef6e2023-03-30 14:49:03 -0700912
913 // If the input dataspace is range extended, the output dataspace transfer is sRGB
914 // and dimmingStage is GAMMA_OETF, dim in linear space instead, and
915 // set the output dataspace's transfer to be GAMMA2_2.
916 // This allows DPU side to use oetf_gamma_2p2 for extended HDR layer
917 // to avoid tone shift.
918 // The reason of tone shift here is because HDR layers manage white point
919 // luminance in linear space, which color pipelines request GAMMA_OETF break
920 // without a gamma 2.2 fixup.
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700921 const bool requiresLinearEffect = layer.colorTransform != mat4() ||
Alec Mouri47bcb072023-08-15 02:02:49 +0000922 (needsToneMapping(layer.sourceDataspace, display.outputDataspace)) ||
Sally Qi628ef6e2023-03-30 14:49:03 -0700923 (dimInLinearSpace && !equalsWithinMargin(1.f, layerDimmingRatio)) ||
924 (!dimInLinearSpace && isExtendedHdr);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700925
926 // quick abort from drawing the remaining portion of the layer
927 if (layer.skipContentDraw ||
928 (layer.alpha == 0 && !requiresLinearEffect && !layer.disableBlending &&
929 (!displayColorTransform || displayColorTransform->isAlphaUnchanged()))) {
930 continue;
931 }
932
Alec Mouri47bcb072023-08-15 02:02:49 +0000933 const ui::Dataspace layerDataspace = layer.sourceDataspace;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700934
935 SkPaint paint;
936 if (layer.source.buffer.buffer) {
937 ATRACE_NAME("DrawImage");
938 validateInputBufferUsage(layer.source.buffer.buffer->getBuffer());
939 const auto& item = layer.source.buffer;
Ian Elliott8506e362023-03-08 12:12:09 -0700940 auto imageTextureRef = getOrCreateBackendTexture(item.buffer->getBuffer(), false);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700941
942 // if the layer's buffer has a fence, then we must must respect the fence prior to using
943 // the buffer.
944 if (layer.source.buffer.fence != nullptr) {
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400945 waitFence(context, layer.source.buffer.fence->get());
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700946 }
947
948 // isOpaque means we need to ignore the alpha in the image,
949 // replacing it with the alpha specified by the LayerSettings. See
950 // https://developer.android.com/reference/android/view/SurfaceControl.Builder#setOpaque(boolean)
951 // The proper way to do this is to use an SkColorType that ignores
952 // alpha, like kRGB_888x_SkColorType, and that is used if the
953 // incoming image is kRGBA_8888_SkColorType. However, the incoming
954 // image may be kRGBA_F16_SkColorType, for which there is no RGBX
955 // SkColorType, or kRGBA_1010102_SkColorType, for which we have
956 // kRGB_101010x_SkColorType, but it is not yet supported as a source
957 // on the GPU. (Adding both is tracked in skbug.com/12048.) In the
958 // meantime, we'll use a workaround that works unless we need to do
959 // any color conversion. The workaround requires that we pretend the
960 // image is already premultiplied, so that we do not premultiply it
961 // before applying SkBlendMode::kPlus.
962 const bool useIsOpaqueWorkaround = item.isOpaque &&
963 (imageTextureRef->colorType() == kRGBA_1010102_SkColorType ||
964 imageTextureRef->colorType() == kRGBA_F16_SkColorType);
965 const auto alphaType = useIsOpaqueWorkaround ? kPremul_SkAlphaType
966 : item.isOpaque ? kOpaque_SkAlphaType
967 : item.usePremultipliedAlpha ? kPremul_SkAlphaType
968 : kUnpremul_SkAlphaType;
Nolan Scobie17e25512024-03-13 18:02:48 -0400969 sk_sp<SkImage> image = imageTextureRef->makeImage(layerDataspace, alphaType);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700970
971 auto texMatrix = getSkM44(item.textureTransform).asM33();
972 // textureTansform was intended to be passed directly into a shader, so when
973 // building the total matrix with the textureTransform we need to first
974 // normalize it, then apply the textureTransform, then scale back up.
975 texMatrix.preScale(1.0f / bounds.width(), 1.0f / bounds.height());
976 texMatrix.postScale(image->width(), image->height());
977
978 SkMatrix matrix;
979 if (!texMatrix.invert(&matrix)) {
980 matrix = texMatrix;
981 }
982 // The shader does not respect the translation, so we add it to the texture
983 // transform for the SkImage. This will make sure that the correct layer contents
984 // are drawn in the correct part of the screen.
985 matrix.postTranslate(bounds.rect().fLeft, bounds.rect().fTop);
986
987 sk_sp<SkShader> shader;
988
989 if (layer.source.buffer.useTextureFiltering) {
990 shader = image->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
991 SkSamplingOptions(
992 {SkFilterMode::kLinear, SkMipmapMode::kNone}),
993 &matrix);
994 } else {
995 shader = image->makeShader(SkSamplingOptions(), matrix);
996 }
997
998 if (useIsOpaqueWorkaround) {
999 shader = SkShaders::Blend(SkBlendMode::kPlus, shader,
1000 SkShaders::Color(SkColors::kBlack,
1001 toSkColorSpace(layerDataspace)));
1002 }
1003
1004 paint.setShader(createRuntimeEffectShader(
1005 RuntimeEffectShaderParameters{.shader = shader,
1006 .layer = layer,
1007 .display = display,
1008 .undoPremultipliedAlpha = !item.isOpaque &&
1009 item.usePremultipliedAlpha,
1010 .requiresLinearEffect = requiresLinearEffect,
1011 .layerDimmingRatio = dimInLinearSpace
1012 ? layerDimmingRatio
Sally Qi628ef6e2023-03-30 14:49:03 -07001013 : 1.f,
Alec Mourie0bb6f42023-08-02 22:41:52 +00001014 .outputDataSpace = display.outputDataspace,
1015 .fakeOutputDataspace = fakeDataspace}));
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001016
1017 // Turn on dithering when dimming beyond this (arbitrary) threshold...
linkai296566e2024-01-22 20:58:15 +08001018 static constexpr float kDimmingThreshold = 0.9f;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001019 // ...or we're rendering an HDR layer down to an 8-bit target
1020 // Most HDR standards require at least 10-bits of color depth for source content, so we
1021 // can just extract the transfer function rather than dig into precise gralloc layout.
1022 // Furthermore, we can assume that the only 8-bit target we support is RGBA8888.
Sally Qif6918d42023-08-07 15:28:30 -07001023 const bool requiresDownsample =
1024 getHdrRenderType(layer.sourceDataspace,
1025 std::optional<ui::PixelFormat>(static_cast<ui::PixelFormat>(
1026 buffer->getPixelFormat()))) != HdrRenderType::SDR &&
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001027 buffer->getPixelFormat() == PIXEL_FORMAT_RGBA_8888;
1028 if (layerDimmingRatio <= kDimmingThreshold || requiresDownsample) {
1029 paint.setDither(true);
1030 }
1031 paint.setAlphaf(layer.alpha);
1032
1033 if (imageTextureRef->colorType() == kAlpha_8_SkColorType) {
1034 LOG_ALWAYS_FATAL_IF(layer.disableBlending, "Cannot disableBlending with A8");
1035
1036 // SysUI creates the alpha layer as a coverage layer, which is
1037 // appropriate for the DPU. Use a color matrix to convert it to
1038 // a mask.
1039 // TODO (b/219525258): Handle input as a mask.
1040 //
1041 // The color matrix will convert A8 pixels with no alpha to
1042 // black, as described by this vector. If the display handles
1043 // the color transform, we need to invert it to find the color
1044 // that will result in black after the DPU applies the transform.
1045 SkV4 black{0.0f, 0.0f, 0.0f, 1.0f}; // r, g, b, a
1046 if (display.colorTransform != mat4() && display.deviceHandlesColorTransform) {
1047 SkM44 colorSpaceMatrix = getSkM44(display.colorTransform);
1048 if (colorSpaceMatrix.invert(&colorSpaceMatrix)) {
1049 black = colorSpaceMatrix * black;
1050 } else {
1051 // We'll just have to use 0,0,0 as black, which should
1052 // be close to correct.
1053 ALOGI("Could not invert colorTransform!");
1054 }
1055 }
1056 SkColorMatrix colorMatrix(0, 0, 0, 0, black[0],
1057 0, 0, 0, 0, black[1],
1058 0, 0, 0, 0, black[2],
1059 0, 0, 0, -1, 1);
1060 if (display.colorTransform != mat4() && !display.deviceHandlesColorTransform) {
1061 // On the other hand, if the device doesn't handle it, we
1062 // have to apply it ourselves.
1063 colorMatrix.postConcat(toSkColorMatrix(display.colorTransform));
1064 }
1065 paint.setColorFilter(SkColorFilters::Matrix(colorMatrix));
1066 }
1067 } else {
1068 ATRACE_NAME("DrawColor");
1069 const auto color = layer.source.solidColor;
1070 sk_sp<SkShader> shader = SkShaders::Color(SkColor4f{.fR = color.r,
1071 .fG = color.g,
1072 .fB = color.b,
1073 .fA = layer.alpha},
1074 toSkColorSpace(layerDataspace));
1075 paint.setShader(createRuntimeEffectShader(
1076 RuntimeEffectShaderParameters{.shader = shader,
1077 .layer = layer,
1078 .display = display,
1079 .undoPremultipliedAlpha = false,
1080 .requiresLinearEffect = requiresLinearEffect,
Sally Qi628ef6e2023-03-30 14:49:03 -07001081 .layerDimmingRatio = layerDimmingRatio,
Alec Mourie0bb6f42023-08-02 22:41:52 +00001082 .outputDataSpace = display.outputDataspace,
1083 .fakeOutputDataspace = fakeDataspace}));
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001084 }
1085
1086 if (layer.disableBlending) {
1087 paint.setBlendMode(SkBlendMode::kSrc);
1088 }
1089
1090 // An A8 buffer will already have the proper color filter attached to
1091 // its paint, including the displayColorTransform as needed.
1092 if (!paint.getColorFilter()) {
1093 if (!dimInLinearSpace && !equalsWithinMargin(1.0, layerDimmingRatio)) {
1094 // If we don't dim in linear space, then when we gamma correct the dimming ratio we
1095 // can assume a gamma 2.2 transfer function.
1096 static constexpr float kInverseGamma22 = 1.f / 2.2f;
1097 const auto gammaCorrectedDimmingRatio =
1098 std::pow(layerDimmingRatio, kInverseGamma22);
1099 auto dimmingMatrix =
1100 mat4::scale(vec4(gammaCorrectedDimmingRatio, gammaCorrectedDimmingRatio,
1101 gammaCorrectedDimmingRatio, 1.f));
1102
1103 const auto colorFilter =
1104 SkColorFilters::Matrix(toSkColorMatrix(std::move(dimmingMatrix)));
1105 paint.setColorFilter(displayColorTransform
1106 ? displayColorTransform->makeComposed(colorFilter)
1107 : colorFilter);
1108 } else {
1109 paint.setColorFilter(displayColorTransform);
1110 }
1111 }
1112
1113 if (!roundRectClip.isEmpty()) {
1114 canvas->clipRRect(roundRectClip, true);
1115 }
1116
1117 if (!bounds.isRect()) {
1118 paint.setAntiAlias(true);
1119 canvas->drawRRect(bounds, paint);
1120 } else {
1121 canvas->drawRect(bounds.rect(), paint);
1122 }
Nolan Scobie1e06f2d2024-03-21 14:56:38 -04001123 if (kGaneshFlushAfterEveryLayer) {
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001124 ATRACE_NAME("flush surface");
Nolan Scobie1e06f2d2024-03-21 14:56:38 -04001125 // No-op in Graphite. If "flushing" Skia's drawing commands after each layer is desired
1126 // in Graphite, then a graphite::Recording would need to be snapped and tracked for each
1127 // layer, which is likely possible but adds non-trivial complexity (in both bookkeeping
1128 // and refactoring).
Kevin Lubick208e11a2023-05-31 19:34:46 +00001129 skgpu::ganesh::Flush(activeSurface);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001130 }
1131 }
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001132
1133 surfaceAutoSaveRestore.restore();
1134 mCapture->endCapture();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001135
Nolan Scobie1e06f2d2024-03-21 14:56:38 -04001136 LOG_ALWAYS_FATAL_IF(activeSurface != dstSurface);
1137 auto drawFence = sp<Fence>::make(flushAndSubmit(context, dstSurface));
Alec Mouri0e7d8fd2023-05-03 23:58:43 +00001138
1139 if (ATRACE_ENABLED()) {
1140 static gui::FenceMonitor sMonitor("RE Completion");
1141 sMonitor.queueFence(drawFence);
1142 }
1143 resultPromise->set_value(std::move(drawFence));
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001144}
1145
1146size_t SkiaRenderEngine::getMaxTextureSize() const {
Nolan Scobiefc125ec2024-03-11 20:08:27 -04001147 return mContext->getMaxTextureSize();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001148}
1149
1150size_t SkiaRenderEngine::getMaxViewportDims() const {
Nolan Scobiefc125ec2024-03-11 20:08:27 -04001151 return mContext->getMaxRenderTargetSize();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001152}
1153
1154void SkiaRenderEngine::drawShadow(SkCanvas* canvas,
1155 const SkRRect& casterRRect,
1156 const ShadowSettings& settings) {
1157 ATRACE_CALL();
1158 const float casterZ = settings.length / 2.0f;
1159 const auto flags =
1160 settings.casterIsTranslucent ? kTransparentOccluder_ShadowFlag : kNone_ShadowFlag;
1161
1162 SkShadowUtils::DrawShadow(canvas, SkPath::RRect(casterRRect), SkPoint3::Make(0, 0, casterZ),
1163 getSkPoint3(settings.lightPos), settings.lightRadius,
1164 getSkColor(settings.ambientColor), getSkColor(settings.spotColor),
1165 flags);
1166}
1167
1168void SkiaRenderEngine::onActiveDisplaySizeChanged(ui::Size size) {
1169 // This cache multiplier was selected based on review of cache sizes relative
1170 // to the screen resolution. Looking at the worst case memory needed by blur (~1.5x),
1171 // shadows (~1x), and general data structures (e.g. vertex buffers) we selected this as a
1172 // conservative default based on that analysis.
1173 const float SURFACE_SIZE_MULTIPLIER = 3.5f * bytesPerPixel(mDefaultPixelFormat);
1174 const int maxResourceBytes = size.width * size.height * SURFACE_SIZE_MULTIPLIER;
1175
1176 // start by resizing the current context
Nolan Scobiefc125ec2024-03-11 20:08:27 -04001177 getActiveContext()->setResourceCacheLimit(maxResourceBytes);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001178
1179 // if it is possible to switch contexts then we will resize the other context
1180 const bool originalProtectedState = mInProtectedContext;
1181 useProtectedContext(!mInProtectedContext);
1182 if (mInProtectedContext != originalProtectedState) {
Nolan Scobiefc125ec2024-03-11 20:08:27 -04001183 getActiveContext()->setResourceCacheLimit(maxResourceBytes);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001184 // reset back to the initial context that was active when this method was called
1185 useProtectedContext(originalProtectedState);
1186 }
1187}
1188
1189void SkiaRenderEngine::dump(std::string& result) {
1190 // Dump for the specific backend (GLES or Vk)
1191 appendBackendSpecificInfoToDump(result);
1192
1193 // Info about protected content
1194 StringAppendF(&result, "RenderEngine supports protected context: %d\n",
1195 supportsProtectedContent());
1196 StringAppendF(&result, "RenderEngine is in protected context: %d\n", mInProtectedContext);
1197 StringAppendF(&result, "RenderEngine shaders cached since last dump/primeCache: %d\n",
1198 mSkSLCacheMonitor.shadersCachedSinceLastCall());
1199
1200 std::vector<ResourcePair> cpuResourceMap = {
1201 {"skia/sk_resource_cache/bitmap_", "Bitmaps"},
1202 {"skia/sk_resource_cache/rrect-blur_", "Masks"},
1203 {"skia/sk_resource_cache/rects-blur_", "Masks"},
1204 {"skia/sk_resource_cache/tessellated", "Shadows"},
1205 {"skia", "Other"},
1206 };
1207 SkiaMemoryReporter cpuReporter(cpuResourceMap, false);
1208 SkGraphics::DumpMemoryStatistics(&cpuReporter);
1209 StringAppendF(&result, "Skia CPU Caches: ");
1210 cpuReporter.logTotals(result);
1211 cpuReporter.logOutput(result);
1212
1213 {
1214 std::lock_guard<std::mutex> lock(mRenderingMutex);
1215
1216 std::vector<ResourcePair> gpuResourceMap = {
1217 {"texture_renderbuffer", "Texture/RenderBuffer"},
1218 {"texture", "Texture"},
1219 {"gr_text_blob_cache", "Text"},
1220 {"skia", "Other"},
1221 };
1222 SkiaMemoryReporter gpuReporter(gpuResourceMap, true);
Nolan Scobiefc125ec2024-03-11 20:08:27 -04001223 mContext->dumpMemoryStatistics(&gpuReporter);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001224 StringAppendF(&result, "Skia's GPU Caches: ");
1225 gpuReporter.logTotals(result);
1226 gpuReporter.logOutput(result);
1227 StringAppendF(&result, "Skia's Wrapped Objects:\n");
1228 gpuReporter.logOutput(result, true);
1229
1230 StringAppendF(&result, "RenderEngine tracked buffers: %zu\n",
1231 mGraphicBufferExternalRefs.size());
1232 StringAppendF(&result, "Dumping buffer ids...\n");
1233 for (const auto& [id, refCounts] : mGraphicBufferExternalRefs) {
1234 StringAppendF(&result, "- 0x%" PRIx64 " - %d refs \n", id, refCounts);
1235 }
1236 StringAppendF(&result, "RenderEngine AHB/BackendTexture cache size: %zu\n",
1237 mTextureCache.size());
1238 StringAppendF(&result, "Dumping buffer ids...\n");
1239 // TODO(178539829): It would be nice to know which layer these are coming from and what
1240 // the texture sizes are.
1241 for (const auto& [id, unused] : mTextureCache) {
1242 StringAppendF(&result, "- 0x%" PRIx64 "\n", id);
1243 }
1244 StringAppendF(&result, "\n");
1245
1246 SkiaMemoryReporter gpuProtectedReporter(gpuResourceMap, true);
Nolan Scobiefc125ec2024-03-11 20:08:27 -04001247 if (mProtectedContext) {
1248 mProtectedContext->dumpMemoryStatistics(&gpuProtectedReporter);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -07001249 }
1250 StringAppendF(&result, "Skia's GPU Protected Caches: ");
1251 gpuProtectedReporter.logTotals(result);
1252 gpuProtectedReporter.logOutput(result);
1253 StringAppendF(&result, "Skia's Protected Wrapped Objects:\n");
1254 gpuProtectedReporter.logOutput(result, true);
1255
1256 StringAppendF(&result, "\n");
1257 StringAppendF(&result, "RenderEngine runtime effects: %zu\n", mRuntimeEffects.size());
1258 for (const auto& [linearEffect, unused] : mRuntimeEffects) {
1259 StringAppendF(&result, "- inputDataspace: %s\n",
1260 dataspaceDetails(
1261 static_cast<android_dataspace>(linearEffect.inputDataspace))
1262 .c_str());
1263 StringAppendF(&result, "- outputDataspace: %s\n",
1264 dataspaceDetails(
1265 static_cast<android_dataspace>(linearEffect.outputDataspace))
1266 .c_str());
1267 StringAppendF(&result, "undoPremultipliedAlpha: %s\n",
1268 linearEffect.undoPremultipliedAlpha ? "true" : "false");
1269 }
1270 }
1271 StringAppendF(&result, "\n");
1272}
1273
rnleec6a73642021-06-04 14:16:42 -07001274} // namespace skia
John Reck67b1e2b2020-08-26 13:17:24 -07001275} // namespace renderengine
rnleec6a73642021-06-04 14:16:42 -07001276} // namespace android