1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "rs_base_render_engine.h"
17
18 #include "rs_divided_render_util.h"
19 #include "rs_trace.h"
20
21 #include "pipeline/rs_uni_render_judgement.h"
22 #include "platform/common/rs_log.h"
23 #include "platform/common/rs_system_properties.h"
24 #include "platform/ohos/backend/rs_surface_ohos_gl.h"
25 #include "platform/ohos/backend/rs_surface_ohos_raster.h"
26 #include "render/rs_skia_filter.h"
27
28 namespace OHOS {
29 namespace Rosen {
RSBaseRenderEngine()30 RSBaseRenderEngine::RSBaseRenderEngine()
31 {
32 }
33
~RSBaseRenderEngine()34 RSBaseRenderEngine::~RSBaseRenderEngine() noexcept
35 {
36 }
37
Init()38 void RSBaseRenderEngine::Init()
39 {
40 #ifdef RS_ENABLE_GL
41 renderContext_ = std::make_shared<RenderContext>();
42 renderContext_->InitializeEglContext();
43 if (RSUniRenderJudgement::IsUniRender()) {
44 RS_LOGI("RSRenderEngine::RSRenderEngine set new cacheDir");
45 renderContext_->SetUniRenderMode(true);
46 }
47 renderContext_->SetUpGrContext();
48 #endif // RS_ENABLE_GL
49
50 #ifdef RS_ENABLE_EGLIMAGE
51 eglImageManager_ = std::make_shared<RSEglImageManager>(renderContext_->GetEGLDisplay());
52 #endif // RS_ENABLE_EGLIMAGE
53 }
54
NeedForceCPU(const std::vector<LayerInfoPtr> & layers)55 bool RSBaseRenderEngine::NeedForceCPU(const std::vector<LayerInfoPtr>& layers)
56 {
57 bool forceCPU = false;
58 for (const auto& layer: layers) {
59 if (layer == nullptr) {
60 continue;
61 }
62
63 auto buffer = layer->GetBuffer();
64 if (buffer == nullptr) {
65 continue;
66 }
67
68 #ifndef RS_ENABLE_EGLIMAGE
69 const auto bufferFormat = buffer->GetFormat();
70 if (bufferFormat == PIXEL_FMT_YCRCB_420_SP || bufferFormat == PIXEL_FMT_YCBCR_420_SP) {
71 forceCPU = true;
72 break;
73 }
74 #endif
75
76 GraphicColorGamut srcGamut = static_cast<GraphicColorGamut>(buffer->GetSurfaceBufferColorGamut());
77 GraphicColorGamut dstGamut = GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB;
78 if (srcGamut != dstGamut) {
79 forceCPU = true;
80 break;
81 }
82 }
83
84 return forceCPU;
85 }
86
CreateEglImageFromBuffer(const sptr<SurfaceBuffer> & buffer,const sptr<SyncFence> & acquireFence)87 sk_sp<SkImage> RSBaseRenderEngine::CreateEglImageFromBuffer(
88 const sptr<SurfaceBuffer>& buffer, const sptr<SyncFence>& acquireFence)
89 {
90 #ifdef RS_ENABLE_EGLIMAGE
91 if (!RSBaseRenderUtil::IsBufferValid(buffer)) {
92 RS_LOGE("RSBaseRenderEngine::CreateEglImageFromBuffer invalid param!");
93 return nullptr;
94 }
95 if (renderContext_->GetGrContext() == nullptr) {
96 RS_LOGE("RSBaseRenderEngine::CreateEglImageFromBuffer GrContext is null!");
97 return nullptr;
98 }
99 auto eglTextureId = eglImageManager_->MapEglImageFromSurfaceBuffer(buffer, acquireFence);
100 if (eglTextureId == 0) {
101 RS_LOGE("RSBaseRenderEngine::CreateEglImageFromBuffer MapEglImageFromSurfaceBuffer return invalid texture ID");
102 return nullptr;
103 }
104 SkColorType colorType = (buffer->GetFormat() == PIXEL_FMT_BGRA_8888) ?
105 kBGRA_8888_SkColorType : kRGBA_8888_SkColorType;
106 GrGLTextureInfo grExternalTextureInfo = { GL_TEXTURE_EXTERNAL_OES, eglTextureId, GL_RGBA8 };
107 GrBackendTexture backendTexture(buffer->GetSurfaceBufferWidth(), buffer->GetSurfaceBufferHeight(),
108 GrMipMapped::kNo, grExternalTextureInfo);
109 return SkImage::MakeFromTexture(renderContext_->GetGrContext(), backendTexture,
110 kTopLeft_GrSurfaceOrigin, colorType, kPremul_SkAlphaType, nullptr);
111 #else
112 return nullptr;
113 #endif // RS_ENABLE_EGLIMAGE
114 }
115
RequestFrame(const std::shared_ptr<RSSurfaceOhos> & rsSurface,const BufferRequestConfig & config,bool forceCPU,bool useAFBC)116 std::unique_ptr<RSRenderFrame> RSBaseRenderEngine::RequestFrame(const std::shared_ptr<RSSurfaceOhos>& rsSurface,
117 const BufferRequestConfig& config, bool forceCPU, bool useAFBC)
118 {
119 RS_TRACE_NAME("RSBaseRenderEngine::RequestFrame(RSSurface)");
120 if (rsSurface == nullptr) {
121 RS_LOGE("RSBaseRenderEngine::RequestFrame: surface is null!");
122 return nullptr;
123 }
124
125 auto bufferUsage = config.usage;
126 #if (defined RS_ENABLE_GL) && (defined RS_ENABLE_EGLIMAGE)
127 if (forceCPU) {
128 bufferUsage |= BUFFER_USAGE_CPU_WRITE;
129 }
130 #else // (defined RS_ENABLE_GL) && (defined RS_ENABLE_EGLIMAGE)
131 bufferUsage |= BUFFER_USAGE_CPU_WRITE;
132 #endif // (defined RS_ENABLE_GL) && (defined RS_ENABLE_EGLIMAGE)
133 rsSurface->SetSurfaceBufferUsage(bufferUsage);
134
135 // check if we can use GPU context
136 #ifdef RS_ENABLE_GL
137 if (renderContext_ != nullptr) {
138 rsSurface->SetRenderContext(renderContext_.get());
139 }
140 #endif
141
142 auto surfaceFrame = rsSurface->RequestFrame(config.width, config.height, 0, useAFBC);
143 if (surfaceFrame == nullptr) {
144 RS_LOGE("RSBaseRenderEngine::RequestFrame: request SurfaceFrame failed!");
145 return nullptr;
146 }
147
148 return std::make_unique<RSRenderFrame>(rsSurface, std::move(surfaceFrame));
149 }
150
RequestFrame(const sptr<Surface> & targetSurface,const BufferRequestConfig & config,bool forceCPU,bool useAFBC)151 std::unique_ptr<RSRenderFrame> RSBaseRenderEngine::RequestFrame(const sptr<Surface>& targetSurface,
152 const BufferRequestConfig& config, bool forceCPU, bool useAFBC)
153 {
154 RS_TRACE_NAME("RSBaseRenderEngine::RequestFrame(Surface)");
155 if (targetSurface == nullptr) {
156 RS_LOGE("RSBaseRenderEngine::RequestFrame: surface is null!");
157 return nullptr;
158 }
159
160 auto surfaceId = targetSurface->GetUniqueId();
161 if (rsSurfaces_.count(surfaceId) == 0) {
162 #if (defined RS_ENABLE_GL) && (defined RS_ENABLE_EGLIMAGE)
163 if (forceCPU) {
164 rsSurfaces_[surfaceId] = std::make_shared<RSSurfaceOhosRaster>(targetSurface);
165 } else {
166 rsSurfaces_[surfaceId] = std::make_shared<RSSurfaceOhosGl>(targetSurface);
167 }
168 #else
169 rsSurfaces_[surfaceId] = std::make_shared<RSSurfaceOhosRaster>(targetSurface);
170 #endif // (defined RS_ENABLE_GL) && (defined RS_ENABLE_EGLIMAGE)
171 }
172
173 return RequestFrame(rsSurfaces_.at(surfaceId), config, forceCPU, useAFBC);
174 }
175
SetUiTimeStamp(const std::unique_ptr<RSRenderFrame> & renderFrame,const uint64_t surfaceId)176 void RSBaseRenderEngine::SetUiTimeStamp(const std::unique_ptr<RSRenderFrame>& renderFrame, const uint64_t surfaceId)
177 {
178 std::shared_ptr<RSSurfaceOhos> surfaceOhos = nullptr;
179 for (auto it = rsSurfaces_.begin(); it != rsSurfaces_.end(); ++it) {
180 if (it->first == surfaceId) {
181 surfaceOhos = it->second;
182 break;
183 }
184 }
185
186 if (surfaceOhos == nullptr) {
187 RS_LOGE("RSBaseRenderEngine::SetUiTimeStamp: surfaceOhos is null!");
188 return;
189 }
190
191 if (renderFrame == nullptr) {
192 RS_LOGE("RSBaseRenderEngine::SetUiTimeStamp: renderFrame is null!.");
193 return;
194 }
195
196 auto& frame = renderFrame->GetFrame();
197 surfaceOhos->SetUiTimeStamp(frame);
198 }
199
DrawDisplayNodeWithParams(RSPaintFilterCanvas & canvas,RSDisplayRenderNode & node,BufferDrawParam & params)200 void RSBaseRenderEngine::DrawDisplayNodeWithParams(RSPaintFilterCanvas& canvas, RSDisplayRenderNode& node,
201 BufferDrawParam& params)
202 {
203 if (params.useCPU) {
204 DrawBuffer(canvas, params);
205 } else {
206 RegisterDeleteBufferListener(node.GetConsumer());
207 DrawImage(canvas, params);
208 }
209 }
210
SetColorFilterMode(ColorFilterMode mode)211 void RSBaseRenderEngine::SetColorFilterMode(ColorFilterMode mode)
212 {
213 uint32_t uMode = static_cast<uint32_t>(mode);
214 uint32_t uInvertMode = static_cast<uint32_t>(ColorFilterMode::INVERT_COLOR_ENABLE_MODE);
215 uint32_t ucolorFilterMode = static_cast<uint32_t>(colorFilterMode_);
216 bool isInvertModeEnabled = ((ucolorFilterMode & uInvertMode) == uInvertMode);
217
218 switch (mode) {
219 case ColorFilterMode::INVERT_COLOR_DISABLE_MODE: {
220 if (colorFilterMode_ != ColorFilterMode::COLOR_FILTER_END) {
221 colorFilterMode_ = static_cast<ColorFilterMode>(ucolorFilterMode & ~uInvertMode);
222 }
223 break;
224 }
225 case ColorFilterMode::INVERT_COLOR_ENABLE_MODE: {
226 if (colorFilterMode_ != ColorFilterMode::COLOR_FILTER_END) {
227 colorFilterMode_ = static_cast<ColorFilterMode>(ucolorFilterMode | uInvertMode);
228 } else {
229 colorFilterMode_ = mode;
230 }
231 break;
232 }
233 case ColorFilterMode::DALTONIZATION_PROTANOMALY_MODE:
234 case ColorFilterMode::DALTONIZATION_DEUTERANOMALY_MODE:
235 case ColorFilterMode::DALTONIZATION_TRITANOMALY_MODE: {
236 if (isInvertModeEnabled) {
237 colorFilterMode_ = static_cast<ColorFilterMode>(uMode | uInvertMode);
238 } else {
239 colorFilterMode_ = mode;
240 }
241 break;
242 }
243 case ColorFilterMode::DALTONIZATION_NORMAL_MODE: {
244 if (isInvertModeEnabled) {
245 colorFilterMode_ = ColorFilterMode::INVERT_COLOR_ENABLE_MODE;
246 } else {
247 colorFilterMode_ = ColorFilterMode::COLOR_FILTER_END;
248 }
249 break;
250 }
251
252 // INVERT_DALTONIZATION_PROTANOMALY_MODE, INVERT_DALTONIZATION_DEUTERANOMALY_MODE
253 // INVERT_DALTONIZATION_TRITANOMALY_MODE and COLOR_FILTER_END can not be set directly
254 case ColorFilterMode::INVERT_DALTONIZATION_PROTANOMALY_MODE: // fall-through
255 case ColorFilterMode::INVERT_DALTONIZATION_DEUTERANOMALY_MODE: // fall-through
256 case ColorFilterMode::INVERT_DALTONIZATION_TRITANOMALY_MODE: // fall-through
257 case ColorFilterMode::COLOR_FILTER_END: // fall-through
258 default: {
259 colorFilterMode_ = ColorFilterMode::COLOR_FILTER_END;
260 break;
261 }
262 }
263 }
264
DrawBuffer(RSPaintFilterCanvas & canvas,BufferDrawParam & params)265 void RSBaseRenderEngine::DrawBuffer(RSPaintFilterCanvas& canvas, BufferDrawParam& params)
266 {
267 RS_TRACE_NAME("RSBaseRenderEngine::DrawBuffer(CPU)");
268 SkBitmap bitmap;
269 std::vector<uint8_t> newBuffer;
270 if (!RSBaseRenderUtil::ConvertBufferToBitmap(params.buffer, newBuffer, params.targetColorGamut, bitmap,
271 params.metaDatas)) {
272 RS_LOGE("RSDividedRenderUtil::DrawBuffer: create bitmap failed.");
273 return;
274 }
275 canvas.drawBitmapRect(bitmap, params.srcRect, params.dstRect, &(params.paint));
276 }
277
DrawImage(RSPaintFilterCanvas & canvas,BufferDrawParam & params)278 void RSBaseRenderEngine::DrawImage(RSPaintFilterCanvas& canvas, BufferDrawParam& params)
279 {
280 RS_TRACE_NAME("RSBaseRenderEngine::DrawImage(GPU)");
281 auto image = CreateEglImageFromBuffer(params.buffer, params.acquireFence);
282 if (image == nullptr) {
283 RS_LOGE("RSDividedRenderUtil::DrawImage: image is nullptr!");
284 return;
285 }
286 canvas.drawImageRect(image, params.srcRect, params.dstRect, &(params.paint));
287 }
288
RegisterDeleteBufferListener(const sptr<Surface> & consumer)289 void RSBaseRenderEngine::RegisterDeleteBufferListener(const sptr<Surface>& consumer)
290 {
291 #ifdef RS_ENABLE_EGLIMAGE
292 auto regUnMapEglImageFunc = [](int32_t bufferId) {
293 eglImageManager_->UnMapEglImageFromSurfaceBuffer(bufferId);
294 };
295 if (consumer == nullptr ||
296 (consumer->RegisterDeleteBufferListener(regUnMapEglImageFunc) != GSERROR_OK)) {
297 RS_LOGE("RSBaseRenderEngine::RegisterDeleteBufferListener: failed to register UnMapEglImage callback.");
298 }
299 #endif // #ifdef RS_ENABLE_EGLIMAGE
300 }
301
ShrinkCachesIfNeeded()302 void RSBaseRenderEngine::ShrinkCachesIfNeeded()
303 {
304 #ifdef RS_ENABLE_EGLIMAGE
305 if (eglImageManager_ != nullptr) {
306 eglImageManager_->ShrinkCachesIfNeeded();
307 }
308 #endif // RS_ENABLE_EGLIMAGE
309
310 while (rsSurfaces_.size() > MAX_RS_SURFACE_SIZE) {
311 auto it = rsSurfaces_.begin();
312 (void)rsSurfaces_.erase(it);
313 }
314 }
315 } // namespace Rosen
316 } // namespace OHOS
317