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