1 /*
2 * Copyright (c) 2021-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 #include "rs_test_util.h"
16 #include "feature/round_corner_display/rs_rcd_render_listener.h"
17 #include "pipeline/rs_render_node_gc.h"
18
19 namespace OHOS::Rosen {
20 NodeId RSTestUtil::id = 0;
CreateSurfaceNode(const RSSurfaceRenderNodeConfig surfaceConfig)21 std::shared_ptr<RSSurfaceRenderNode> RSTestUtil::CreateSurfaceNode(const RSSurfaceRenderNodeConfig surfaceConfig)
22 {
23 id++;
24 RSSurfaceRenderNodeConfig config;
25 if (surfaceConfig.id != 0) {
26 config = surfaceConfig;
27 } else {
28 config.id = id;
29 config.name += std::to_string(id);
30 }
31 auto rsSurfaceRenderNode = std::make_shared<RSSurfaceRenderNode>(config);
32 csurf = IConsumerSurface::Create(config.name);
33 rsSurfaceRenderNode->GetRSSurfaceHandler()->SetConsumer(csurf);
34 rsSurfaceRenderNode->InitRenderParams();
35 std::weak_ptr<RSSurfaceRenderNode> surfaceRenderNode(rsSurfaceRenderNode);
36 sptr<IBufferConsumerListener> listener = new RSRenderServiceListener(surfaceRenderNode);
37 csurf->RegisterConsumerListener(listener);
38 return rsSurfaceRenderNode;
39 }
40
CreateSurfaceNodeWithBuffer()41 std::shared_ptr<RSSurfaceRenderNode> RSTestUtil::CreateSurfaceNodeWithBuffer()
42 {
43 auto rsSurfaceRenderNode = CreateSurfaceNode();
44 const auto& surfaceConsumer = rsSurfaceRenderNode->GetRSSurfaceHandler()->GetConsumer();
45 auto producer = surfaceConsumer->GetProducer();
46 psurf = Surface::CreateSurfaceAsProducer(producer);
47 psurf->SetQueueSize(1);
48 sptr<SurfaceBuffer> buffer;
49 sptr<SyncFence> requestFence = SyncFence::INVALID_FENCE;
50 [[maybe_unused]] GSError ret = psurf->RequestBuffer(buffer, requestFence, requestConfig);
51 sptr<SyncFence> flushFence = SyncFence::INVALID_FENCE;
52 ret = psurf->FlushBuffer(buffer, flushFence, flushConfig);
53 OHOS::sptr<SurfaceBuffer> cbuffer;
54 Rect damage;
55 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
56 int64_t timestamp = 0;
57 ret = surfaceConsumer->AcquireBuffer(cbuffer, acquireFence, timestamp, damage);
58 auto& surfaceHandler = *rsSurfaceRenderNode->GetRSSurfaceHandler();
59 surfaceHandler.SetBuffer(cbuffer, acquireFence, damage, timestamp);
60 auto drGPUContext = std::make_shared<Drawing::GPUContext>();
61 rsSurfaceRenderNode->SetDrawingGPUContext(drGPUContext.get());
62 return rsSurfaceRenderNode;
63 }
64
CreateRcdNodeWithBuffer()65 std::shared_ptr<RSRcdSurfaceRenderNode> RSTestUtil::CreateRcdNodeWithBuffer()
66 {
67 id++;
68 auto rcdNode = RSRcdSurfaceRenderNode::Create(id, RCDSurfaceType::TOP);
69 csurf = IConsumerSurface::Create("RcdNode");
70 if (csurf == nullptr) {
71 return nullptr;
72 }
73 rcdNode->GetRSSurfaceHandler()->SetConsumer(csurf);
74 sptr<IBufferConsumerListener> listener = new RSRcdRenderListener(rcdNode->GetRSSurfaceHandler());
75 csurf->RegisterConsumerListener(listener);
76 const auto& surfaceConsumer = rcdNode->GetRSSurfaceHandler()->GetConsumer();
77 auto producer = surfaceConsumer->GetProducer();
78 psurf = Surface::CreateSurfaceAsProducer(producer);
79 if (psurf == nullptr) {
80 return nullptr;
81 }
82 psurf->SetQueueSize(1);
83 sptr<SurfaceBuffer> buffer = nullptr;
84 sptr<SyncFence> requestFence = SyncFence::INVALID_FENCE;
85 [[maybe_unused]] GSError ret = psurf->RequestBuffer(buffer, requestFence, requestConfig);
86 sptr<SyncFence> flushFence = SyncFence::INVALID_FENCE;
87 ret = psurf->FlushBuffer(buffer, flushFence, flushConfig);
88 OHOS::sptr<SurfaceBuffer> cbuffer;
89 Rect damage;
90 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
91 int64_t timestamp = 0;
92 ret = surfaceConsumer->AcquireBuffer(cbuffer, acquireFence, timestamp, damage);
93 auto& surfaceHandler = *rcdNode->GetRSSurfaceHandler();
94 surfaceHandler.SetBuffer(cbuffer, acquireFence, damage, timestamp);
95 return rcdNode;
96 }
97
InitRenderNodeGC()98 void RSTestUtil::InitRenderNodeGC()
99 {
100 auto& renderNodeGC = RSRenderNodeGC::Instance();
101 renderNodeGC.nodeBucket_ = std::queue<std::vector<RSRenderNode*>>();
102 renderNodeGC.drawableBucket_ = std::queue<std::vector<DrawableV2::RSRenderNodeDrawableAdapter*>>();
103 auto& memTrack = MemoryTrack::Instance();
104 memTrack.memNodeMap_ = std::unordered_map<NodeId, MemoryInfo>();
105 auto& memorySnapshot = MemorySnapshot::Instance();
106 memorySnapshot.appMemorySnapshots_ = std::unordered_map<pid_t, MemorySnapshotInfo>();
107 }
108 }
109