1 #include <cstdlib>
2 #include <cstdio>
3 #include <ctime>
4 #include <dlfcn.h>
5 #include <fstream>
6 #include <functional>
7 #include <memory>
8 #include <string>
9 #include <thread>
10
11 #include <gtest/gtest.h>
12
13 #include "algorithm_common.h"
14 #include "algorithm_errors.h"
15 #include "graphic_common_c.h"
16
17 #include "configuration_helper.h"
18 #include "contrast_enhancer_common.h"
19 #include "contrast_enhancer_image_fwk.h"
20
21 using namespace std;
22 using namespace testing::ext;
23 using namespace OHOS::Media::VideoProcessingEngine;
24
25 class ContrastEnhancerUnitTest : public ::testing::Test {
26 protected:
SetUp()27 void SetUp() override {
28 // 初始化必要的对象和变量
29 }
30
TearDown()31 void TearDown() override {
32 // 清理工作
33 }
34 };
35
CreateSurfaceBuffer(uint32_t pixelFormat,int32_t width,int32_t height)36 sptr<SurfaceBuffer> CreateSurfaceBuffer(uint32_t pixelFormat, int32_t width, int32_t height)
37 {
38 if (width <= 0 || height <= 0) {
39 cout << "Invalid resolution" << endl;
40 return nullptr;
41 }
42 auto buffer = SurfaceBuffer::Create();
43 if (buffer == nullptr) {
44 cout << "Create surface buffer failed" << endl;
45 return nullptr;
46 }
47 BufferRequestConfig inputCfg;
48 inputCfg.width = width;
49 inputCfg.height = height;
50 inputCfg.strideAlignment = width;
51 inputCfg.usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE
52 | BUFFER_USAGE_HW_RENDER | BUFFER_USAGE_HW_TEXTURE | BUFFER_USAGE_MEM_MMZ_CACHE;
53 inputCfg.format = pixelFormat;
54 inputCfg.timeout = 0;
55 if (GSERROR_OK != buffer->Alloc(inputCfg)) {
56 cout << "Alloc surface buffer{" + std::to_string(inputCfg.width) + std::to_string(inputCfg.strideAlignment) +
57 "x" + std::to_string(inputCfg.height) + "format:" + std::to_string(inputCfg.format) + "} failed" << endl;
58 return nullptr;
59 }
60 return buffer;
61 }
62
IsSupported()63 bool IsSupported()
64 {
65 std::string xmlFilePath = "/sys_prod/etc/display/effect/displayengine/featureprocessor/adaptive_fov_cfg.xml";
66 if (access(xmlFilePath.c_str(), R_OK) != 0) [[unlikely]] {
67 cout << xmlFilePath + "is NOT exist!" << endl;
68 return false;
69 }
70 return true;
71 }
72
73 // 测试SetParameter函数
74 HWTEST_F(ContrastEnhancerUnitTest, SetParameter_NormalCase, TestSize.Level1)
75 {
76 ContrastEnhancerParameters param;
77 param.type = ADAPTIVE_FOV;
78 // 设置参数
79 auto contrastEnhancer = ContrastEnhancerImage::Create();
80 EXPECT_NE(contrastEnhancer, nullptr);
81 if (contrastEnhancer == nullptr) {
82 return;
83 }
84 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
85 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
86 }
87
88 // 测试GetParameter函数
89 HWTEST_F(ContrastEnhancerUnitTest, GetParameter_NormalCase, TestSize.Level1)
90 {
91 ContrastEnhancerParameters param;
92 auto contrastEnhancer = ContrastEnhancerImage::Create();
93 EXPECT_NE(contrastEnhancer, nullptr);
94 if (contrastEnhancer == nullptr) {
95 return;
96 }
97 VPEAlgoErrCode ret = contrastEnhancer->GetParameter(param);
98 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
99 }
100
101 // 测试GetRegionHist函数
102 HWTEST_F(ContrastEnhancerUnitTest, GetRegionHist_NormalCase, TestSize.Level1)
103 {
104 sptr<SurfaceBuffer> input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1024, 768);
105 // 初始化input
106 auto contrastEnhancer = ContrastEnhancerImage::Create();
107 EXPECT_NE(contrastEnhancer, nullptr);
108 if (contrastEnhancer == nullptr) {
109 return;
110 }
111 ContrastEnhancerParameters param;
112 param.type = ADAPTIVE_FOV;
113 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
114 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
115
116 if (!IsSupported()) {
117 return;
118 }
119
120 ret = contrastEnhancer->GetRegionHist(input);
121 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
122 }
123
124 HWTEST_F(ContrastEnhancerUnitTest, GetRegionHist_InvalidFormat, TestSize.Level1)
125 {
126 sptr<SurfaceBuffer> input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 768);
127 EXPECT_NE(input, nullptr);
128 // 初始化input
129 auto contrastEnhancer = ContrastEnhancerImage::Create();
130 EXPECT_NE(contrastEnhancer, nullptr);
131 if (contrastEnhancer == nullptr) {
132 return;
133 }
134 ContrastEnhancerParameters param;
135 param.type = ADAPTIVE_FOV;
136 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
137 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
138
139 if (!IsSupported()) {
140 return;
141 }
142
143 ret = contrastEnhancer->GetRegionHist(input);
144 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
145 }
146
147 // 测试UpdateMetadataBasedOnHist函数
148 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnHist_ImplDirectly, TestSize.Level1)
149 {
150 OHOS::Rect displayArea = {
151 .x = 0,
152 .y = 0,
153 .w = 1920,
154 .h = 1080,
155 };
156 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
157 EXPECT_NE(surfaceBuffer, nullptr);
158 if (surfaceBuffer == nullptr) {
159 return;
160 }
161 // 初始化surfaceBuffer
162 auto contrastEnhancer = ContrastEnhancerImage::Create();
163 EXPECT_NE(contrastEnhancer, nullptr);
164 if (contrastEnhancer == nullptr) {
165 return;
166 }
167 ContrastEnhancerParameters param;
168 param.type = ADAPTIVE_FOV;
169 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
170 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
171
172 if (!IsSupported()) {
173 return;
174 }
175
176 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
177 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, 0);
178 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
179 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
180 }
181
182 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnHist_InvalidSurfaceBuffer, TestSize.Level1)
183 {
184 OHOS::Rect displayArea = {
185 .x = 0,
186 .y = 0,
187 .w = 1920,
188 .h = 1080,
189 };
190 // 创建一个无效的SurfaceBuffer对象
191 sptr<SurfaceBuffer> invalidSurfaceBuffer = nullptr; // 或者使用其他方式创建无效对象
192 auto contrastEnhancer = ContrastEnhancerImage::Create();
193 EXPECT_NE(contrastEnhancer, nullptr);
194 if (contrastEnhancer == nullptr) {
195 return;
196 }
197 ContrastEnhancerParameters param;
198 param.type = ADAPTIVE_FOV;
199 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
200 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
201
202 if (!IsSupported()) {
203 return;
204 }
205
206 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
207 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, 0);
208 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, invalidSurfaceBuffer, pixelmapInfo);
209 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
210 }
211
212 // unsupport format
213 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnHist_InvalidFormat, TestSize.Level1)
214 {
215 OHOS::Rect displayArea = {
216 .x = 0,
217 .y = 0,
218 .w = 1920,
219 .h = 1080,
220 };
221 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 768);
222 EXPECT_NE(surfaceBuffer, nullptr);
223 if (surfaceBuffer == nullptr) {
224 return;
225 }
226 // 初始化surfaceBuffer
227 auto contrastEnhancer = ContrastEnhancerImage::Create();
228 EXPECT_NE(contrastEnhancer, nullptr);
229 if (contrastEnhancer == nullptr) {
230 return;
231 }
232 ContrastEnhancerParameters param;
233 param.type = ADAPTIVE_FOV;
234 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
235 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
236
237 if (!IsSupported()) {
238 return;
239 }
240
241 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
242 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, 0);
243 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
244 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
245 }
246
247 // 测试UpdateMetadataBasedOnPixel函数
248 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnPixel_NormalCase, TestSize.Level1)
249 {
250 OHOS::Rect displayArea = {
251 .x = 0,
252 .y = 0,
253 .w = 1920,
254 .h = 1080,
255 };
256 OHOS::Rect curPixelmapArea = {
257 .x = 0,
258 .y = 0,
259 .w = 960,
260 .h = 540,
261 };
262 OHOS::Rect completePixelmapArea = {
263 .x = 0,
264 .y = 0,
265 .w = 1920,
266 .h = 1080,
267 };
268 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1024, 768);
269 EXPECT_NE(surfaceBuffer, nullptr);
270 if (surfaceBuffer == nullptr) {
271 return;
272 }
273 // 初始化surfaceBuffer
274 float fullRatio = 1.0f; // 示例值
275 auto contrastEnhancer = ContrastEnhancerImage::Create();
276 EXPECT_NE(contrastEnhancer, nullptr);
277 if (contrastEnhancer == nullptr) {
278 return;
279 }
280 ContrastEnhancerParameters param;
281 param.type = ADAPTIVE_FOV;
282 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
283 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
284
285 if (!IsSupported()) {
286 return;
287 }
288
289 ret = contrastEnhancer->UpdateMetadataBasedOnPixel(displayArea, curPixelmapArea,
290 completePixelmapArea, surfaceBuffer, fullRatio);
291 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
292 }
293
294 // invalid surfacebuffer
295 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnPixel_InvalidSurfaceBuffer, TestSize.Level1)
296 {
297 OHOS::Rect displayArea = {
298 .x = 0,
299 .y = 0,
300 .w = 1920,
301 .h = 1080,
302 };
303 OHOS::Rect curPixelmapArea = {
304 .x = 0,
305 .y = 0,
306 .w = 960,
307 .h = 540,
308 };
309 OHOS::Rect completePixelmapArea = {
310 .x = 0,
311 .y = 0,
312 .w = 1920,
313 .h = 1080,
314 };
315 float fullRatio = 1.0f;
316 // 创建一个无效的SurfaceBuffer对象
317 sptr<SurfaceBuffer> invalidSurfaceBuffer = nullptr; // 或者使用其他方式创建无效对象
318 auto contrastEnhancer = ContrastEnhancerImage::Create();
319 EXPECT_NE(contrastEnhancer, nullptr);
320 if (contrastEnhancer == nullptr) {
321 return;
322 }
323 ContrastEnhancerParameters param;
324 param.type = ADAPTIVE_FOV;
325 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
326 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
327
328 if (!IsSupported()) {
329 return;
330 }
331
332 ret = contrastEnhancer->UpdateMetadataBasedOnPixel(displayArea, curPixelmapArea,
333 completePixelmapArea, invalidSurfaceBuffer, fullRatio);
334 EXPECT_EQ(ret, VPE_ALGO_ERR_UNKNOWN);
335 }
336
337 // over max ratio
338 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnHist_MaxRatio, TestSize.Level1)
339 {
340 OHOS::Rect displayArea = {
341 .x = 0,
342 .y = 0,
343 .w = 1920,
344 .h = 1080,
345 };
346 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
347 EXPECT_NE(surfaceBuffer, nullptr);
348 if (surfaceBuffer == nullptr) {
349 return;
350 }
351 // 初始化surfaceBuffer
352 auto contrastEnhancer = ContrastEnhancerImage::Create();
353 EXPECT_NE(contrastEnhancer, nullptr);
354 if (contrastEnhancer == nullptr) {
355 return;
356 }
357 ContrastEnhancerParameters param;
358 param.type = ADAPTIVE_FOV;
359 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
360 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
361
362 if (!IsSupported()) {
363 return;
364 }
365
366 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
367 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.6, 0.5, 0.2, 0);
368 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
369 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
370 }
371
372 // smaller than min ratio
373 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnHist_MinRatio, TestSize.Level1)
374 {
375 OHOS::Rect displayArea = {
376 .x = 0,
377 .y = 0,
378 .w = 1920,
379 .h = 1080,
380 };
381 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
382 EXPECT_NE(surfaceBuffer, nullptr);
383 if (surfaceBuffer == nullptr) {
384 return;
385 }
386 // 初始化surfaceBuffer
387 auto contrastEnhancer = ContrastEnhancerImage::Create();
388 EXPECT_NE(contrastEnhancer, nullptr);
389 if (contrastEnhancer == nullptr) {
390 return;
391 }
392 ContrastEnhancerParameters param;
393 param.type = ADAPTIVE_FOV;
394 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
395 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
396
397 if (!IsSupported()) {
398 return;
399 }
400
401 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
402 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.1, 0.5, 0.2, 0);
403 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
404 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
405 }
406
407 // double click, animation duration > 0
408 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnHist_DoubleClick, TestSize.Level1)
409 {
410 OHOS::Rect displayArea = {
411 .x = 0,
412 .y = 0,
413 .w = 1920,
414 .h = 1080,
415 };
416 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
417 EXPECT_NE(surfaceBuffer, nullptr);
418 if (surfaceBuffer == nullptr) {
419 return;
420 }
421 // 初始化surfaceBuffer
422 auto contrastEnhancer = ContrastEnhancerImage::Create();
423 EXPECT_NE(contrastEnhancer, nullptr);
424 if (contrastEnhancer == nullptr) {
425 return;
426 }
427 ContrastEnhancerParameters param;
428 param.type = ADAPTIVE_FOV;
429 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
430 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
431
432 if (!IsSupported()) {
433 return;
434 }
435
436 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
437 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, 200);
438 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
439 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
440 }
441
442 // invalid animation duration
443 HWTEST_F(ContrastEnhancerUnitTest, UpdateMetadataBasedOnHist_InvalidDuration, TestSize.Level1)
444 {
445 OHOS::Rect displayArea = {
446 .x = 0,
447 .y = 0,
448 .w = 1920,
449 .h = 1080,
450 };
451 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
452 EXPECT_NE(surfaceBuffer, nullptr);
453 if (surfaceBuffer == nullptr) {
454 return;
455 }
456 // 初始化surfaceBuffer
457 auto contrastEnhancer = ContrastEnhancerImage::Create();
458 EXPECT_NE(contrastEnhancer, nullptr);
459 if (contrastEnhancer == nullptr) {
460 return;
461 }
462 ContrastEnhancerParameters param;
463 param.type = ADAPTIVE_FOV;
464 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
465 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
466
467 if (!IsSupported()) {
468 return;
469 }
470
471 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
472 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, -200);
473 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
474 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
475 }
476
threadFunction(std::shared_ptr<ContrastEnhancerImage> impl,OHOS::Rect rect,sptr<SurfaceBuffer> surfaceBuffer,std::tuple<int,int,double,double,double,int> pixelmapInfo)477 void threadFunction(std::shared_ptr<ContrastEnhancerImage> impl, OHOS::Rect rect, sptr<SurfaceBuffer> surfaceBuffer,
478 std::tuple<int, int, double, double, double, int> pixelmapInfo) {
479 impl->UpdateMetadataBasedOnHist(rect, surfaceBuffer, pixelmapInfo);
480 }
481
482
483 // 多线程、无动画
484 HWTEST_F(ContrastEnhancerUnitTest, Concurrency_scenarios, TestSize.Level1)
485 {
486 OHOS::Rect displayArea = {
487 .x = 0,
488 .y = 0,
489 .w = 1920,
490 .h = 1080,
491 };
492 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
493 EXPECT_NE(surfaceBuffer, nullptr);
494 if (surfaceBuffer == nullptr) {
495 return;
496 }
497 // 初始化surfaceBuffer
498 std::shared_ptr<ContrastEnhancerImage> contrastEnhancer = std::make_shared<ContrastEnhancerImageFwk>();
499 EXPECT_NE(contrastEnhancer, nullptr);
500 if (contrastEnhancer == nullptr) {
501 return;
502 }
503 ContrastEnhancerParameters param;
504 param.type = ADAPTIVE_FOV;
505 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
506 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
507
508 if (!IsSupported()) {
509 return;
510 }
511
512 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
513 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, 0);
514 // 创建一个线程向量来存储线程对象
515 std::thread threads[5];
516 // 创建并启动5个线程
517 for (int i = 0; i < 5; ++i) {
518 threads[i] = std::thread(threadFunction, std::ref(contrastEnhancer), displayArea, surfaceBuffer, pixelmapInfo);
519 }
520 // 等待所有线程完成
521 for (auto& th : threads) {
522 if (th.joinable()) {
523 th.join();
524 }
525 }
526 }
527
528 // 多线程、有动画
529 HWTEST_F(ContrastEnhancerUnitTest, Concurrency_scenarios_with_animation, TestSize.Level1)
530 {
531 OHOS::Rect displayArea = {
532 .x = 0,
533 .y = 0,
534 .w = 1920,
535 .h = 1080,
536 };
537 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
538 EXPECT_NE(surfaceBuffer, nullptr);
539 if (surfaceBuffer == nullptr) {
540 return;
541 }
542 // 初始化surfaceBuffer
543 std::shared_ptr<ContrastEnhancerImage> contrastEnhancer = std::make_shared<ContrastEnhancerImageFwk>();
544 EXPECT_NE(contrastEnhancer, nullptr);
545 if (contrastEnhancer == nullptr) {
546 return;
547 }
548 ContrastEnhancerParameters param;
549 param.type = ADAPTIVE_FOV;
550 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
551 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
552
553 if (!IsSupported()) {
554 return;
555 }
556
557 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
558 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, 200);
559 // 创建一个线程向量来存储线程对象
560 std::thread threads[5];
561 // 创建并启动5个线程
562 for (int i = 0; i < 5; ++i) {
563 threads[i] = std::thread(threadFunction, std::ref(contrastEnhancer), displayArea, surfaceBuffer, pixelmapInfo);
564 }
565 // 等待所有线程完成
566 for (auto& th : threads) {
567 if (th.joinable()) {
568 th.join();
569 }
570 }
571 }
572
573 // impl twice
574 HWTEST_F(ContrastEnhancerUnitTest, Get_Algo_Twice, TestSize.Level1)
575 {
576 OHOS::Rect displayArea = {
577 .x = 0,
578 .y = 0,
579 .w = 1920,
580 .h = 1080,
581 };
582 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
583 EXPECT_NE(surfaceBuffer, nullptr);
584 if (surfaceBuffer == nullptr) {
585 return;
586 }
587 // 初始化surfaceBuffer
588 std::shared_ptr<ContrastEnhancerImageFwk> contrastEnhancer = std::make_shared<ContrastEnhancerImageFwk>();
589 EXPECT_NE(contrastEnhancer, nullptr);
590 if (contrastEnhancer == nullptr) {
591 return;
592 }
593 ContrastEnhancerParameters param;
594 param.type = ADAPTIVE_FOV;
595 VPEAlgoErrCode ret = contrastEnhancer->SetParameter(param);
596 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
597
598 if (!IsSupported()) {
599 return;
600 }
601
602 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
603 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, 2200);
604 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
605 EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
606 }
607
608 // get algo failed over 5 times due to invalid enhancer type
609 HWTEST_F(ContrastEnhancerUnitTest, Get_Algo_Failed, TestSize.Level1)
610 {
611 OHOS::Rect displayArea = {
612 .x = 0,
613 .y = 0,
614 .w = 1920,
615 .h = 1080,
616 };
617 sptr<SurfaceBuffer> surfaceBuffer = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_1010102, 1920, 1080);
618 EXPECT_NE(surfaceBuffer, nullptr);
619 if (surfaceBuffer == nullptr) {
620 return;
621 }
622 // 初始化surfaceBuffer
623 std::shared_ptr<ContrastEnhancerImageFwk> contrastEnhancer = std::make_shared<ContrastEnhancerImageFwk>();
624 EXPECT_NE(contrastEnhancer, nullptr);
625 if (contrastEnhancer == nullptr) {
626 return;
627 }
628
629 if (!IsSupported()) {
630 return;
631 }
632
633 // UniqueId, contentId, curRatio, maxRatio, minRatio, animationDuration
634 std::tuple<int, int, double, double, double, int> pixelmapInfo = std::make_tuple(1, 1, 0.3, 0.5, 0.2, 2200);
635 VPEAlgoErrCode ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
636 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
637 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
638 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
639 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
640 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
641 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
642 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
643 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
644 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
645 ret = contrastEnhancer->UpdateMetadataBasedOnHist(displayArea, surfaceBuffer, pixelmapInfo);
646 EXPECT_NE(ret, VPE_ALGO_ERR_OK);
647 }