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 "common/rs_singleton.h"
17 #include "display_engine/rs_luminance_control.h"
18 #include "feature/hdr/rs_hdr_util.h"
19 #include "info_collection/rs_layer_compose_collection.h"
20 #include "rs_uni_render_engine.h"
21 #include "rs_uni_render_util.h"
22 #ifdef RS_ENABLE_GPU
23 #include "feature/round_corner_display/rs_round_corner_display_manager.h"
24 #endif
25 #ifdef USE_VIDEO_PROCESSING_ENGINE
26 #include "metadata_helper.h"
27 #endif
28
29 #include "drawable/rs_screen_render_node_drawable.h"
30 #include "drawable/rs_surface_render_node_drawable.h"
31
32 namespace OHOS {
33 namespace Rosen {
34
35 using RSRcdManager = RSSingleton<RoundCornerDisplayManager>;
36 namespace {
37 const float REDRAW_DFX_ALPHA = 0.4f; // redraw dfx drawrect alpha
38 }
DrawSurfaceNodeWithParams(RSPaintFilterCanvas & canvas,RSSurfaceRenderNode & node,BufferDrawParam & params,PreProcessFunc preProcess,PostProcessFunc postProcess)39 void RSUniRenderEngine::DrawSurfaceNodeWithParams(RSPaintFilterCanvas& canvas, RSSurfaceRenderNode& node,
40 BufferDrawParam& params, PreProcessFunc preProcess, PostProcessFunc postProcess)
41 {
42 RS_LOGE("RSUniRenderEngine::DrawSurfaceNodeWithParams is not support");
43 }
44
DrawSurfaceNodeWithParams(RSPaintFilterCanvas & canvas,DrawableV2::RSSurfaceRenderNodeDrawable & surfaceDrawable,BufferDrawParam & params,PreProcessFunc preProcess,PostProcessFunc postProcess)45 void RSUniRenderEngine::DrawSurfaceNodeWithParams(RSPaintFilterCanvas& canvas,
46 DrawableV2::RSSurfaceRenderNodeDrawable& surfaceDrawable, BufferDrawParam& params, PreProcessFunc preProcess,
47 PostProcessFunc postProcess)
48 {
49 canvas.Save();
50 canvas.ConcatMatrix(params.matrix);
51 if (!params.useCPU) {
52 RegisterDeleteBufferListener(surfaceDrawable.GetConsumerOnDraw());
53 DrawImage(canvas, params);
54 } else {
55 DrawBuffer(canvas, params);
56 }
57 canvas.Restore();
58 }
59
60 #ifdef USE_VIDEO_PROCESSING_ENGINE
DrawLayers(RSPaintFilterCanvas & canvas,const std::vector<LayerInfoPtr> & layers,bool forceCPU,const ScreenInfo & screenInfo,GraphicColorGamut colorGamut)61 void RSUniRenderEngine::DrawLayers(RSPaintFilterCanvas& canvas, const std::vector<LayerInfoPtr>& layers, bool forceCPU,
62 const ScreenInfo& screenInfo, GraphicColorGamut colorGamut)
63 #else
64 void RSUniRenderEngine::DrawLayers(RSPaintFilterCanvas& canvas, const std::vector<LayerInfoPtr>& layers, bool forceCPU,
65 const ScreenInfo& screenInfo)
66 #endif
67 {
68 for (const auto& layer : layers) {
69 if (layer == nullptr) {
70 continue;
71 }
72 if (layer->GetCompositionType() == GraphicCompositionType::GRAPHIC_COMPOSITION_DEVICE ||
73 layer->GetCompositionType() == GraphicCompositionType::GRAPHIC_COMPOSITION_DEVICE_CLEAR ||
74 layer->GetCompositionType() == GraphicCompositionType::GRAPHIC_COMPOSITION_SOLID_COLOR) {
75 continue;
76 }
77 GraphicLayerColor layerBlackColor = {
78 .r = 0,
79 .g = 0,
80 .b = 0,
81 .a = 0
82 };
83 auto layerSurface = layer->GetSurface();
84 if (layerSurface == nullptr) {
85 const auto& layerColor = layer->GetLayerColor();
86 if (layerColor.a != layerBlackColor.a || layerColor.r != layerBlackColor.r ||
87 layerColor.g != layerBlackColor.g || layerColor.b != layerBlackColor.b) {
88 Drawing::AutoCanvasRestore acr(canvas, true);
89 const auto& dstRect = layer->GetLayerSize();
90 auto color = Drawing::Color::ColorQuadSetARGB(layerColor.a, layerColor.r, layerColor.g, layerColor.b);
91 Drawing::Rect clipRect = Drawing::Rect(static_cast<float>(dstRect.x), static_cast<float>(dstRect.y),
92 static_cast<float>(dstRect.w) + static_cast<float>(dstRect.x),
93 static_cast<float>(dstRect.h) + static_cast<float>(dstRect.y));
94 canvas.ClipRect(clipRect, Drawing::ClipOp::INTERSECT, false);
95 canvas.DrawColor(color);
96 }
97 continue;
98 } else if (RSRcdManager::GetInstance().CheckLayerIsRCD(layerSurface->GetName())) {
99 continue;
100 }
101 Drawing::AutoCanvasRestore acr(canvas, true);
102 DrawLayerPreProcess(canvas, layer, screenInfo);
103 // prepare BufferDrawParam
104 auto params = RSUniRenderUtil::CreateLayerBufferDrawParam(layer, forceCPU);
105 params.matrix.PostScale(screenInfo.GetRogWidthRatio(), screenInfo.GetRogHeightRatio());
106 params.screenId = screenInfo.id;
107 #ifdef USE_VIDEO_PROCESSING_ENGINE
108 params.targetColorGamut = colorGamut;
109 auto screenManager = CreateOrGetScreenManager();
110 if (screenManager != nullptr) {
111 params.sdrNits = layer->GetSdrNit();
112 params.tmoNits = layer->GetDisplayNit();
113 params.displayNits = params.tmoNits / std::pow(layer->GetBrightnessRatio(), 2.2f); // gamma 2.2
114 // color temperature
115 params.layerLinearMatrix = layer->GetLayerLinearMatrix();
116 }
117 if (RSHdrUtil::CheckIsHdrSurfaceBuffer(layer->GetBuffer()) == HdrStatus::NO_HDR) {
118 params.brightnessRatio = layer->GetBrightnessRatio();
119 if (RSHdrUtil::CheckIsSurfaceBufferWithMetadata(layer->GetBuffer())) {
120 params.hasMetadata = true;
121 }
122 } else {
123 params.isHdrRedraw = true;
124 }
125 #endif
126 RS_TRACE_NAME_FMT("DrawLayerWithParams, surface name: %s", layerSurface->GetName().c_str());
127 DrawHdiLayerWithParams(canvas, layer, params);
128 // Dfx for redraw region
129 auto dstRect = layer->GetLayerSize();
130 if (RSSystemProperties::GetHwcRegionDfxEnabled()) {
131 RectI dst(dstRect.x, dstRect.y, dstRect.w, dstRect.h);
132 RSUniRenderUtil::DrawRectForDfx(canvas, dst, Drawing::Color::COLOR_YELLOW, REDRAW_DFX_ALPHA,
133 layerSurface->GetName());
134 }
135 }
136
137 LayerComposeCollection::GetInstance().UpdateRedrawFrameNumberForDFX();
138 }
139
DrawLayerPreProcess(RSPaintFilterCanvas & canvas,const LayerInfoPtr & layer,const ScreenInfo & screenInfo)140 void RSUniRenderEngine::DrawLayerPreProcess(RSPaintFilterCanvas& canvas, const LayerInfoPtr& layer,
141 const ScreenInfo& screenInfo)
142 {
143 const auto& dstRect = layer->GetLayerSize();
144 const auto& drmCornerRadiusInfo = layer->GetCornerRadiusInfoForDRM();
145 const auto& layerBackgroundColor = layer->GetBackgroundColor();
146 Color backgroundColor = {
147 layerBackgroundColor.r,
148 layerBackgroundColor.g,
149 layerBackgroundColor.b,
150 layerBackgroundColor.a
151 };
152 // clip round rect when drm has radius info
153 if (!drmCornerRadiusInfo.empty()) {
154 auto rect = RectF();
155 rect = {drmCornerRadiusInfo[0], drmCornerRadiusInfo[1], // 0 and 1 represent rect left and top
156 drmCornerRadiusInfo[2], drmCornerRadiusInfo[3]}; // 2 and 3 represent rect width and height
157 Vector4f radiusVector {drmCornerRadiusInfo[4], drmCornerRadiusInfo[5], // 4 and 5 represent corner radius
158 drmCornerRadiusInfo[6], drmCornerRadiusInfo[7]}; // 6 and 7 represent corner radius
159 RRect rrect = RRect(rect, radiusVector);
160 canvas.ClipRoundRect(RSPropertiesPainter::RRect2DrawingRRect(rrect), Drawing::ClipOp::INTERSECT, true);
161 if (backgroundColor != RgbPalette::Transparent()) {
162 canvas.DrawColor(backgroundColor.AsArgbInt());
163 }
164 return;
165 }
166 // draw background color for DRM buffer and then draw layer size image when surface has scaling mode
167 if (layer->GetBuffer() && (layer->GetBuffer()->GetUsage() & BUFFER_USAGE_PROTECTED) &&
168 backgroundColor != RgbPalette::Transparent()) {
169 const auto& boundsRect = layer->GetBoundSize();
170 const auto& layerMatrix = layer->GetMatrix();
171 auto skMatrix = Drawing::Matrix();
172 skMatrix.SetMatrix(layerMatrix.scaleX, layerMatrix.skewX, layerMatrix.transX, layerMatrix.skewY,
173 layerMatrix.scaleY, layerMatrix.transY, layerMatrix.pers0, layerMatrix.pers1, layerMatrix.pers2);
174 skMatrix.PostTranslate(screenInfo.samplingTranslateX, screenInfo.samplingTranslateY);
175 skMatrix.PostScale(screenInfo.samplingScale, screenInfo.samplingScale);
176 Drawing::AutoCanvasRestore acr(canvas, true);
177 canvas.ConcatMatrix(skMatrix);
178 Drawing::Rect drawRect = Drawing::Rect(0.f, 0.f,
179 static_cast<float>(boundsRect.w), static_cast<float>(boundsRect.h));
180 Drawing::Brush rectBrush;
181 rectBrush.SetColor(backgroundColor.AsArgbInt());
182 canvas.AttachBrush(rectBrush);
183 canvas.DrawRect(drawRect);
184 canvas.DetachBrush();
185 }
186 Drawing::Rect clipRect = Drawing::Rect(static_cast<float>(dstRect.x), static_cast<float>(dstRect.y),
187 static_cast<float>(dstRect.w) + static_cast<float>(dstRect.x),
188 static_cast<float>(dstRect.h) + static_cast<float>(dstRect.y));
189 canvas.ClipRect(clipRect, Drawing::ClipOp::INTERSECT, false);
190 }
191
DrawHdiLayerWithParams(RSPaintFilterCanvas & canvas,const LayerInfoPtr & layer,BufferDrawParam & params)192 void RSUniRenderEngine::DrawHdiLayerWithParams(RSPaintFilterCanvas& canvas, const LayerInfoPtr& layer,
193 BufferDrawParam& params)
194 {
195 RS_LOGD_IF(DEBUG_COMPOSER, "RSUniRenderEngine::DrawHdiLayerWithParams: matrix=[%{public}.2f, %{public}.2f, "
196 "%{public}.2f, %{public}.2f, %{public}.2f, %{public}.2f, %{public}.2f, %{public}.2f, %{public}.2f]",
197 params.matrix.Get(Drawing::Matrix::SCALE_X), params.matrix.Get(Drawing::Matrix::SKEW_X),
198 params.matrix.Get(Drawing::Matrix::TRANS_X), params.matrix.Get(Drawing::Matrix::SKEW_Y),
199 params.matrix.Get(Drawing::Matrix::SCALE_Y), params.matrix.Get(Drawing::Matrix::TRANS_Y),
200 params.matrix.Get(Drawing::Matrix::PERSP_0), params.matrix.Get(Drawing::Matrix::PERSP_1),
201 params.matrix.Get(Drawing::Matrix::PERSP_2));
202 canvas.ConcatMatrix(params.matrix);
203 if (!params.useCPU) {
204 RegisterDeleteBufferListener(layer->GetSurface(), !RSSystemProperties::GetVKImageUseEnabled());
205 DrawImage(canvas, params);
206 } else {
207 DrawBuffer(canvas, params);
208 }
209 }
210
DrawHDRCacheWithParams(RSPaintFilterCanvas & canvas,BufferDrawParam & params)211 void RSUniRenderEngine::DrawHDRCacheWithParams(RSPaintFilterCanvas& canvas, BufferDrawParam& params)
212 {
213 if (!params.useCPU) {
214 DrawImage(canvas, params);
215 } else {
216 DrawBuffer(canvas, params);
217 }
218 }
219 } // namespace Rosen
220 } // namespace OHOS
221