1 /*
2 * Copyright (c) 2023 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_rcd_surface_render_node.h"
17 #include "common/rs_singleton.h"
18 #include "common/rs_optional_trace.h"
19 #include "platform/common/rs_log.h"
20 #include "params/rs_rcd_render_params.h"
21 #include "transaction/rs_render_service_client.h"
22 #include "pipeline/rs_canvas_render_node.h"
23 #include "pipeline/rs_processor.h"
24 #include "rs_rcd_surface_render_node_drawable.h"
25 #include "rs_round_corner_display_manager.h"
26 #include "rs_rcd_render_visitor.h"
27
28 namespace OHOS {
29 namespace Rosen {
30
31 const float RCD_LAYER_Z_TOP1 = static_cast<float>(0x7FFFFFFF); // toppest
32 const float RCD_LAYER_Z_TOP2 = static_cast<float>(0x7FFFFEFF); // not set toppest - 1, float only 6 significant digits
33
RSRcdSurfaceRenderNode(RCDSurfaceType type,const std::weak_ptr<RSContext> & context)34 RSRcdSurfaceRenderNode::RSRcdSurfaceRenderNode(RCDSurfaceType type, const std::weak_ptr<RSContext>& context)
35 : RSRcdSurfaceRenderNode(GenerateId(), type, context)
36 {}
37
RSRcdSurfaceRenderNode(NodeId id,RCDSurfaceType type,const std::weak_ptr<RSContext> & context)38 RSRcdSurfaceRenderNode::RSRcdSurfaceRenderNode(NodeId id, RCDSurfaceType type, const std::weak_ptr<RSContext> &context)
39 : RSRenderNode(id, context), surfaceHandler_(std::make_shared<RSSurfaceHandler>(id))
40 {
41 RS_LOGD("RCD: Start Create RSRcdSurfaceRenderNode %{public}d", type);
42 rcdExtInfo_.surfaceType = type;
43 MemoryInfo info = {sizeof(*this), ExtractPid(id), id, MEMORY_TYPE::MEM_RENDER_NODE};
44 MemoryTrack::Instance().AddNodeRecord(id, info);
45 MemorySnapshot::Instance().AddCpuMemory(ExtractPid(id), sizeof(*this));
46 }
47
Create(NodeId id,RCDSurfaceType type,const std::weak_ptr<RSContext> & context)48 RSRcdSurfaceRenderNode::SharedPtr RSRcdSurfaceRenderNode::Create(
49 NodeId id, RCDSurfaceType type, const std::weak_ptr<RSContext> &context)
50 {
51 auto node = std::make_shared<RSRcdSurfaceRenderNode>(type, context);
52 node->renderTargetId_ = id;
53 node->InitRenderParams();
54 RSSingleton<RoundCornerDisplayManager>::GetInstance().AddRoundCornerDisplay(id);
55 return node;
56 }
57
InitRenderParams()58 void RSRcdSurfaceRenderNode::InitRenderParams()
59 {
60 stagingRenderParams_ = std::make_unique<RSRcdRenderParams>(GetId());
61 DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(shared_from_this());
62 if (renderDrawable_ == nullptr) {
63 RS_LOGE("RSRcdSurfaceRenderNode::InitRenderParams failed");
64 return;
65 }
66 auto renderDrawable = std::static_pointer_cast<DrawableV2::RSRcdSurfaceRenderNodeDrawable>(renderDrawable_);
67 if (renderDrawable) {
68 renderDrawable->SetRenderTargetId(renderTargetId_);
69 renderDrawable->SetSurfaceType(static_cast<uint32_t>(rcdExtInfo_.surfaceType));
70 }
71 }
72
~RSRcdSurfaceRenderNode()73 RSRcdSurfaceRenderNode::~RSRcdSurfaceRenderNode()
74 {
75 MemoryTrack::Instance().RemoveNodeRecord(GetId());
76 MemorySnapshot::Instance().RemoveCpuMemory(ExtractPid(GetId()), sizeof(*this));
77 RSSingleton<RoundCornerDisplayManager>::GetInstance().RemoveRCDResource(renderTargetId_);
78 }
79
GetSrcRect() const80 const RectI& RSRcdSurfaceRenderNode::GetSrcRect() const
81 {
82 return rcdExtInfo_.srcRect_;
83 }
84
GetDstRect() const85 const RectI& RSRcdSurfaceRenderNode::GetDstRect() const
86 {
87 return rcdExtInfo_.dstRect_;
88 }
89
OnSync()90 void RSRcdSurfaceRenderNode::OnSync()
91 {
92 auto rcdParams = static_cast<RSRcdRenderParams*>(stagingRenderParams_.get());
93 if (rcdParams == nullptr) {
94 RS_LOGE("RSRcdSurfaceRenderNode::OnSync rcdParams is null");
95 return;
96 }
97 if (!renderDrawable_) {
98 return;
99 }
100 rcdParams->SetRcdEnabled(RSSingleton<RoundCornerDisplayManager>::GetInstance().GetRcdEnable());
101 if (rcdParams->GetResourceChanged()) {
102 rcdParams->SetNeedSync(true);
103 }
104 RSRenderNode::OnSync();
105 }
106
PrepareHardwareResource(std::shared_ptr<rs_rcd::RoundCornerLayer> & layerInfo)107 void RSRcdSurfaceRenderNode::PrepareHardwareResource(std::shared_ptr<rs_rcd::RoundCornerLayer> &layerInfo)
108 {
109 auto visitor = std::make_shared<RSRcdRenderVisitor>();
110 auto res = visitor->PrepareResourceBuffer(*this, layerInfo);
111 }
112
DoProcessRenderMainThreadTask(bool resourceChanged,std::shared_ptr<RSProcessor> processor)113 void RSRcdSurfaceRenderNode::DoProcessRenderMainThreadTask(bool resourceChanged, std::shared_ptr<RSProcessor> processor)
114 {
115 RS_TRACE_BEGIN("RSRcdSurfaceRenderNode:DoRCDProcessMainThreadTask");
116 if (!RSSingleton<RoundCornerDisplayManager>::GetInstance().GetRcdEnable()) {
117 RS_LOGD("RSRcdSurfaceRenderNode:DoRCDProcessMainThreadTask: Draw skip, rcd disabled");
118 RS_TRACE_END();
119 return;
120 }
121 if (!processor) {
122 RS_LOGE("RCD: Processor in MainThread is incorrect");
123 RS_TRACE_END();
124 return;
125 }
126 auto visitor = std::make_shared<RSRcdRenderVisitor>();
127 visitor->SetUniProcessor(processor);
128 visitor->ProcessRcdSurfaceRenderNode(*this, resourceChanged);
129 RS_TRACE_END();
130 }
131
SetRcdBufferWidth(uint32_t width)132 void RSRcdSurfaceRenderNode::SetRcdBufferWidth(uint32_t width)
133 {
134 rcdSourceInfo.bufferWidth = width;
135 }
136
GetRcdBufferWidth() const137 uint32_t RSRcdSurfaceRenderNode::GetRcdBufferWidth() const
138 {
139 return rcdSourceInfo.bufferWidth;
140 }
141
SetRcdBufferHeight(uint32_t height)142 void RSRcdSurfaceRenderNode::SetRcdBufferHeight(uint32_t height)
143 {
144 rcdSourceInfo.bufferHeight = height;
145 }
146
GetRcdBufferHeight() const147 uint32_t RSRcdSurfaceRenderNode::GetRcdBufferHeight() const
148 {
149 return rcdSourceInfo.bufferHeight;
150 }
151
SetRcdBufferSize(uint32_t bufferSize)152 void RSRcdSurfaceRenderNode::SetRcdBufferSize(uint32_t bufferSize)
153 {
154 rcdSourceInfo.bufferSize = bufferSize;
155 }
156
GetRcdBufferSize() const157 uint32_t RSRcdSurfaceRenderNode::GetRcdBufferSize() const
158 {
159 return rcdSourceInfo.bufferSize;
160 }
161
PrepareHardwareResourceBuffer(const std::shared_ptr<rs_rcd::RoundCornerLayer> & layerInfo)162 bool RSRcdSurfaceRenderNode::PrepareHardwareResourceBuffer(const std::shared_ptr<rs_rcd::RoundCornerLayer>& layerInfo)
163 {
164 RS_LOGD("RCD: Start PrepareHardwareResourceBuffer");
165 if (layerInfo == nullptr) {
166 RS_LOGE("RCD: layerInfo is nullptr");
167 return false;
168 }
169
170 cldLayerInfo_.pathBin = std::string(rs_rcd::PATH_CONFIG_DIR) + "/" + layerInfo->binFileName;
171 cldLayerInfo_.bufferSize = layerInfo->bufferSize;
172 cldLayerInfo_.cldWidth = layerInfo->cldWidth;
173 cldLayerInfo_.cldHeight = layerInfo->cldHeight;
174
175 if (layerInfo->curBitmap == nullptr) {
176 RS_LOGE("layerInfo->curBitmap is nullptr");
177 return false;
178 }
179 layerBitmap_ = *(layerInfo->curBitmap);
180 uint32_t bitmapHeight = static_cast<uint32_t>(layerBitmap_.GetHeight());
181 uint32_t bitmapWidth = static_cast<uint32_t>(layerBitmap_.GetWidth());
182 if (bitmapHeight <= 0 || bitmapWidth <= 0 || displayRect_.GetHeight() <= 0) {
183 RS_LOGE("bitmapHeight, bitmapWidth or layerHeight is wrong value");
184 return false;
185 }
186 SetRcdBufferHeight(bitmapHeight);
187 SetRcdBufferWidth(bitmapWidth);
188 SetRcdBufferSize(cldLayerInfo_.bufferSize);
189
190 if (IsTopSurface()) {
191 rcdExtInfo_.srcRect_ = RectI(0, 0, bitmapWidth, bitmapHeight);
192 rcdExtInfo_.dstRect_ = RectI(displayRect_.GetLeft(), displayRect_.GetTop(), bitmapWidth, bitmapHeight);
193 surfaceHandler_->SetGlobalZOrder(RCD_LAYER_Z_TOP1);
194 } else {
195 rcdExtInfo_.srcRect_ = RectI(0, 0, bitmapWidth, bitmapHeight);
196 rcdExtInfo_.dstRect_ = RectI(displayRect_.GetLeft(), displayRect_.GetHeight() - bitmapHeight +
197 displayRect_.GetTop(), bitmapWidth, bitmapHeight);
198 surfaceHandler_->SetGlobalZOrder(RCD_LAYER_Z_TOP2);
199 }
200 return true;
201 }
202
UpdateRcdRenderParams(bool resourceChanged,const std::shared_ptr<Drawing::Bitmap> curBitmap)203 void RSRcdSurfaceRenderNode::UpdateRcdRenderParams(
204 bool resourceChanged, const std::shared_ptr<Drawing::Bitmap> curBitmap)
205 {
206 auto rcdParams = static_cast<RSRcdRenderParams*>(stagingRenderParams_.get());
207 if (resourceChanged) {
208 rcdParams->SetPathBin(cldLayerInfo_.pathBin);
209 rcdParams->SetBufferSize(cldLayerInfo_.bufferSize);
210 rcdParams->SetCldWidth(cldLayerInfo_.cldWidth);
211 rcdParams->SetCldHeight(cldLayerInfo_.cldHeight);
212 rcdParams->SetSrcRect(rcdExtInfo_.srcRect_);
213 rcdParams->SetDstRect(rcdExtInfo_.dstRect_);
214 rcdParams->SetRcdBitmap(curBitmap);
215 }
216 rcdParams->SetResourceChanged(resourceChanged);
217 if (rcdParams->NeedSync()) {
218 AddToPendingSyncList();
219 }
220 }
221
ResetCurrFrameState()222 void RSRcdSurfaceRenderNode::ResetCurrFrameState()
223 {
224 rcdExtInfo_.srcRect_.Clear();
225 rcdExtInfo_.dstRect_.Clear();
226 rcdExtInfo_.surfaceBounds.Clear();
227 rcdExtInfo_.frameBounds.Clear();
228 rcdExtInfo_.frameViewPort.Clear();
229 }
230
Reset()231 void RSRcdSurfaceRenderNode::Reset()
232 {
233 ResetCurrFrameState();
234 }
235
IsTopSurface() const236 bool RSRcdSurfaceRenderNode::IsTopSurface() const
237 {
238 return rcdExtInfo_.surfaceType == RCDSurfaceType::TOP;
239 }
240
IsBottomSurface() const241 bool RSRcdSurfaceRenderNode::IsBottomSurface() const
242 {
243 return rcdExtInfo_.surfaceType == RCDSurfaceType::BOTTOM;
244 }
245
IsInvalidSurface() const246 bool RSRcdSurfaceRenderNode::IsInvalidSurface() const
247 {
248 return rcdExtInfo_.surfaceType == RCDSurfaceType::INVALID;
249 }
250
GetCldInfo() const251 const CldInfo RSRcdSurfaceRenderNode::GetCldInfo() const
252 {
253 auto renderDrawable = std::static_pointer_cast<DrawableV2::RSRcdSurfaceRenderNodeDrawable>(renderDrawable_);
254 if (!renderDrawable) {
255 return CldInfo();
256 }
257 return renderDrawable->GetCldInfo();
258 }
259 } // namespace Rosen
260 } // namespace OHOS