1 /*
2 * Copyright (c) 2024 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 <gtest/gtest.h>
17 #include <hilog/log.h>
18 #include "common/rs_background_thread.h"
19 #include "ui/rs_canvas_node.h"
20 #include "ui/rs_canvas_drawing_node.h"
21 #include "feature/capture/rs_surface_capture_task_parallel.h"
22 #include "pipeline/render_thread/rs_uni_render_engine.h"
23 #include "pipeline/rs_context.h"
24 #include "pipeline/main_thread/rs_main_thread.h"
25 #include "pipeline/rs_surface_render_node.h"
26 #include "pipeline/rs_test_util.h"
27 #include "feature/capture/rs_capture_pixelmap_manager.h"
28 #include "transaction/rs_interfaces.h"
29 #include "pipeline/rs_uni_render_judgement.h"
30 #include "platform/common/rs_system_properties.h"
31 #include "pipeline/rs_paint_filter_canvas.h"
32 #include "ipc_callbacks/surface_capture_callback_stub.h"
33 #include "pipeline/render_thread/rs_render_engine.h"
34 #include "pipeline/rs_screen_render_node.h"
35 #include "pipeline/rs_logical_display_render_node.h"
36 #include "surface_buffer_impl.h"
37 using namespace testing;
38 using namespace testing::ext;
39
40 namespace OHOS {
41 namespace Rosen {
42 constexpr uint32_t MAX_TIME_WAITING_FOR_CALLBACK = 200;
43 constexpr uint32_t SLEEP_TIME_IN_US = 10000; // 10ms
44 constexpr uint32_t SLEEP_TIME_FOR_PROXY = 100000; // 100ms
45 constexpr uint32_t DEFAULT_WEIGHT = 1260;
46 constexpr uint32_t DEFAULT_HIGHT = 2720;
47
48 class CustomizedSurfaceCapture : public SurfaceCaptureCallback {
49 public:
CustomizedSurfaceCapture()50 CustomizedSurfaceCapture() {}
51
~CustomizedSurfaceCapture()52 ~CustomizedSurfaceCapture() override {}
53
OnSurfaceCapture(std::shared_ptr<Media::PixelMap> pixelmap)54 void OnSurfaceCapture(std::shared_ptr<Media::PixelMap> pixelmap) override
55 {
56 testSuccess = (pixelmap != nullptr);
57 isCallbackCalled_ = true;
58 }
59
OnSurfaceCaptureHDR(std::shared_ptr<Media::PixelMap> pixelmap,std::shared_ptr<Media::PixelMap> pixelMapHDR)60 void OnSurfaceCaptureHDR(std::shared_ptr<Media::PixelMap> pixelmap,
61 std::shared_ptr<Media::PixelMap> pixelMapHDR) override {}
62
IsTestSuccess()63 bool IsTestSuccess()
64 {
65 return testSuccess;
66 }
67
IsCallbackCalled()68 bool IsCallbackCalled()
69 {
70 return isCallbackCalled_;
71 }
72
Reset()73 void Reset()
74 {
75 testSuccess = false;
76 isCallbackCalled_ = false;
77 }
78
79 private:
80 bool testSuccess = false;
81 bool isCallbackCalled_ = false;
82 }; // class CustomizedSurfaceCapture
83
84 class RSSurfaceCaptureCallbackStubMock : public RSSurfaceCaptureCallbackStub {
85 public:
86 RSSurfaceCaptureCallbackStubMock() = default;
87 virtual ~RSSurfaceCaptureCallbackStubMock() = default;
OnSurfaceCapture(NodeId id,const RSSurfaceCaptureConfig & captureConfig,Media::PixelMap * pixelmap,Media::PixelMap * pixelmapHDR=nullptr)88 void OnSurfaceCapture(NodeId id, const RSSurfaceCaptureConfig& captureConfig,
89 Media::PixelMap* pixelmap, Media::PixelMap* pixelmapHDR = nullptr) override {};
90 };
91
92 class SurfaceImplMock : public Drawing::SurfaceImpl {
93 public:
SurfaceImplMock()94 SurfaceImplMock() {};
~SurfaceImplMock()95 ~SurfaceImplMock() override {};
96
GetType() const97 Drawing::AdapterType GetType() const override { return Drawing::AdapterType::DDGR_ADAPTER; };
Bind(const Drawing::Bitmap & bitmap)98 bool Bind(const Drawing::Bitmap& bitmap) override { return true; };
99 #ifdef RS_ENABLE_GPU
Bind(const Drawing::Image & image)100 bool Bind(const Drawing::Image& image) override { return true; };
Bind(const Drawing::FrameBuffer & frameBuffer)101 bool Bind(const Drawing::FrameBuffer& frameBuffer) override { return true; };
102 #endif
GetCanvas() const103 std::shared_ptr<Drawing::Canvas> GetCanvas() const override { return nullptr; };
GetImageSnapshot() const104 std::shared_ptr<Drawing::Image> GetImageSnapshot() const override { return nullptr; };
GetImageSnapshot(const Drawing::RectI & bounds,bool allowRefCache=true) const105 std::shared_ptr<Drawing::Image> GetImageSnapshot(const Drawing::RectI& bounds,
106 bool allowRefCache = true) const override
107 {
108 return nullptr;
109 };
MakeSurface(int width,int height) const110 std::shared_ptr<Drawing::Surface> MakeSurface(int width, int height) const override { return nullptr; };
MakeSurface(const Drawing::ImageInfo & imageInfo) const111 std::shared_ptr<Drawing::Surface> MakeSurface(const Drawing::ImageInfo& imageInfo) const override
112 {
113 return nullptr;
114 };
GetBackendTexture(Drawing::BackendAccess access) const115 Drawing::BackendTexture GetBackendTexture(Drawing::BackendAccess access) const override
116 {
117 return Drawing::BackendTexture(returnValidTexture_);
118 }
FlushAndSubmit(bool syncCpu)119 void FlushAndSubmit(bool syncCpu) override {};
Flush(Drawing::FlushInfo * drawingflushInfo=nullptr)120 Drawing::SemaphoresSubmited Flush(Drawing::FlushInfo *drawingflushInfo = nullptr) override
121 {
122 return Drawing::SemaphoresSubmited::DRAWING_SUBMIT_NO;
123 }
124 #ifdef RS_ENABLE_VK
Wait(int32_t time,const VkSemaphore & semaphore)125 void Wait(int32_t time, const VkSemaphore& semaphore) override {};
SetDrawingArea(const std::vector<Drawing::RectI> & rects)126 void SetDrawingArea(const std::vector<Drawing::RectI>& rects) override {};
ClearDrawingArea()127 void ClearDrawingArea() override {};
128 #endif
SetHeadroom(float headroom)129 void SetHeadroom(float headroom) {};
GetHeadroom() const130 float GetHeadroom() const { return 0.0; };
Width() const131 int Width() const override { return 0; };
Height() const132 int Height() const override { return 0; };
133
134 bool returnValidTexture_ = true;
135 };
136
137 class RSSurfaceCaptureTaskParallelTest : public testing::Test {
138 public:
139 static void SetUpTestCase();
140 static void TearDownTestCase();
141 void SetUp() override;
142 void TearDown() override;
143 bool CheckSurfaceCaptureCallback();
144 static std::shared_ptr<CustomizedSurfaceCapture> surfaceCaptureCb_;
145 static RSInterfaces* rsInterfaces_;
146 static std::shared_ptr<RSSurfaceNode> surfaceNode_;
147 static std::shared_ptr<RSSurfaceNode> CreateSurface(std::string surfaceName);
148 static std::shared_ptr<RSCanvasNode> canvasNode_;
149 };
150
151 RSInterfaces* RSSurfaceCaptureTaskParallelTest::rsInterfaces_ = nullptr;
152 std::shared_ptr<RSSurfaceNode> RSSurfaceCaptureTaskParallelTest::surfaceNode_ = nullptr;
153 std::shared_ptr<CustomizedSurfaceCapture> RSSurfaceCaptureTaskParallelTest::surfaceCaptureCb_ = nullptr;
154 std::shared_ptr<RSCanvasNode> RSSurfaceCaptureTaskParallelTest::canvasNode_ = nullptr;
155
CheckSurfaceCaptureCallback()156 bool RSSurfaceCaptureTaskParallelTest::CheckSurfaceCaptureCallback()
157 {
158 if (surfaceCaptureCb_ == nullptr) {
159 return false;
160 }
161 uint32_t times = 0;
162 do {
163 if (surfaceCaptureCb_->IsCallbackCalled()) {
164 return true;
165 }
166 usleep(SLEEP_TIME_IN_US);
167 ++times;
168 } while (times <= MAX_TIME_WAITING_FOR_CALLBACK);
169 return false;
170 }
171
CreateSurface(std::string surfaceNodeName)172 std::shared_ptr<RSSurfaceNode> RSSurfaceCaptureTaskParallelTest::CreateSurface(std::string surfaceNodeName)
173 {
174 RSSurfaceNodeConfig config;
175 config.SurfaceNodeName = surfaceNodeName;
176 return RSSurfaceNode::Create(config);
177 }
178
SetUpTestCase()179 void RSSurfaceCaptureTaskParallelTest::SetUpTestCase()
180 {
181 RSTestUtil::InitRenderNodeGC();
182 rsInterfaces_ = &(RSInterfaces::GetInstance());
183 if (rsInterfaces_ == nullptr) {
184 std::cout << "rsInterfaces_ is nullptr" << std::endl;
185 return;
186 }
187
188 surfaceNode_ = CreateSurface("SurfaceCaptureTestNode");
189 if (surfaceNode_ == nullptr) {
190 return;
191 }
192 surfaceNode_->SetBounds({0, 0, DEFAULT_WEIGHT, DEFAULT_HIGHT});
193 canvasNode_ = RSCanvasNode::Create();
194 if (canvasNode_ == nullptr) {
195 return;
196 }
197 canvasNode_->SetBounds({0, 0, DEFAULT_WEIGHT, DEFAULT_HIGHT});
198 surfaceNode_->AddChild(canvasNode_, -1);
199 RSTransactionProxy::GetInstance()->FlushImplicitTransaction();
200 usleep(SLEEP_TIME_FOR_PROXY);
201
202 surfaceCaptureCb_ = std::make_shared<CustomizedSurfaceCapture>();
203 if (surfaceCaptureCb_ == nullptr) {
204 return;
205 }
206 }
207
TearDownTestCase()208 void RSSurfaceCaptureTaskParallelTest::TearDownTestCase()
209 {
210 surfaceCaptureCb_->Reset();
211 surfaceCaptureCb_ = nullptr;
212 rsInterfaces_ = nullptr;
213 surfaceNode_ = nullptr;
214 canvasNode_ = nullptr;
215 RSTransactionProxy::GetInstance()->FlushImplicitTransaction();
216 usleep(SLEEP_TIME_FOR_PROXY);
217 }
SetUp()218 void RSSurfaceCaptureTaskParallelTest::SetUp() {}
TearDown()219 void RSSurfaceCaptureTaskParallelTest::TearDown() {}
220
221 /*
222 * @tc.name: CalPixelMapRotation
223 * @tc.desc: function test
224 * @tc.type: FUNC
225 * @tc.require: issueI9PKY5
226 */
227 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CalPixelMapRotation, TestSize.Level2)
228 {
229 RSSurfaceCaptureConfig captureConfig;
230 RSSurfaceCaptureTaskParallel task(0, captureConfig);
231 task.screenCorrection_ = ScreenRotation::ROTATION_90;
232 task.screenRotation_ = ScreenRotation::ROTATION_270;
233 ASSERT_EQ(task.CalPixelMapRotation(), RS_ROTATION_180);
234 }
235
236 /*
237 * @tc.name: SetupGpuContext
238 * @tc.desc: Test RSSurfaceCaptureTaskParallel.SetupGpuContext while gpuContext_ is nullptr
239 * @tc.type: FUNC
240 * @tc.require: issueIAHND9
241 */
242 HWTEST_F(RSSurfaceCaptureTaskParallelTest, SetupGpuContext, TestSize.Level2)
243 {
244 RSSurfaceCaptureConfig captureConfig;
245 RSSurfaceCaptureTaskParallel task(0, captureConfig);
246 if (RSUniRenderJudgement::IsUniRender()) {
247 auto& uniRenderThread = RSUniRenderThread::Instance();
248 ASSERT_EQ(uniRenderThread.uniRenderEngine_, nullptr);
249 uniRenderThread.uniRenderEngine_ = std::make_shared<RSUniRenderEngine>();
250 ASSERT_NE(uniRenderThread.uniRenderEngine_, nullptr);
251 }
252 task.gpuContext_ = nullptr;
253 task.SetupGpuContext();
254 }
255
256 /*
257 * @tc.name: CreatePixelMapBySurfaceNode
258 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreatePixelMapBySurfaceNode with not nullptr
259 * @tc.type: FUNC
260 * @tc.require: issueIAHND9
261 */
262 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreatePixelMapBySurfaceNode, TestSize.Level2)
263 {
264 RSSurfaceCaptureConfig captureConfig;
265 RSSurfaceCaptureTaskParallel task(0, captureConfig);
266 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(0);
267 ASSERT_NE(node, nullptr);
268 const float imgWidth = 1.0f;
269 const float imgHeight = 1.0f;
270 node->GetGravityTranslate(imgWidth, imgHeight);
271 task.surfaceNode_ = node;
272 auto pxiemap = task.CreatePixelMapBySurfaceNode(node, false);
273 EXPECT_EQ(pxiemap, nullptr);
274
275 node->renderProperties_.SetBoundsWidth(1.0f);
276 node->renderProperties_.SetBoundsHeight(1.0f);
277 pxiemap = task.CreatePixelMapBySurfaceNode(node, false);
278 EXPECT_NE(pxiemap, nullptr);
279 pxiemap = task.CreatePixelMapBySurfaceNode(node, true);
280 EXPECT_NE(pxiemap, nullptr);
281 }
282
283 /*
284 * @tc.name: CreatePixelMapByDisplayNode001
285 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreatePixelMapByDisplayNode while node is nullptr
286 * @tc.type: FUNC
287 * @tc.require: issueIAHND9
288 */
289 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreatePixelMapByDisplayNode001, TestSize.Level2)
290 {
291 RSSurfaceCaptureConfig captureConfig;
292 RSSurfaceCaptureTaskParallel task(0, captureConfig);
293 ASSERT_EQ(nullptr, task.CreatePixelMapByDisplayNode(nullptr));
294 }
295
296 /*
297 * @tc.name: CreatePixelMapByDisplayNode002
298 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreatePixelMapByDisplayNode with not nullptr
299 * @tc.type: FUNC
300 * @tc.require: issueIAHND9
301 */
302 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreatePixelMapByDisplayNode002, TestSize.Level2)
303 {
304 RSSurfaceCaptureConfig captureConfig;
305 RSSurfaceCaptureTaskParallel task(0, captureConfig);
306 RSDisplayNodeConfig config;
307 std::shared_ptr<RSLogicalDisplayRenderNode> node = std::make_shared<RSLogicalDisplayRenderNode>(0, config);
308 ASSERT_EQ(nullptr, task.CreatePixelMapByDisplayNode(node));
309 }
310
311 /*
312 * @tc.name: CreatePixelMapByDisplayNode003
313 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreatePixelMapByDisplayNode with pixelmap not nullptr
314 * @tc.type: FUNC
315 * @tc.require: issueIAHND9
316 */
317 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreatePixelMapByDisplayNode003, TestSize.Level2)
318 {
319 RSSurfaceCaptureConfig captureConfig;
320 RSSurfaceCaptureTaskParallel task(0, captureConfig);
321 RSDisplayNodeConfig config;
322 std::shared_ptr<RSLogicalDisplayRenderNode> node = std::make_shared<RSLogicalDisplayRenderNode>(0, config);
323
324 NodeId id = 0;
325 ScreenId screenId = 1;
326 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
327 auto screenNode = std::make_shared<RSScreenRenderNode>(id, screenId, context);
328 ASSERT_NE(screenNode, nullptr);
329 screenNode->AddChild(node);
330 ASSERT_EQ(nullptr, task.CreatePixelMapByDisplayNode(node));
331 ASSERT_EQ(nullptr, task.CreatePixelMapByDisplayNode(node, true));
332 }
333
334 /*
335 * @tc.name: CreateSurface001
336 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateSurface with pixelmap is nullptr
337 * @tc.type: FUNC
338 * @tc.require: issueIAHND9
339 */
340 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateSurface001, TestSize.Level2)
341 {
342 RSSurfaceCaptureConfig captureConfig;
343 RSSurfaceCaptureTaskParallel task(0, captureConfig);
344 std::unique_ptr<Media::PixelMap> pixelmap = nullptr;
345 ASSERT_EQ(nullptr, task.CreateSurface(pixelmap));
346 }
347
348 /*
349 * @tc.name: CreateResources001
350 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateResources: while SurfaceCapture scale is invalid
351 * @tc.type: FUNC
352 * @tc.require: issueIAHND9
353 */
354 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateResources001, TestSize.Level2)
355 {
356 RSSurfaceCaptureConfig captureConfig;
357 captureConfig.scaleX = 0.f;
358 captureConfig.scaleY = 0.f;
359 RSSurfaceCaptureTaskParallel task(0, captureConfig);
360 ASSERT_EQ(false, task.CreateResources());
361 }
362
363 /*
364 * @tc.name: CreateResources002
365 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateResources while node is nullptr
366 * @tc.type: FUNC
367 * @tc.require: issueIAHND9
368 */
369 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateResources002, TestSize.Level2)
370 {
371 RSSurfaceCaptureConfig captureConfig;
372 captureConfig.scaleX = 1.0f;
373 captureConfig.scaleY = 1.0f;
374 RSSurfaceCaptureTaskParallel task(0, captureConfig);
375 ASSERT_EQ(false, task.CreateResources());
376 }
377
378 /*
379 * @tc.name: CreateResources003
380 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateResources with not nullptr
381 * @tc.type: FUNC
382 * @tc.require: issueIAHND9
383 */
384 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateResources003, TestSize.Level2)
385 {
386 RSSurfaceCaptureConfig captureConfig;
387 captureConfig.scaleX = 1.0f;
388 captureConfig.scaleY = 1.0f;
389 captureConfig.useCurWindow = false;
390 RSSurfaceCaptureTaskParallel task(1, captureConfig);
391 ASSERT_EQ(false, task.CreateResources());
392 }
393
394 /*
395 * @tc.name: CreateResources004
396 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateResources with node not nullptr
397 * @tc.type: FUNC
398 * @tc.require: issueIAHND9
399 */
400 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateResources004, TestSize.Level2)
401 {
402 RSSurfaceCaptureConfig captureConfig;
403 captureConfig.scaleX = 1.0f;
404 captureConfig.scaleY = 1.0f;
405 captureConfig.useCurWindow = true;
406
407 NodeId nodeId = 1000123;
408 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(nodeId);
409 node->GetMutableRenderProperties().SetBounds({ 0, 0, 1260, 2720 });
410 ASSERT_NE(node, nullptr);
411 node->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
412 auto mainThread = RSMainThread::Instance();
413 ASSERT_NE(mainThread, nullptr);
414 RSRenderNodeMap& nodeMap = mainThread->GetContext().GetMutableNodeMap();
415 nodeMap.RegisterRenderNode(node);
416
417 node->shouldPaint_ = true;
418 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
419 ASSERT_EQ(true, task.CreateResources());
420 }
421
422 /*
423 * @tc.name: CreateResources005
424 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateResources with node not nullptr
425 * @tc.type: FUNC
426 * @tc.require: issueIAHND9
427 */
428 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateResources005, TestSize.Level2)
429 {
430 RSSurfaceCaptureConfig captureConfig;
431 captureConfig.scaleX = 1.0f;
432 captureConfig.scaleY = 1.0f;
433 captureConfig.useCurWindow = true;
434
435 NodeId nodeId = 1000124;
436 RSDisplayNodeConfig config;
437 std::shared_ptr<RSLogicalDisplayRenderNode> node = std::make_shared<RSLogicalDisplayRenderNode>(nodeId, config);
438 ASSERT_NE(node, nullptr);
439 auto mainThread = RSMainThread::Instance();
440 ASSERT_NE(mainThread, nullptr);
441 RSRenderNodeMap& nodeMap = mainThread->GetContext().GetMutableNodeMap();
442 nodeMap.RegisterRenderNode(node);
443
444 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
445 EXPECT_EQ(false, task.CreateResources());
446
447 captureConfig.isHdrCapture = true;
448 RSSurfaceCaptureTaskParallel task1(nodeId, captureConfig);
449 task1.CreateResources();
450
451 NodeId id = 0;
452 ScreenId screenId = 1;
453 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
454 auto screenNode = std::make_shared<RSScreenRenderNode>(id, screenId, context);
455 ASSERT_NE(screenNode, nullptr);
456
457 node->parent_ = screenNode;
458 RSSurfaceCaptureTaskParallel task2(nodeId, captureConfig);
459 ASSERT_EQ(false, task2.CreateResources());
460
461 RSSurfaceCaptureTaskParallel task3(nodeId, captureConfig);
462 screenNode->CollectHdrStatus(HdrStatus::HDR_VIDEO);
463 ASSERT_EQ(false, task3.CreateResources());
464 }
465
466 /*
467 * @tc.name: Run001
468 * @tc.desc: Test RSSurfaceCaptureTaskParallel.Run while surface is nullptr
469 * @tc.type: FUNC
470 * @tc.require: issueIAIT5Z
471 */
472 HWTEST_F(RSSurfaceCaptureTaskParallelTest, Run001, TestSize.Level2)
473 {
474 NodeId id = 0;
475 RSSurfaceCaptureConfig captureConfig;
476 RSSurfaceCaptureTaskParallel task(id, captureConfig);
477 ASSERT_EQ(nullptr, task.pixelMap_);
478 RSSurfaceCaptureParam captureParam;
479 ASSERT_EQ(false, task.Run(nullptr, captureParam));
480 }
481
482 /*
483 * @tc.name: Run002
484 * @tc.desc: Test RSSurfaceCaptureTaskParallel.Run while surfaceNodeDrawable_ is not nullptr
485 * @tc.type: FUNC
486 * @tc.require: issueIAIT5Z
487 */
488 HWTEST_F(RSSurfaceCaptureTaskParallelTest, Run002, TestSize.Level2)
489 {
490 NodeId id = 0;
491 RSSurfaceCaptureConfig captureConfig;
492 RSSurfaceCaptureTaskParallel task(id, captureConfig);
493 auto node = std::make_shared<RSRenderNode>(id);
494 task.surfaceNodeDrawable_ = std::static_pointer_cast<DrawableV2::RSRenderNodeDrawable>(
495 DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(node));
496 RSSurfaceCaptureParam captureParam;
497 ASSERT_EQ(false, task.Run(nullptr, captureParam));
498 }
499
500 /*
501 * @tc.name: Run003
502 * @tc.desc: Test RSSurfaceCaptureTaskParallel.Run while displayNodeDrawable_ is not nullptr
503 * @tc.type: FUNC
504 * @tc.require: issueIAIT5Z
505 */
506 HWTEST_F(RSSurfaceCaptureTaskParallelTest, Run003, TestSize.Level2)
507 {
508 NodeId id = 0;
509 RSSurfaceCaptureConfig captureConfig;
510 RSSurfaceCaptureTaskParallel task(id, captureConfig);
511 auto node = std::make_shared<RSRenderNode>(id);
512 task.surfaceNodeDrawable_ = nullptr;
513 task.displayNodeDrawable_ = std::static_pointer_cast<DrawableV2::RSRenderNodeDrawable>(
514 DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(node));
515 RSSurfaceCaptureParam captureParam;
516 ASSERT_EQ(false, task.Run(nullptr, captureParam));
517 }
518
519 /*
520 * @tc.name: Run004
521 * @tc.desc: Test RSSurfaceCaptureTaskParallel.Run004, TEST CreateResources
522 * @tc.type: FUNC
523 * @tc.require: issueIAIT5Z
524 */
525 HWTEST_F(RSSurfaceCaptureTaskParallelTest, Run004, TestSize.Level2)
526 {
527 NodeId id = 0;
528 RSSurfaceCaptureConfig captureConfig;
529 RSSurfaceCaptureTaskParallel task(id, captureConfig);
530 task.surfaceNodeDrawable_ = nullptr;
531 task.displayNodeDrawable_ = nullptr;
532 RSSurfaceCaptureParam captureParam;
533 ASSERT_EQ(false, task.Run(nullptr, captureParam));
534
535 auto renderEngine = std::make_shared<RSRenderEngine>();
536 renderEngine->Init();
537 RSUniRenderThread::Instance().uniRenderEngine_ = renderEngine;
538 auto mainThread = RSMainThread::Instance();
539 ASSERT_NE(mainThread, nullptr);
540
541 NodeId nodeId= 1000235;
542 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(nodeId);
543 node->GetMutableRenderProperties().SetBounds({0, 0, 1260, 2720});
544 ASSERT_NE(node, nullptr);
545 node->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
546 RSRenderNodeMap& nodeMap = mainThread->GetContext().GetMutableNodeMap();
547 nodeMap.RegisterRenderNode(node);
548 // define callBack
549
550 RSSurfaceCaptureTaskParallel task1(nodeId, captureConfig);
551 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
552
553 ASSERT_EQ(callback != nullptr, true);
554 bool ret = task1.CreateResources();
555 EXPECT_EQ(ret, true);
556
557 ASSERT_EQ(task1.Run(callback, captureParam), true);
558
559 task1.finalRotationAngle_ = RS_ROTATION_90;
560 ASSERT_EQ(task1.Run(callback, captureParam), true);
561 // Reset
562 nodeMap.UnregisterRenderNode(nodeId);
563 RSUniRenderThread::Instance().uniRenderEngine_ = nullptr;
564 }
565
566 /*
567 * @tc.name: CheckModifiers
568 * @tc.desc: Test CheckModifiers
569 * @tc.type: FUNC
570 * @tc.require:
571 */
572 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CheckModifiers, TestSize.Level2)
573 {
574 auto mainThread = RSMainThread::Instance();
575 ASSERT_NE(mainThread, nullptr);
576 mainThread->nodeTreeDumpTasks_.clear();
577 NodeId nodeId = 1;
578 std::shared_ptr<RSSurfaceRenderNode> node = std::make_shared<RSSurfaceRenderNode>(nodeId);
579 ASSERT_NE(node, nullptr);
580 node->nodeType_ = RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
581 RSRenderNodeMap& nodeMap = mainThread->GetContext().GetMutableNodeMap();
582 nodeMap.RegisterRenderNode(node);
583 ASSERT_TRUE(mainThread->IsOcclusionNodesNeedSync(nodeId, true));
584 mainThread->GetContext().AddPendingSyncNode(node);
585 RSSurfaceCaptureConfig captureConfig;
586 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
587 captureConfig.useCurWindow = true;
588 task.CheckModifiers(nodeId, captureConfig.useCurWindow);
589 }
590
591 /*
592 * @tc.name: CreateClientPixelMap
593 * @tc.desc: Test CreateClientPixelMap
594 * @tc.type: FUNC
595 * @tc.require:
596 */
597 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateClientPixelMap, TestSize.Level2)
598 {
599 // TEST0: vail Capture Size and Alloc Share mem/Heap mem
600 {
601 Drawing::Rect rect = {0, 0 ,1260, 2720};
602 RSSurfaceCaptureConfig captureConfig;
603 auto pixelMap = RSCapturePixelMapManager::GetClientCapturePixelMap(rect, captureConfig,
604 UniRenderEnabledType::UNI_RENDER_ENABLED_FOR_ALL);
605 EXPECT_EQ(pixelMap != nullptr, true);
606 //Heap Mem
607 auto pixelMap1 = RSCapturePixelMapManager::CreatePixelMap(rect, captureConfig);
608 bool ret = RSCapturePixelMapManager::AttachHeapMem(pixelMap1);
609 EXPECT_EQ(ret, true);
610 }
611
612 // TEST1:: Vail Caputre size and use DMA
613 {
614 Drawing::Rect rect = {0, 0, 1260, 2720};
615 RSSurfaceCaptureConfig captureConfig;
616 captureConfig.useDma = true;
617 auto pixelMap = RSCapturePixelMapManager::GetClientCapturePixelMap(rect, captureConfig,
618 UniRenderEnabledType::UNI_RENDER_ENABLED_FOR_ALL);
619 EXPECT_EQ(pixelMap != nullptr, true);
620 }
621
622 // TEST2:: InVaild scalex01
623 {
624 Drawing::Rect rect = {0, 0, 1260, 2720};
625 RSSurfaceCaptureConfig captureConfig;
626 captureConfig.scaleX = 2;
627 auto pixelMap = RSCapturePixelMapManager::GetClientCapturePixelMap(rect, captureConfig,
628 UniRenderEnabledType::UNI_RENDER_ENABLED_FOR_ALL);
629 EXPECT_EQ(pixelMap == nullptr, true);
630 }
631
632 // TESt: invauld scalex01
633
634 {
635 Drawing::Rect rect = {0, 0 ,1260, 2720};
636 RSSurfaceCaptureConfig captureConfig;
637 captureConfig.scaleX = 0.0;
638 auto pixelMap = RSCapturePixelMapManager::GetClientCapturePixelMap(rect, captureConfig,
639 UniRenderEnabledType::UNI_RENDER_ENABLED_FOR_ALL);
640 EXPECT_EQ(pixelMap == nullptr, true);
641 }
642 }
643
644 /*
645 * @tc.name: TestSurfaceCaputreIt
646 * @tc.desc: Test TestSurfaceCaputreIt
647 * @tc.type: FUNC
648 * @tc.require:
649 */
650 HWTEST_F(RSSurfaceCaptureTaskParallelTest, TestSurfaceCaputreIt, TestSize.Level2)
651 {
652 if (RSUniRenderJudgement::IsUniRender()) {
653 RSSurfaceCaptureConfig captureConfig;
654 captureConfig.useCurWindow = true;
655
656 bool ret = rsInterfaces_->TakeSurfaceCapture(surfaceNode_, surfaceCaptureCb_);
657 EXPECT_EQ(ret, true);
658 EXPECT_EQ(CheckSurfaceCaptureCallback(), true);
659 EXPECT_EQ(surfaceCaptureCb_->IsTestSuccess(), true);
660 // DMA Surface Cpautre
661 surfaceCaptureCb_->Reset();
662 captureConfig.useDma = true;
663 ret = rsInterfaces_->TakeSurfaceCapture(surfaceNode_, surfaceCaptureCb_, captureConfig);
664 EXPECT_EQ(ret, true);
665 EXPECT_EQ(CheckSurfaceCaptureCallback(), true);
666 EXPECT_EQ(surfaceCaptureCb_->IsTestSuccess(), true);
667 // No DMA Canvas Node
668 surfaceCaptureCb_->Reset();
669 ret = rsInterfaces_->TakeSurfaceCaptureForUI(surfaceNode_, surfaceCaptureCb_, 0.5, 0.5);
670 EXPECT_EQ(ret, true);
671 EXPECT_EQ(CheckSurfaceCaptureCallback(), true);
672 EXPECT_EQ(surfaceCaptureCb_->IsTestSuccess(), true);
673 // DMA Canvas Node
674 surfaceCaptureCb_->Reset();
675 captureConfig.useDma = true;
676 ret = rsInterfaces_->TakeSurfaceCaptureForUI(surfaceNode_, surfaceCaptureCb_, 0.5, 0.5);
677 EXPECT_EQ(ret, true);
678 EXPECT_EQ(CheckSurfaceCaptureCallback(), true);
679 EXPECT_EQ(surfaceCaptureCb_->IsTestSuccess(), true);
680 }
681 }
682
683 /*
684 * @tc.name: CaptureDisplayNode
685 * @tc.desc: Test CaptureDisplayNode
686 * @tc.type: FUNC
687 * @tc.require: #ICQ74B
688 */
689 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CaptureDisplayNode, TestSize.Level2)
690 {
691 NodeId id = 0;
692 RSSurfaceCaptureConfig captureConfig;
693 RSSurfaceCaptureParam captureParam;
694 auto type = RSPaintFilterCanvas::ScreenshotType::SDR_SCREENSHOT;
695 Drawing::Canvas drawingCanvas;
696 RSPaintFilterCanvas canvas(&drawingCanvas);
697 RSSurfaceCaptureTaskParallel task(id, captureConfig);
698 auto node = std::make_shared<RSRenderNode>(id);
699 auto drawable = std::static_pointer_cast<DrawableV2::RSRenderNodeDrawable>(
700 DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(node));
701 ASSERT_NE(drawable, nullptr);
702 RSRenderThreadParamsManager::Instance().renderThreadParams_ = nullptr;
703 task.CaptureDisplayNode(*drawable, canvas, captureParam, type);
704 RSRenderThreadParamsManager::Instance().renderThreadParams_ = std::make_unique<RSRenderThreadParams>();
705 auto& uniParams = RSUniRenderThread::Instance().GetRSRenderThreadParams();
706 ASSERT_NE(uniParams, nullptr);
707 bool secExemption = uniParams == nullptr ? false : uniParams->GetSecExemption();
708 captureParam.secExemption = false;
709 task.CaptureDisplayNode(*drawable, canvas, captureParam, type);
710 bool secExemption1 = uniParams == nullptr ? false : uniParams->GetSecExemption();
711 ASSERT_EQ(secExemption, secExemption1);
712
713 captureParam.secExemption = true;
714 task.CaptureDisplayNode(*drawable, canvas, captureParam, type);
715 bool secExemption2 = uniParams == nullptr ? false : uniParams->GetSecExemption();
716 ASSERT_EQ(secExemption, secExemption2);
717 }
718
719 /*
720 * @tc.name: Capture001
721 * @tc.desc: Test RSSurfaceCaptureTaskParallel::Capture
722 * @tc.type: FUNC
723 * @tc.require: issueIAIT5Z
724 */
725 HWTEST_F(RSSurfaceCaptureTaskParallelTest, Capture001, TestSize.Level0)
726 {
727 auto renderEngine = std::make_shared<RSRenderEngine>();
728 renderEngine->Init();
729 RSUniRenderThread::Instance().uniRenderEngine_ = renderEngine;
730 auto mainThread = RSMainThread::Instance();
731 ASSERT_NE(mainThread, nullptr);
732
733 NodeId nodeId = 111;
734 RSDisplayNodeConfig config;
735 auto node = std::make_shared<RSLogicalDisplayRenderNode>(nodeId, config);
736 ASSERT_NE(node, nullptr);
737 NodeId id = 0;
738 ScreenId screenId = 1;
739 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
740 auto screenNode = std::make_shared<RSScreenRenderNode>(id, screenId, context);
741 ASSERT_NE(screenNode, nullptr);
742 screenNode->CollectHdrStatus(HdrStatus::HDR_VIDEO);
743 node->parent_ = screenNode;
744 // set screen
745 auto virtualScreenId =
746 impl::RSScreenManager::GetInstance()->CreateVirtualScreen("virtualDisplayTest", 480, 320, nullptr);
747 node->screenId_ = virtualScreenId;
748 RSRenderNodeMap& nodeMap = mainThread->GetContext().GetMutableNodeMap();
749 nodeMap.RegisterRenderNode(node);
750
751 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
752 ASSERT_EQ(callback != nullptr, true);
753
754 RSSurfaceCaptureParam captureParam;
755 captureParam.id = nodeId;
756 captureParam.config.isHdrCapture = true;
757 captureParam.config.mainScreenRect = {0.f, 0.f, 480.f, 320.f};
758 RSSurfaceCaptureTaskParallel::Capture(callback, captureParam);
759
760 // Reset
761 impl::RSScreenManager::GetInstance()->RemoveVirtualScreen(virtualScreenId);
762 nodeMap.UnregisterRenderNode(nodeId);
763 RSUniRenderThread::Instance().uniRenderEngine_ = nullptr;
764 }
765
766 /*
767 * @tc.name: Capture002
768 * @tc.desc: Test RSSurfaceCaptureTaskParallel::Capture
769 * @tc.type: FUNC
770 * @tc.require: issueIAIT5Z
771 */
772 HWTEST_F(RSSurfaceCaptureTaskParallelTest, Capture002, TestSize.Level0)
773 {
774 auto renderEngine = std::make_shared<RSRenderEngine>();
775 renderEngine->Init();
776 RSUniRenderThread::Instance().uniRenderEngine_ = renderEngine;
777 auto mainThread = RSMainThread::Instance();
778 ASSERT_NE(mainThread, nullptr);
779
780 NodeId nodeId = 111;
781 RSDisplayNodeConfig config;
782 auto node = std::make_shared<RSLogicalDisplayRenderNode>(nodeId, config);
783 ASSERT_NE(node, nullptr);
784 // set screen
785 auto virtualScreenId =
786 impl::RSScreenManager::GetInstance()->CreateVirtualScreen("virtualDisplayTest", 480, 320, nullptr);
787 node->screenId_ = virtualScreenId;
788 RSRenderNodeMap& nodeMap = mainThread->GetContext().GetMutableNodeMap();
789 nodeMap.RegisterRenderNode(node);
790
791 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
792 ASSERT_EQ(callback != nullptr, true);
793
794 RSSurfaceCaptureParam captureParam;
795 captureParam.id = nodeId;
796 captureParam.config.isHdrCapture = true;
797 captureParam.config.mainScreenRect = {0.f, 0.f, 480.f, 320.f};
798 RSSurfaceCaptureTaskParallel::Capture(callback, captureParam);
799
800 // Reset
801 impl::RSScreenManager::GetInstance()->RemoveVirtualScreen(virtualScreenId);
802 nodeMap.UnregisterRenderNode(nodeId);
803 RSUniRenderThread::Instance().uniRenderEngine_ = nullptr;
804 }
805
806 /*
807 * @tc.name: Capture003
808 * @tc.desc: Test RSSurfaceCaptureTaskParallel::Capture
809 * @tc.type: FUNC
810 * @tc.require: issueIAIT5Z
811 */
812 HWTEST_F(RSSurfaceCaptureTaskParallelTest, Capture003, TestSize.Level0)
813 {
814 auto renderEngine = std::make_shared<RSRenderEngine>();
815 renderEngine->Init();
816 RSUniRenderThread::Instance().uniRenderEngine_ = renderEngine;
817
818 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
819 ASSERT_EQ(callback != nullptr, true);
820
821 RSSurfaceCaptureConfig captureConfig;
822 captureConfig.scaleX = 1.0f;
823 captureConfig.scaleY = 1.0f;
824 captureConfig.useCurWindow = true;
825
826 NodeId nodeId = 1000124;
827 RSDisplayNodeConfig config;
828 std::shared_ptr<RSLogicalDisplayRenderNode> node = std::make_shared<RSLogicalDisplayRenderNode>(nodeId, config);
829 ASSERT_NE(node, nullptr);
830 auto mainThread = RSMainThread::Instance();
831 ASSERT_NE(mainThread, nullptr);
832 RSRenderNodeMap& nodeMap = mainThread->GetContext().GetMutableNodeMap();
833 nodeMap.RegisterRenderNode(node);
834 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
835 captureConfig.isHdrCapture = true;
836 NodeId id = 0;
837 ScreenId screenId = 1;
838 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
839 auto screenNode = std::make_shared<RSScreenRenderNode>(id, screenId, context);
840 ASSERT_NE(screenNode, nullptr);
841 node->parent_ = screenNode;
842 screenNode->CollectHdrStatus(HdrStatus::HDR_VIDEO);
843
844 RSSurfaceCaptureParam captureParam;
845 captureParam.id = nodeId;
846 captureParam.config = captureConfig;
847 RSSurfaceCaptureTaskParallel::Capture(callback, captureParam);
848
849 // Reset
850 nodeMap.UnregisterRenderNode(nodeId);
851 RSUniRenderThread::Instance().uniRenderEngine_ = nullptr;
852 }
853
854 /*
855 * @tc.name: RunHDR001
856 * @tc.desc: Test RSSurfaceCaptureTaskParallel.RunHDR002, TEST RunHDR
857 * @tc.type: FUNC
858 * @tc.require: issueIAIT5Z
859 */
860 HWTEST_F(RSSurfaceCaptureTaskParallelTest, RunHDR001, TestSize.Level2)
861 {
862 auto renderEngine = std::make_shared<RSRenderEngine>();
863 renderEngine->Init();
864 RSUniRenderThread::Instance().uniRenderEngine_ = renderEngine;
865 auto mainThread = RSMainThread::Instance();
866 ASSERT_NE(mainThread, nullptr);
867
868 NodeId nodeId = 111;
869 RSDisplayNodeConfig config;
870 auto node = std::make_shared<RSLogicalDisplayRenderNode>(nodeId, config);
871 ASSERT_NE(node, nullptr);
872 NodeId id = 0;
873 ScreenId screenId = 1;
874 std::shared_ptr<RSContext> context = std::make_shared<RSContext>();
875 auto screenNode = std::make_shared<RSScreenRenderNode>(id, screenId, context);
876 ASSERT_NE(screenNode, nullptr);
877 screenNode->CollectHdrStatus(HdrStatus::HDR_VIDEO);
878 node->parent_ = screenNode;
879 // set screen
880 auto virtualScreenId =
881 impl::RSScreenManager::GetInstance()->CreateVirtualScreen("virtualDisplayTest", 480, 320, nullptr);
882 node->screenId_ = virtualScreenId;
883 RSRenderNodeMap& nodeMap = mainThread->GetContext().GetMutableNodeMap();
884 nodeMap.RegisterRenderNode(node);
885
886 RSSurfaceCaptureConfig captureConfig;
887 captureConfig.isHdrCapture = true;
888 captureConfig.mainScreenRect = {0.f, 0.f, 480.f, 320.f};
889 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
890 bool ret = task.CreateResources();
891 EXPECT_EQ(ret, false);
892
893 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
894 ASSERT_EQ(callback != nullptr, true);
895 RSSurfaceCaptureParam captureParam;
896 captureParam.id = nodeId;
897 captureParam.config.isHdrCapture = true;
898 captureParam.config.mainScreenRect = {0.f, 0.f, 480.f, 320.f};
899 ret = task.RunHDR(callback, captureParam);
900 EXPECT_EQ(ret, false);
901
902 task.finalRotationAngle_ = RS_ROTATION_90;
903 ret = task.RunHDR(callback, captureParam);
904 EXPECT_EQ(ret, false);
905
906 // Reset
907 impl::RSScreenManager::GetInstance()->RemoveVirtualScreen(virtualScreenId);
908 nodeMap.UnregisterRenderNode(nodeId);
909 RSUniRenderThread::Instance().uniRenderEngine_ = nullptr;
910 }
911
912 /*
913 * @tc.name: RunHDR002
914 * @tc.desc: Test RSSurfaceCaptureTaskParallel.RunHDR002, TEST RunHDR
915 * @tc.type: FUNC
916 * @tc.require: issueIAIT5Z
917 */
918 HWTEST_F(RSSurfaceCaptureTaskParallelTest, RunHDR002, TestSize.Level2)
919 {
920 NodeId nodeId = 111;
921 RSSurfaceCaptureConfig captureConfig;
922 captureConfig.isHdrCapture = true;
923 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
924
925 RSSurfaceCaptureParam captureParam;
926 captureParam.config.isHdrCapture = true;
927 task.useScreenShotWithHDR_ = false;
928 EXPECT_EQ(task.RunHDR(nullptr, captureParam), false);
929 task.useScreenShotWithHDR_ = true;
930 EXPECT_EQ(task.RunHDR(nullptr, captureParam), false);
931 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
932 ASSERT_EQ(callback != nullptr, true);
933 EXPECT_EQ(task.RunHDR(callback, captureParam), false);
934 }
935
936 /*
937 * @tc.name: RunHDR003
938 * @tc.desc: Test RSSurfaceCaptureTaskParallel.RunHDR003, TEST RunHDR
939 * @tc.type: FUNC
940 * @tc.require: issueIAIT5Z
941 */
942 HWTEST_F(RSSurfaceCaptureTaskParallelTest, RunHDR003, TestSize.Level2)
943 {
944 NodeId nodeId = 111;
945 RSSurfaceCaptureConfig captureConfig;
946 captureConfig.isHdrCapture = true;
947 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
948 auto node = std::make_shared<RSRenderNode>(nodeId);
949
950 RSSurfaceCaptureParam captureParam;
951 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
952 ASSERT_NE(callback, nullptr);
953 task.useScreenShotWithHDR_ = true;
954
955 Media::InitializationOptions opts;
956 opts.size.width = 480;
957 opts.size.height = 320;
958 task.pixelMap_ = Media::PixelMap::Create(opts);
959 task.pixelMapHDR_ = Media::PixelMap::Create(opts);
960 Media::ImageInfo imageInfo;
961 // 200, 300 means size
962 imageInfo.size.width = 200;
963 imageInfo.size.height = 300;
964 imageInfo.pixelFormat = Media::PixelFormat::ASTC_4x4;
965 imageInfo.colorSpace = Media::ColorSpace::SRGB;
966 task.pixelMap_->SetImageInfo(imageInfo);
967 task.pixelMapHDR_->SetImageInfo(imageInfo);
968
969 // 200 means rowDataSize
970 int32_t rowDataSize = 200;
971 // 300 means height
972 uint32_t bufferSize = rowDataSize * 300;
973 void *buffer = malloc(bufferSize);
974 char *ch = static_cast<char *>(buffer);
975 for (unsigned int i = 0; i < bufferSize; i++) {
976 *(ch++) = (char)i;
977 }
978
979 task.pixelMap_->data_ = static_cast<uint8_t *>(buffer);
980 EXPECT_TRUE(task.pixelMap_->data_ != nullptr);
981
982 task.captureConfig_.mainScreenRect = {0.f, 0.f, 480.f, 320.f};
983 task.captureConfig_.isHdrCapture = true;
984 task.displayNodeDrawable_ = std::static_pointer_cast<DrawableV2::RSRenderNodeDrawable>(
985 DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(node));
986 EXPECT_EQ(task.RunHDR(callback, captureParam), false);
987
988 void *bufferHDR = malloc(bufferSize);
989 char *ch1 = static_cast<char *>(bufferHDR);
990 for (unsigned int i = 0; i < bufferSize; i++) {
991 *(ch1++) = (char)i;
992 }
993 task.pixelMapHDR_->data_ = static_cast<uint8_t *>(bufferHDR);
994 EXPECT_TRUE(task.pixelMapHDR_->data_ != nullptr);
995 EXPECT_EQ(task.RunHDR(callback, captureParam), false);
996 }
997
998 #ifdef RS_ENABLE_UNI_RENDER
999 /*
1000 * @tc.name: CreateSurfaceSyncCopyTask001
1001 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateSurfaceSyncCopyTask
1002 * @tc.type: FUNC
1003 * @tc.require: issueIAIT5Z
1004 */
1005 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateSurfaceSyncCopyTask001, TestSize.Level2)
1006 {
1007 NodeId nodeId = 111;
1008 RSSurfaceCaptureConfig captureConfig;
1009 captureConfig.isHdrCapture = true;
1010 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
1011
1012 Media::InitializationOptions opts;
1013 opts.size.width = 480;
1014 opts.size.height = 320;
1015 std::unique_ptr<Media::PixelMap> pixelmap = Media::PixelMap::Create(opts);
1016 ASSERT_NE(pixelmap, nullptr);
1017 auto address = const_cast<uint32_t*>(pixelmap->GetPixel32(0, 0));
1018 ASSERT_NE(address, nullptr);
1019 Drawing::ImageInfo info { pixelmap->GetWidth(), pixelmap->GetHeight(), Drawing::ColorType::COLORTYPE_RGBA_8888,
1020 Drawing::AlphaType::ALPHATYPE_PREMUL };
1021 auto surface = Drawing::Surface::MakeRasterDirect(info, address, pixelmap->GetRowBytes());
1022 ASSERT_NE(surface, nullptr);
1023 std::shared_ptr<Drawing::SurfaceImpl> impl = std::make_shared<SurfaceImplMock>();
1024 surface->impl_ = impl;
1025 Drawing::BackendTexture backendTexture = surface->GetBackendTexture();
1026 EXPECT_TRUE(backendTexture.IsValid());
1027 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
1028 auto copyTask = task.CreateSurfaceSyncCopyTask(surface, std::move(pixelmap), nodeId, captureConfig, callback, 0);
1029 EXPECT_NE(copyTask, nullptr);
1030 copyTask();
1031 copyTask = task.CreateSurfaceSyncCopyTask(surface, std::move(pixelmap), nodeId, captureConfig, callback, 1);
1032 EXPECT_NE(copyTask, nullptr);
1033 copyTask();
1034 }
1035
1036 /*
1037 * @tc.name: CreateSurfaceSyncCopyTaskWithDoublePixelMap001
1038 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateSurfaceSyncCopyTaskWithDoublePixelMap
1039 * @tc.type: FUNC
1040 * @tc.require: issueIAIT5Z
1041 */
1042 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateSurfaceSyncCopyTaskWithDoublePixelMap001, TestSize.Level2)
1043 {
1044 NodeId nodeId = 111;
1045 RSSurfaceCaptureConfig captureConfig;
1046 captureConfig.isHdrCapture = true;
1047 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
1048
1049 task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(nullptr, nullptr, nullptr, nullptr, nodeId, captureConfig,
1050 nullptr, 0);
1051
1052 Media::InitializationOptions opts;
1053 opts.size.width = 480;
1054 opts.size.height = 320;
1055 std::unique_ptr<Media::PixelMap> pixelmap = Media::PixelMap::Create(opts);
1056 ASSERT_NE(pixelmap, nullptr);
1057 auto address = const_cast<uint32_t*>(pixelmap->GetPixel32(0, 0));
1058 ASSERT_NE(address, nullptr);
1059 Drawing::ImageInfo info { pixelmap->GetWidth(), pixelmap->GetHeight(), Drawing::ColorType::COLORTYPE_RGBA_8888,
1060 Drawing::AlphaType::ALPHATYPE_PREMUL };
1061 auto surface = Drawing::Surface::MakeRasterDirect(info, address, pixelmap->GetRowBytes());
1062 auto copyTask = task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(surface, std::move(pixelmap), nullptr, nullptr,
1063 nodeId, captureConfig, nullptr, 0);
1064 EXPECT_EQ(copyTask, nullptr);
1065 }
1066
1067 /*
1068 * @tc.name: CreateSurfaceSyncCopyTaskWithDoublePixelMap002
1069 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateSurfaceSyncCopyTaskWithDoublePixelMap
1070 * @tc.type: FUNC
1071 * @tc.require: issueIAIT5Z
1072 */
1073 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateSurfaceSyncCopyTaskWithDoublePixelMap002, TestSize.Level2)
1074 {
1075 NodeId nodeId = 111;
1076 RSSurfaceCaptureConfig captureConfig;
1077 captureConfig.isHdrCapture = true;
1078 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
1079
1080 Media::InitializationOptions opts;
1081 opts.size.width = 480;
1082 opts.size.height = 320;
1083 std::unique_ptr<Media::PixelMap> pixelmap = Media::PixelMap::Create(opts);
1084 ASSERT_NE(pixelmap, nullptr);
1085 auto address = const_cast<uint32_t*>(pixelmap->GetPixel32(0, 0));
1086 ASSERT_NE(address, nullptr);
1087 Drawing::ImageInfo info { pixelmap->GetWidth(), pixelmap->GetHeight(), Drawing::ColorType::COLORTYPE_RGBA_8888,
1088 Drawing::AlphaType::ALPHATYPE_PREMUL };
1089 auto surface = Drawing::Surface::MakeRasterDirect(info, address, pixelmap->GetRowBytes());
1090 std::shared_ptr<Drawing::SurfaceImpl> impl = std::make_shared<SurfaceImplMock>();
1091 surface->impl_ = impl;
1092
1093 Media::InitializationOptions optsHDR;
1094 optsHDR.size.width = 480;
1095 optsHDR.size.height = 320;
1096 std::unique_ptr<Media::PixelMap> pixelmapHDR = Media::PixelMap::Create(optsHDR);
1097 ASSERT_NE(pixelmapHDR, nullptr);
1098 auto addressHDR = const_cast<uint32_t*>(pixelmapHDR->GetPixel32(0, 0));
1099 ASSERT_NE(addressHDR, nullptr);
1100 Drawing::ImageInfo infoHDR { pixelmapHDR->GetWidth(), pixelmapHDR->GetHeight(),
1101 Drawing::ColorType::COLORTYPE_RGBA_8888, Drawing::AlphaType::ALPHATYPE_PREMUL };
1102 auto surfaceHDR = Drawing::Surface::MakeRasterDirect(infoHDR, addressHDR, pixelmapHDR->GetRowBytes());
1103 std::shared_ptr<Drawing::SurfaceImpl> implHDR = std::make_shared<SurfaceImplMock>();
1104 surfaceHDR->impl_ = implHDR;
1105
1106 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
1107
1108 auto copyTask = task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(surface, nullptr, surfaceHDR,
1109 nullptr, nodeId, captureConfig, callback, 0);
1110 EXPECT_NE(copyTask, nullptr);
1111 copyTask();
1112 copyTask = task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(surface, std::move(pixelmap), surfaceHDR,
1113 nullptr, nodeId, captureConfig, callback, 0);
1114 EXPECT_NE(copyTask, nullptr);
1115 copyTask();
1116 delete callback;
1117 }
1118
1119 /*
1120 * @tc.name: CreateSurfaceSyncCopyTaskWithDoublePixelMap003
1121 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateSurfaceSyncCopyTaskWithDoublePixelMap
1122 * @tc.type: FUNC
1123 * @tc.require: issueIAIT5Z
1124 */
1125 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateSurfaceSyncCopyTaskWithDoublePixelMap003, TestSize.Level2)
1126 {
1127 NodeId nodeId = 111;
1128 RSSurfaceCaptureConfig captureConfig;
1129 captureConfig.isHdrCapture = true;
1130 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
1131
1132 task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(nullptr, nullptr, nullptr, nullptr, nodeId, captureConfig,
1133 nullptr, 0);
1134
1135 Media::InitializationOptions opts;
1136 opts.size.width = 480;
1137 opts.size.height = 320;
1138 std::unique_ptr<Media::PixelMap> pixelmap = Media::PixelMap::Create(opts);
1139 ASSERT_NE(pixelmap, nullptr);
1140 auto address = const_cast<uint32_t*>(pixelmap->GetPixel32(0, 0));
1141 ASSERT_NE(address, nullptr);
1142 Drawing::ImageInfo info { pixelmap->GetWidth(), pixelmap->GetHeight(), Drawing::ColorType::COLORTYPE_RGBA_8888,
1143 Drawing::AlphaType::ALPHATYPE_PREMUL };
1144 auto surface = Drawing::Surface::MakeRasterDirect(info, address, pixelmap->GetRowBytes());
1145 std::shared_ptr<Drawing::SurfaceImpl> impl = std::make_shared<SurfaceImplMock>();
1146 surface->impl_ = impl;
1147
1148 Media::InitializationOptions optsHDR;
1149 optsHDR.size.width = 480;
1150 optsHDR.size.height = 320;
1151 std::unique_ptr<Media::PixelMap> pixelmapHDR = Media::PixelMap::Create(optsHDR);
1152 ASSERT_NE(pixelmapHDR, nullptr);
1153 auto addressHDR = const_cast<uint32_t*>(pixelmapHDR->GetPixel32(0, 0));
1154 ASSERT_NE(addressHDR, nullptr);
1155 Drawing::ImageInfo infoHDR { pixelmapHDR->GetWidth(), pixelmapHDR->GetHeight(),
1156 Drawing::ColorType::COLORTYPE_RGBA_8888, Drawing::AlphaType::ALPHATYPE_PREMUL };
1157 auto surfaceHDR = Drawing::Surface::MakeRasterDirect(infoHDR, addressHDR, pixelmapHDR->GetRowBytes());
1158 std::shared_ptr<Drawing::SurfaceImpl> implHDR = std::make_shared<SurfaceImplMock>();
1159 surfaceHDR->impl_ = implHDR;
1160
1161 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
1162
1163 auto copyTask = task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(surface, std::move(pixelmap), surfaceHDR,
1164 std::move(pixelmapHDR), nodeId, captureConfig, callback, 0);
1165 EXPECT_NE(copyTask, nullptr);
1166 copyTask();
1167 delete callback;
1168 }
1169
1170 /*
1171 * @tc.name: CreateSurfaceSyncCopyTaskWithDoublePixelMap004
1172 * @tc.desc: Test RSSurfaceCaptureTaskParallel.CreateSurfaceSyncCopyTaskWithDoublePixelMap
1173 * @tc.type: FUNC
1174 * @tc.require: issueIAIT5Z
1175 */
1176 HWTEST_F(RSSurfaceCaptureTaskParallelTest, CreateSurfaceSyncCopyTaskWithDoublePixelMap004, TestSize.Level2)
1177 {
1178 NodeId nodeId = 111;
1179 RSSurfaceCaptureConfig captureConfig;
1180 captureConfig.isHdrCapture = true;
1181 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
1182
1183 Media::InitializationOptions opts;
1184 opts.size.width = 480;
1185 opts.size.height = 320;
1186 std::unique_ptr<Media::PixelMap> pixelmap = Media::PixelMap::Create(opts);
1187 ASSERT_NE(pixelmap, nullptr);
1188 auto address = const_cast<uint32_t*>(pixelmap->GetPixel32(0, 0));
1189 ASSERT_NE(address, nullptr);
1190 Drawing::ImageInfo info { pixelmap->GetWidth(), pixelmap->GetHeight(), Drawing::ColorType::COLORTYPE_RGBA_8888,
1191 Drawing::AlphaType::ALPHATYPE_PREMUL };
1192 auto surface = Drawing::Surface::MakeRasterDirect(info, address, pixelmap->GetRowBytes());
1193 std::shared_ptr<SurfaceImplMock> impl = std::make_shared<SurfaceImplMock>();
1194
1195 surface->impl_ = impl;
1196 Media::InitializationOptions optsHDR;
1197 optsHDR.size.width = 480;
1198 optsHDR.size.height = 320;
1199 std::unique_ptr<Media::PixelMap> pixelmapHDR = Media::PixelMap::Create(optsHDR);
1200 ASSERT_NE(pixelmapHDR, nullptr);
1201 auto addressHDR = const_cast<uint32_t*>(pixelmapHDR->GetPixel32(0, 0));
1202 ASSERT_NE(addressHDR, nullptr);
1203 Drawing::ImageInfo infoHDR { pixelmapHDR->GetWidth(), pixelmapHDR->GetHeight(),
1204 Drawing::ColorType::COLORTYPE_RGBA_8888, Drawing::AlphaType::ALPHATYPE_PREMUL };
1205 auto surfaceHDR = Drawing::Surface::MakeRasterDirect(infoHDR, addressHDR, pixelmapHDR->GetRowBytes());
1206 std::shared_ptr<SurfaceImplMock> implHDR = std::make_shared<SurfaceImplMock>();
1207 surfaceHDR->impl_ = implHDR;
1208
1209 sptr<RSISurfaceCaptureCallback> callback = new RSSurfaceCaptureCallbackStubMock();
1210
1211 impl->returnValidTexture_ = false;
1212 implHDR->returnValidTexture_ = false;
1213 auto copyTask = task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(surface, nullptr, surfaceHDR, nullptr, nodeId,
1214 captureConfig, callback, 0);
1215
1216 impl->returnValidTexture_ = true;
1217 implHDR->returnValidTexture_ = false;
1218 copyTask = task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(surface, nullptr, surfaceHDR, nullptr, nodeId,
1219 captureConfig, callback, 0);
1220
1221 impl->returnValidTexture_ = true;
1222 implHDR->returnValidTexture_ = true;
1223 copyTask = task.CreateSurfaceSyncCopyTaskWithDoublePixelMap(surface, nullptr, surfaceHDR, nullptr, nodeId,
1224 captureConfig, callback, 0);
1225
1226 EXPECT_NE(copyTask, nullptr);
1227 copyTask();
1228 delete callback;
1229 }
1230
1231 /*
1232 * @tc.name: PixelMapCopy001
1233 * @tc.desc: Test RSSurfaceCaptureTaskParallel.PixelMapCopy
1234 * @tc.type: FUNC
1235 * @tc.require: issueIAIT5Z
1236 */
1237 HWTEST_F(RSSurfaceCaptureTaskParallelTest, PixelMapCopy001, TestSize.Level2)
1238 {
1239 NodeId nodeId = 111;
1240 RSSurfaceCaptureConfig captureConfig;
1241 captureConfig.isHdrCapture = true;
1242 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
1243
1244 Drawing::BackendTexture texture;
1245 Drawing::ColorType type = Drawing::ColorType::COLORTYPE_RGBA_8888;
1246 std::unique_ptr<Media::PixelMap> pixelmap = nullptr;
1247 auto ret = task.PixelMapCopy(pixelmap, nullptr, texture, type, false, 0);
1248 ASSERT_EQ(ret, false);
1249
1250 Media::InitializationOptions opts;
1251 opts.size.width = 480;
1252 opts.size.height = 320;
1253 std::unique_ptr<Media::PixelMap> pixelmap2 = Media::PixelMap::Create(opts);
1254 ASSERT_NE(pixelmap2, nullptr);
1255 RS_LOGE("RSSurfaceCaptureTaskParallel PixelMapCopy in");
1256 ret = task.PixelMapCopy(pixelmap2, nullptr, texture, type, false, 0);
1257 EXPECT_EQ(ret, false);
1258 }
1259
1260 /*
1261 * @tc.name: DrawHDRSurfaceContent001
1262 * @tc.desc: Test RSSurfaceCaptureTaskParallel.DrawHDRSurfaceContent
1263 * @tc.type: FUNC
1264 * @tc.require: issueIAIT5Z
1265 */
1266 HWTEST_F(RSSurfaceCaptureTaskParallelTest, DrawHDRSurfaceContent001, TestSize.Level2)
1267 {
1268 NodeId nodeId = 111;
1269 RSSurfaceCaptureConfig captureConfig;
1270 captureConfig.isHdrCapture = true;
1271 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
1272 auto node = std::make_shared<RSRenderNode>(nodeId);
1273
1274
1275 Media::InitializationOptions opts;
1276 opts.size.width = 480;
1277 opts.size.height = 320;
1278 std::unique_ptr<Media::PixelMap> pixelmap = Media::PixelMap::Create(opts);
1279 ASSERT_NE(pixelmap, nullptr);
1280 auto address = const_cast<uint32_t*>(pixelmap->GetPixel32(0, 0));
1281 ASSERT_NE(address, nullptr);
1282 Drawing::ImageInfo info { pixelmap->GetWidth(), pixelmap->GetHeight(), Drawing::ColorType::COLORTYPE_RGBA_8888,
1283 Drawing::AlphaType::ALPHATYPE_PREMUL };
1284 auto surface = Drawing::Surface::MakeRasterDirect(info, address, pixelmap->GetRowBytes());
1285 task.surfaceNodeDrawable_ = nullptr;
1286 task.displayNodeDrawable_ = nullptr;
1287
1288 task.captureConfig_.mainScreenRect = {0.f, 0.f, -1.f, 1.f};
1289
1290 task.captureConfig_.mainScreenRect = {0.f, 0.f, 1.f, -1.f};
1291
1292
1293 task.captureConfig_.mainScreenRect = {0.f, 0.f, 480.f, 320.f};
1294 task.displayNodeDrawable_ = std::static_pointer_cast<DrawableV2::RSRenderNodeDrawable>(
1295 DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(node));
1296 }
1297 /*
1298 * @tc.name: PixelMapCopy002
1299 * @tc.desc: Test RSSurfaceCaptureTaskParallel.PixelMapCopy
1300 * @tc.type: FUNC
1301 * @tc.require: issueIAIT5Z
1302 */
1303 HWTEST_F(RSSurfaceCaptureTaskParallelTest, PixelMapCopy002, TestSize.Level2)
1304 {
1305 NodeId nodeId = 1000;
1306 RSSurfaceCaptureConfig captureConfig;
1307 captureConfig.isHdrCapture = true;
1308 RSSurfaceCaptureTaskParallel task(nodeId, captureConfig);
1309
1310 Media::InitializationOptions opts;
1311 opts.size.width = 480;
1312 opts.size.height = 320;
1313 std::unique_ptr<Media::PixelMap> pixelmap = Media::PixelMap::Create(opts);
1314 ASSERT_NE(pixelmap, nullptr);
1315
1316 auto colorSpace = std::make_shared<Drawing::ColorSpace>(Drawing::ColorSpace::ColorSpaceType::REF_IMAGE);
1317 ASSERT_FALSE(colorSpace->IsSRGB());
1318
1319 RSBackgroundThread::Instance().gpuContext_ = std::make_shared<Drawing::GPUContext>();
1320 auto grContext = RSBackgroundThread::Instance().GetShareGPUContext();
1321 ASSERT_NE(grContext, nullptr);
1322
1323 Drawing::BackendTexture texture;
1324 bool useDmaType = RSSystemProperties::GetGpuApiType() == GpuApiType::VULKAN ||
1325 RSSystemProperties::GetGpuApiType() == GpuApiType::DDGR;
1326 ASSERT_TRUE(useDmaType);
1327
1328 auto ret = task.PixelMapCopy(pixelmap, colorSpace, texture, Drawing::ColorType::COLORTYPE_RGBA_8888, true, 90);
1329 ASSERT_FALSE(ret);
1330
1331 ret = task.PixelMapCopy(pixelmap, colorSpace, texture, Drawing::ColorType::COLORTYPE_RGBA_8888, false, 90);
1332 ASSERT_FALSE(ret);
1333 }
1334 #endif
1335 }
1336 }
1337