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 <fstream>
18
19 #include "image_processing.h"
20 #include "image_processing_types.h"
21 #include "image_processing_impl.h"
22 #include "image_processing_native.h"
23 #include "native_avformat.h"
24 #include "pixelmap_native.h"
25 #include "surface/native_buffer.h"
26
27 using namespace std;
28 using namespace testing::ext;
29
30 const int32_t IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION = 0x1;
31 const int32_t IMAGE_PROCESSING_TYPE_COMPOSITION = 0x2;
32 const int32_t IMAGE_PROCESSING_TYPE_DECOMPOSITION = 0x4;
33 const int32_t IMAGE_PROCESSING_TYPE_METADATA_GENERATION = 0x8;
34 const int32_t IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER = 0x10;
35 const char* IMAGE_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL = "QualityLevel";
36
37 namespace OHOS {
38 namespace Media {
39 namespace VideoProcessingEngine {
40
41 const ImageProcessing_ColorSpaceInfo param_srgb = {
42 0,
43 OH_COLORSPACE_SRGB_FULL,
44 NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
45 };
46
47 const ImageProcessing_ColorSpaceInfo param_p3 = {
48 0,
49 OH_COLORSPACE_P3_FULL,
50 NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
51 };
52
53 const ImageProcessing_ColorSpaceInfo param_bt709 = {
54 0,
55 OH_COLORSPACE_BT709_FULL,
56 NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
57 };
58
59 const ImageProcessing_ColorSpaceInfo param_not_support = {
60 0,
61 OH_COLORSPACE_BT601_EBU_FULL,
62 NATIVEBUFFER_PIXEL_FMT_BGRX_8888,
63 };
64
65 const ImageProcessing_ColorSpaceInfo param5 = {
66 0,
67 OH_COLORSPACE_BT2020_PQ_LIMIT,
68 NATIVEBUFFER_PIXEL_FMT_RGBA_1010102,
69 };
70
71 class DetailEnhancerImageNdkUnitTest : public testing::Test {
72 public:
73 static void SetUpTestCase(void);
74 static void TearDownTestCase(void);
75 void SetUp();
76 void TearDown();
77 };
78
SetUpTestCase(void)79 void DetailEnhancerImageNdkUnitTest::SetUpTestCase(void)
80 {
81 }
82
TearDownTestCase(void)83 void DetailEnhancerImageNdkUnitTest::TearDownTestCase(void)
84 {
85 }
86
SetUp(void)87 void DetailEnhancerImageNdkUnitTest::SetUp(void)
88 {
89 }
90
TearDown(void)91 void DetailEnhancerImageNdkUnitTest::TearDown(void)
92 {
93 }
94
CreateEmptyPixelmap(OH_PixelmapNative ** pixelMap,int32_t width,int32_t height,int format)95 void CreateEmptyPixelmap(OH_PixelmapNative** pixelMap, int32_t width, int32_t height, int format)
96 {
97 OH_Pixelmap_InitializationOptions* options = nullptr;
98 (void)OH_PixelmapInitializationOptions_Create(&options);
99 (void)OH_PixelmapInitializationOptions_SetWidth(options, width);
100 (void)OH_PixelmapInitializationOptions_SetHeight(options, height);
101 (void)OH_PixelmapInitializationOptions_SetPixelFormat(options, format);
102 (void)OH_PixelmapNative_CreateEmptyPixelmap(options, pixelMap);
103 }
104
105 // initialize environment
106 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_01, TestSize.Level1)
107 {
108 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
109 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
110 OH_ImageProcessing_DeinitializeEnvironment();
111 }
112
113 // initialize and de-initialize
114 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_02, TestSize.Level1)
115 {
116 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
117 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
118 ret = OH_ImageProcessing_DeinitializeEnvironment();
119 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
120 }
121
122 // de-initialize without initialize
123 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_03, TestSize.Level1)
124 {
125 ImageProcessing_ErrorCode ret = OH_ImageProcessing_DeinitializeEnvironment();
126 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
127 }
128
129 // create instance
130 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_04, TestSize.Level1)
131 {
132 OH_ImageProcessing_InitializeEnvironment();
133 OH_ImageProcessing* instance = nullptr;
134 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
135 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
136 }
137
138 // create instance impl
139 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_04_1, TestSize.Level1)
140 {
141 OH_ImageProcessing_InitializeEnvironment();
142 OH_ImageProcessing* instance = nullptr;
143 ImageProcessing_ErrorCode ret = OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
144 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
145 }
146
147 // create instance with wrong type
148 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_05, TestSize.Level1)
149 {
150 OH_ImageProcessing_InitializeEnvironment();
151 OH_ImageProcessing* instance = nullptr;
152 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, 11);
153 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
154 }
155
156 // create instance with wrong type impl
157 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_05_1, TestSize.Level1)
158 {
159 OH_ImageProcessing_InitializeEnvironment();
160 OH_ImageProcessing* instance = nullptr;
161 ImageProcessing_ErrorCode ret = OH_ImageProcessing::Create(&instance, 11);
162 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
163 }
164
165 // destroy instance
166 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_06, TestSize.Level1)
167 {
168 OH_ImageProcessing_InitializeEnvironment();
169 OH_ImageProcessing* instance = nullptr;
170 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
171 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Destroy(instance);
172 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
173 }
174
175 // destroy instance impl
176 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_06_1, TestSize.Level1)
177 {
178 OH_ImageProcessing_InitializeEnvironment();
179 OH_ImageProcessing* instance = nullptr;
180 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
181 ImageProcessing_ErrorCode ret = OH_ImageProcessing::Destroy(instance);
182 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
183 }
184
185 // destroy null instance
186 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_07, TestSize.Level1)
187 {
188 OH_ImageProcessing_InitializeEnvironment();
189 OH_ImageProcessing* instance = nullptr;
190 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Destroy(instance);
191 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
192 }
193
194 // destroy null instance impl
195 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_07_1, TestSize.Level1)
196 {
197 OH_ImageProcessing_InitializeEnvironment();
198 OH_ImageProcessing* instance = nullptr;
199 ImageProcessing_ErrorCode ret = OH_ImageProcessing::Destroy(instance);
200 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
201 }
202
203 // set parameter normally
204 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_08, TestSize.Level1)
205 {
206 OH_ImageProcessing* instance = nullptr;
207 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
208 OH_AVFormat* parameter = OH_AVFormat_Create();
209 OH_AVFormat_SetIntValue(parameter, IMAGE_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL, 10);
210 ImageProcessing_ErrorCode ret = OH_ImageProcessing_SetParameter(instance, parameter);
211 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
212 OH_ImageProcessing_Destroy(instance);
213 }
214
215 // set parameter normally impl
216 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_08_1, TestSize.Level1)
217 {
218 OH_ImageProcessing* instance = nullptr;
219 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
220 OH_AVFormat* parameter = OH_AVFormat_Create();
221 OH_AVFormat_SetIntValue(parameter, IMAGE_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL, 10);
222 ImageProcessing_ErrorCode ret = instance->GetObj()->SetParameter(parameter);
223 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
224 OH_ImageProcessing::Destroy(instance);
225 }
226
227 // set parameter with null
228 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_09, TestSize.Level1)
229 {
230 OH_ImageProcessing* instance = nullptr;
231 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
232 OH_AVFormat* parameter = nullptr;
233 ImageProcessing_ErrorCode ret = OH_ImageProcessing_SetParameter(instance, parameter);
234 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
235 OH_ImageProcessing_Destroy(instance);
236 }
237
238 // set parameter with null impl
239 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_09_1, TestSize.Level1)
240 {
241 OH_ImageProcessing* instance = nullptr;
242 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
243 OH_AVFormat* parameter = nullptr;
244 ImageProcessing_ErrorCode ret = instance->GetObj()->SetParameter(parameter);
245 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
246 OH_ImageProcessing::Destroy(instance);
247 }
248
249 // set parameter but instance is null
250 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_10, TestSize.Level1)
251 {
252 OH_ImageProcessing* instance = nullptr;
253 OH_AVFormat* parameter = nullptr;
254 ImageProcessing_ErrorCode ret = OH_ImageProcessing_SetParameter(instance, parameter);
255 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
256 }
257
258 // get parameter after set parameter
259 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_11, TestSize.Level1)
260 {
261 OH_ImageProcessing* instance = nullptr;
262 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
263 OH_AVFormat* parameter = OH_AVFormat_Create();
264 OH_AVFormat_SetIntValue(parameter, IMAGE_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
265 IMAGE_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
266 OH_ImageProcessing_SetParameter(instance, parameter);
267 ImageProcessing_ErrorCode ret = OH_ImageProcessing_GetParameter(instance, parameter);
268 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
269 OH_ImageProcessing_Destroy(instance);
270 }
271
272 // get parameter after set parameter impl
273 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_11_1, TestSize.Level1)
274 {
275 OH_ImageProcessing* instance = nullptr;
276 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
277 OH_AVFormat* parameter = OH_AVFormat_Create();
278 OH_AVFormat_SetIntValue(parameter, IMAGE_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
279 IMAGE_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
280 instance->GetObj()->SetParameter(parameter);
281 ImageProcessing_ErrorCode ret = instance->GetObj()->GetParameter(parameter);
282 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
283 OH_ImageProcessing::Destroy(instance);
284 }
285
286 // get parameter but parameter is null
287 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_12, TestSize.Level1)
288 {
289 OH_ImageProcessing* instance = nullptr;
290 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
291 OH_AVFormat* parameter = nullptr;
292 ImageProcessing_ErrorCode ret = OH_ImageProcessing_GetParameter(instance, parameter);
293 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
294 OH_ImageProcessing_Destroy(instance);
295 }
296
297 // get parameter but parameter is null impl
298 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_12_1, TestSize.Level1)
299 {
300 OH_ImageProcessing* instance = nullptr;
301 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
302 OH_AVFormat* parameter = nullptr;
303 ImageProcessing_ErrorCode ret = instance->GetObj()->GetParameter(parameter);
304 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
305 OH_ImageProcessing::Destroy(instance);
306 }
307
308 // get parameter but instance is null set
309 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_13, TestSize.Level1)
310 {
311 OH_ImageProcessing* instance = nullptr;
312 OH_AVFormat* parameter = nullptr;
313 ImageProcessing_ErrorCode ret = OH_ImageProcessing_GetParameter(instance, parameter);
314 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
315 }
316
317 // get parameter but parameter is not null
318 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_14, TestSize.Level1)
319 {
320 OH_ImageProcessing* instance = nullptr;
321 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
322 OH_AVFormat* parameter = OH_AVFormat_Create();
323 ImageProcessing_ErrorCode ret = OH_ImageProcessing_GetParameter(instance, parameter);
324 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
325 OH_ImageProcessing_Destroy(instance);
326 }
327
328 // get parameter but parameter is not null impl
329 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_14_1, TestSize.Level1)
330 {
331 OH_ImageProcessing* instance = nullptr;
332 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
333 OH_AVFormat* parameter = OH_AVFormat_Create();
334 ImageProcessing_ErrorCode ret = instance->GetObj()->GetParameter(parameter);
335 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
336 OH_ImageProcessing::Destroy(instance);
337 }
338
339 // colorspaceconversion support check 1
340 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_15, TestSize.Level1)
341 {
342 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(¶m_srgb, ¶m_p3);
343 ASSERT_FALSE(ret);
344 }
345
346 // colorspaceconversion support check 2
347 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_16, TestSize.Level1)
348 {
349 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(¶m_p3, ¶m_bt709);
350 ASSERT_FALSE(ret);
351 }
352
353 // colorspaceconversion support check 3
354 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_17, TestSize.Level1)
355 {
356 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(¶m_bt709, ¶m_not_support);
357 ASSERT_FALSE(ret);
358 }
359
360 // colorspaceconversion support check 4
361 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_18, TestSize.Level1)
362 {
363 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(¶m_p3, ¶m_srgb);
364 ASSERT_FALSE(ret);
365 }
366
367 // conposition support check 1
368 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_19, TestSize.Level1)
369 {
370 bool ret = OH_ImageProcessing_IsCompositionSupported(¶m_srgb, ¶m_srgb, ¶m_p3);
371 ASSERT_FALSE(ret);
372 }
373
374 // conposition support check 2
375 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_20, TestSize.Level1)
376 {
377 bool ret = OH_ImageProcessing_IsCompositionSupported(¶m_not_support, ¶m_not_support, ¶m_not_support);
378 ASSERT_FALSE(ret);
379 }
380
381 // conposition support check 3
382 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_21, TestSize.Level1)
383 {
384 bool ret = OH_ImageProcessing_IsCompositionSupported(¶m_srgb, ¶m_srgb, ¶m_srgb);
385 ASSERT_FALSE(ret);
386 }
387
388 // deconposition support check 1
389 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_22, TestSize.Level1)
390 {
391 bool ret = OH_ImageProcessing_IsDecompositionSupported(¶m_srgb, ¶m_p3, ¶m_bt709);
392 ASSERT_FALSE(ret);
393 }
394
395 // deconposition support check 2
396 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_23, TestSize.Level1)
397 {
398 bool ret = OH_ImageProcessing_IsDecompositionSupported(¶m_not_support, ¶m_not_support, ¶m_not_support);
399 ASSERT_FALSE(ret);
400 }
401
402 // deconposition support check 3
403 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_24, TestSize.Level1)
404 {
405 bool ret = OH_ImageProcessing_IsDecompositionSupported(¶m_srgb, ¶m_srgb, ¶m_srgb);
406 ASSERT_FALSE(ret);
407 }
408
409 // metadata generation support check 1
410 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_25, TestSize.Level1)
411 {
412 bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(¶m5);
413 ASSERT_FALSE(ret);
414 }
415
416 // metadata generation support check 2
417 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_26, TestSize.Level1)
418 {
419 bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(¶m_p3);
420 ASSERT_FALSE(ret);
421 }
422
423 // metadata generation support check 3
424 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_27, TestSize.Level1)
425 {
426 bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(¶m_bt709);
427 ASSERT_FALSE(ret);
428 }
429
430 // metadata generation support check 4
431 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_28, TestSize.Level1)
432 {
433 bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(¶m_not_support);
434 ASSERT_FALSE(ret);
435 }
436
437 // convert color space RGBA to BGRA impl
438 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_29, TestSize.Level1)
439 {
440 OH_ImageProcessing_InitializeEnvironment();
441 OH_ImageProcessing* instance = nullptr;
442 OH_ImageProcessing* instance2 = nullptr;
443 OH_PixelmapNative* srcImg = nullptr;
444 OH_PixelmapNative* dstImg = nullptr;
445 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
446 CreateEmptyPixelmap(&dstImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
447 OH_ImageProcessing_Create(&instance2, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
448 OH_ImageProcessing_ConvertColorSpace(instance2, srcImg, dstImg);
449 OH_ImageProcessing_Destroy(instance2);
450 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
451 ImageProcessing_ErrorCode ret = instance->GetObj()->ConvertColorSpace(srcImg, dstImg);
452 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
453 OH_ImageProcessing::Destroy(instance);
454 OH_ImageProcessing_DeinitializeEnvironment();
455 }
456
457 // convert color space BGRA to RGBA impl
458 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_30, TestSize.Level1)
459 {
460 OH_ImageProcessing_InitializeEnvironment();
461 OH_ImageProcessing* instance = nullptr;
462 OH_ImageProcessing* instance2 = nullptr;
463 OH_PixelmapNative* srcImg = nullptr;
464 OH_PixelmapNative* dstImg = nullptr;
465 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
466 CreateEmptyPixelmap(&dstImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
467 OH_ImageProcessing_Create(&instance2, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
468 OH_ImageProcessing_ConvertColorSpace(instance2, srcImg, dstImg);
469 OH_ImageProcessing_Destroy(instance2);
470 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
471 ImageProcessing_ErrorCode ret = instance->GetObj()->ConvertColorSpace(srcImg, dstImg);
472 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
473 OH_ImageProcessing::Destroy(instance);
474 OH_ImageProcessing_DeinitializeEnvironment();
475 }
476
477 // convert color space nullptr
478 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_31, TestSize.Level1)
479 {
480 OH_ImageProcessing_InitializeEnvironment();
481 OH_ImageProcessing* instance = nullptr;
482 OH_PixelmapNative* srcImg = nullptr;
483 OH_PixelmapNative* dstImg = nullptr;
484 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
485 ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace(instance, srcImg, dstImg);
486 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
487 OH_ImageProcessing_Destroy(instance);
488 OH_ImageProcessing_DeinitializeEnvironment();
489 }
490
491 // convert color space nullptr impl
492 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_31_1, TestSize.Level1)
493 {
494 OH_ImageProcessing_InitializeEnvironment();
495 OH_ImageProcessing* instance = nullptr;
496 OH_PixelmapNative* srcImg = nullptr;
497 OH_PixelmapNative* dstImg = nullptr;
498 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
499 ImageProcessing_ErrorCode ret = instance->GetObj()->ConvertColorSpace(srcImg, dstImg);
500 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
501 OH_ImageProcessing::Destroy(instance);
502 OH_ImageProcessing_DeinitializeEnvironment();
503 }
504
505 // compose RGBA impl
506 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_32, TestSize.Level1)
507 {
508 OH_ImageProcessing_InitializeEnvironment();
509 OH_ImageProcessing* instance = nullptr;
510 OH_ImageProcessing* instance2 = nullptr;
511 OH_PixelmapNative* srcImg = nullptr;
512 OH_PixelmapNative* gainmap = nullptr;
513 OH_PixelmapNative* dstImg = nullptr;
514 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
515 CreateEmptyPixelmap(&gainmap, 720, 960, PIXEL_FORMAT_RGBA_8888);
516 CreateEmptyPixelmap(&dstImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
517 OH_ImageProcessing_Create(&instance2, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
518 OH_ImageProcessing_Compose(instance2, srcImg, gainmap, dstImg);
519 OH_ImageProcessing_Destroy(instance2);
520 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
521 ImageProcessing_ErrorCode ret = instance->GetObj()->Compose(srcImg, gainmap, dstImg);
522 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
523 OH_ImageProcessing::Destroy(instance);
524 OH_ImageProcessing_DeinitializeEnvironment();
525 }
526
527 // compose BGRA impl
528 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_33, TestSize.Level1)
529 {
530 OH_ImageProcessing_InitializeEnvironment();
531 OH_ImageProcessing* instance = nullptr;
532 OH_ImageProcessing* instance2 = nullptr;
533 OH_PixelmapNative* srcImg = nullptr;
534 OH_PixelmapNative* gainmap = nullptr;
535 OH_PixelmapNative* dstImg = nullptr;
536 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
537 CreateEmptyPixelmap(&gainmap, 720, 960, PIXEL_FORMAT_BGRA_8888);
538 CreateEmptyPixelmap(&dstImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
539 OH_ImageProcessing_Create(&instance2, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
540 OH_ImageProcessing_Compose(instance2, srcImg, gainmap, dstImg);
541 OH_ImageProcessing_Destroy(instance2);
542 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
543 ImageProcessing_ErrorCode ret = instance->GetObj()->Compose(srcImg, gainmap, dstImg);
544 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
545 OH_ImageProcessing::Destroy(instance);
546 OH_ImageProcessing_DeinitializeEnvironment();
547 }
548
549 // compose nullptr
550 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_34, TestSize.Level1)
551 {
552 OH_ImageProcessing_InitializeEnvironment();
553 OH_ImageProcessing* instance = nullptr;
554 OH_PixelmapNative* srcImg = nullptr;
555 OH_PixelmapNative* gainmap = nullptr;
556 OH_PixelmapNative* dstImg = nullptr;
557 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
558 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(instance, srcImg, gainmap, dstImg);
559 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
560 OH_ImageProcessing_Destroy(instance);
561 OH_ImageProcessing_DeinitializeEnvironment();
562 }
563
564 // compose nullptr impl
565 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_34_1, TestSize.Level1)
566 {
567 OH_ImageProcessing_InitializeEnvironment();
568 OH_ImageProcessing* instance = nullptr;
569 OH_PixelmapNative* srcImg = nullptr;
570 OH_PixelmapNative* gainmap = nullptr;
571 OH_PixelmapNative* dstImg = nullptr;
572 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
573 ImageProcessing_ErrorCode ret = instance->GetObj()->Compose(srcImg, gainmap, dstImg);
574 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
575 OH_ImageProcessing::Destroy(instance);
576 OH_ImageProcessing_DeinitializeEnvironment();
577 }
578
579 // decompose RGBA impl
580 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_35, TestSize.Level1)
581 {
582 OH_ImageProcessing_InitializeEnvironment();
583 OH_ImageProcessing* instance = nullptr;
584 OH_ImageProcessing* instance2 = nullptr;
585 OH_PixelmapNative* srcImg = nullptr;
586 OH_PixelmapNative* gainmap = nullptr;
587 OH_PixelmapNative* dstImg = nullptr;
588 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
589 CreateEmptyPixelmap(&gainmap, 720, 960, PIXEL_FORMAT_RGBA_8888);
590 CreateEmptyPixelmap(&dstImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
591 OH_ImageProcessing_Create(&instance2, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
592 OH_ImageProcessing_Decompose(instance2, srcImg, dstImg, gainmap);
593 OH_ImageProcessing_Destroy(instance2);
594 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
595 ImageProcessing_ErrorCode ret = instance->GetObj()->Decompose(srcImg, dstImg, gainmap);
596 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
597 OH_ImageProcessing::Destroy(instance);
598 OH_ImageProcessing_DeinitializeEnvironment();
599 }
600
601 // decompose BGRA impl
602 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_36, TestSize.Level1)
603 {
604 OH_ImageProcessing_InitializeEnvironment();
605 OH_ImageProcessing* instance = nullptr;
606 OH_ImageProcessing* instance2 = nullptr;
607 OH_PixelmapNative* srcImg = nullptr;
608 OH_PixelmapNative* gainmap = nullptr;
609 OH_PixelmapNative* dstImg = nullptr;
610 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
611 CreateEmptyPixelmap(&gainmap, 720, 960, PIXEL_FORMAT_BGRA_8888);
612 CreateEmptyPixelmap(&dstImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
613 OH_ImageProcessing_Create(&instance2, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
614 OH_ImageProcessing_Decompose(instance2, srcImg, dstImg, gainmap);
615 OH_ImageProcessing_Destroy(instance2);
616 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
617 ImageProcessing_ErrorCode ret = instance->GetObj()->Decompose(srcImg, dstImg, gainmap);
618 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
619 OH_ImageProcessing::Destroy(instance);
620 OH_ImageProcessing_DeinitializeEnvironment();
621 }
622
623 // decompose nullptr
624 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_37, TestSize.Level1)
625 {
626 OH_ImageProcessing_InitializeEnvironment();
627 OH_ImageProcessing* instance = nullptr;
628 OH_PixelmapNative* srcImg = nullptr;
629 OH_PixelmapNative* gainmap = nullptr;
630 OH_PixelmapNative* dstImg = nullptr;
631 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
632 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(instance, srcImg, dstImg, gainmap);
633 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
634 OH_ImageProcessing_Destroy(instance);
635 OH_ImageProcessing_DeinitializeEnvironment();
636 }
637
638 // compose nullptr impl
639 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_37_1, TestSize.Level1)
640 {
641 OH_ImageProcessing_InitializeEnvironment();
642 OH_ImageProcessing* instance = nullptr;
643 OH_PixelmapNative* srcImg = nullptr;
644 OH_PixelmapNative* gainmap = nullptr;
645 OH_PixelmapNative* dstImg = nullptr;
646 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
647 ImageProcessing_ErrorCode ret = instance->GetObj()->Decompose(srcImg, dstImg, gainmap);
648 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
649 OH_ImageProcessing::Destroy(instance);
650 OH_ImageProcessing_DeinitializeEnvironment();
651 }
652
653 // generate metadata RGBA impl
654 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_38, TestSize.Level1)
655 {
656 OH_ImageProcessing_InitializeEnvironment();
657 OH_ImageProcessing* instance = nullptr;
658 OH_ImageProcessing* instance2 = nullptr;
659 OH_PixelmapNative* srcImg = nullptr;
660 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
661 OH_ImageProcessing_Create(&instance2, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
662 OH_ImageProcessing_GenerateMetadata(instance2, srcImg);
663 OH_ImageProcessing_Destroy(instance2);
664 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
665 ImageProcessing_ErrorCode ret = instance->GetObj()->GenerateMetadata(srcImg);
666 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
667 OH_ImageProcessing::Destroy(instance);
668 OH_ImageProcessing_DeinitializeEnvironment();
669 }
670
671 // generate metadata BGRA impl
672 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_39, TestSize.Level1)
673 {
674 OH_ImageProcessing_InitializeEnvironment();
675 OH_ImageProcessing* instance = nullptr;
676 OH_ImageProcessing* instance2 = nullptr;
677 OH_PixelmapNative* srcImg = nullptr;
678 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
679 OH_ImageProcessing_Create(&instance2, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
680 OH_ImageProcessing_GenerateMetadata(instance2, srcImg);
681 OH_ImageProcessing_Destroy(instance2);
682 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
683 ImageProcessing_ErrorCode ret = instance->GetObj()->GenerateMetadata(srcImg);
684 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
685 OH_ImageProcessing::Destroy(instance);
686 OH_ImageProcessing_DeinitializeEnvironment();
687 }
688
689 // generate metadata nullptr
690 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_40, TestSize.Level1)
691 {
692 OH_ImageProcessing_InitializeEnvironment();
693 OH_ImageProcessing* instance = nullptr;
694 OH_PixelmapNative* srcImg = nullptr;
695 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
696 ImageProcessing_ErrorCode ret = OH_ImageProcessing_GenerateMetadata(instance, srcImg);
697 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
698 OH_ImageProcessing_Destroy(instance);
699 OH_ImageProcessing_DeinitializeEnvironment();
700 }
701
702 // generate metadata nullptr impl
703 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_40_1, TestSize.Level1)
704 {
705 OH_ImageProcessing_InitializeEnvironment();
706 OH_ImageProcessing* instance = nullptr;
707 OH_PixelmapNative* srcImg = nullptr;
708 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
709 ImageProcessing_ErrorCode ret = instance->GetObj()->GenerateMetadata(srcImg);
710 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
711 OH_ImageProcessing::Destroy(instance);
712 OH_ImageProcessing_DeinitializeEnvironment();
713 }
714
715 // detail enhance RGBA
716 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_41, TestSize.Level1)
717 {
718 OH_ImageProcessing_InitializeEnvironment();
719 OH_ImageProcessing* instance = nullptr;
720 OH_PixelmapNative* srcImg = nullptr;
721 OH_PixelmapNative* dstImg = nullptr;
722 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
723 CreateEmptyPixelmap(&dstImg, 1440, 1920, PIXEL_FORMAT_RGBA_8888);
724 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
725 ImageProcessing_ErrorCode ret = OH_ImageProcessing_EnhanceDetail(instance, srcImg, dstImg);
726 if (!access("/system/lib64/ndk/libimage_processing_capi_impl.so", 0)) {
727 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
728 } else {
729 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
730 }
731 OH_ImageProcessing_Destroy(instance);
732 OH_ImageProcessing_DeinitializeEnvironment();
733 }
734
735 // detail enhance RGBA impl
736 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_41_1, TestSize.Level1)
737 {
738 OH_ImageProcessing_InitializeEnvironment();
739 OH_ImageProcessing* instance = nullptr;
740 OH_PixelmapNative* srcImg = nullptr;
741 OH_PixelmapNative* dstImg = nullptr;
742 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_RGBA_8888);
743 CreateEmptyPixelmap(&dstImg, 1440, 1920, PIXEL_FORMAT_RGBA_8888);
744 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
745 ImageProcessing_ErrorCode ret = instance->GetObj()->EnhanceDetail(srcImg, dstImg);
746 #ifdef SKIA_ENABLE
747 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
748 #else
749 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
750 #endif
751 OH_ImageProcessing::Destroy(instance);
752 OH_ImageProcessing_DeinitializeEnvironment();
753 }
754
755 // detail enhance BGRA
756 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_42, TestSize.Level1)
757 {
758 OH_ImageProcessing_InitializeEnvironment();
759 OH_ImageProcessing* instance = nullptr;
760 OH_PixelmapNative* srcImg = nullptr;
761 OH_PixelmapNative* dstImg = nullptr;
762 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
763 CreateEmptyPixelmap(&dstImg, 1440, 1920, PIXEL_FORMAT_BGRA_8888);
764 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
765 ImageProcessing_ErrorCode ret = OH_ImageProcessing_EnhanceDetail(instance, srcImg, dstImg);
766 if (!access("/system/lib64/ndk/libimage_processing_capi_impl.so", 0)) {
767 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
768 } else {
769 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
770 }
771 OH_ImageProcessing_Destroy(instance);
772 OH_ImageProcessing_DeinitializeEnvironment();
773 }
774
775 // detail enhance BGRA impl
776 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_42_1, TestSize.Level1)
777 {
778 OH_ImageProcessing_InitializeEnvironment();
779 OH_ImageProcessing* instance = nullptr;
780 OH_PixelmapNative* srcImg = nullptr;
781 OH_PixelmapNative* dstImg = nullptr;
782 CreateEmptyPixelmap(&srcImg, 720, 960, PIXEL_FORMAT_BGRA_8888);
783 CreateEmptyPixelmap(&dstImg, 1440, 1920, PIXEL_FORMAT_BGRA_8888);
784 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
785 ImageProcessing_ErrorCode ret = instance->GetObj()->EnhanceDetail(srcImg, dstImg);
786 #ifdef SKIA_ENABLE
787 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
788 #else
789 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
790 #endif
791 OH_ImageProcessing::Destroy(instance);
792 OH_ImageProcessing_DeinitializeEnvironment();
793 }
794
795 // detail enhance nullptr
796 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_43, TestSize.Level1)
797 {
798 OH_ImageProcessing_InitializeEnvironment();
799 OH_ImageProcessing* instance = nullptr;
800 OH_PixelmapNative* srcImg = nullptr;
801 OH_PixelmapNative* dstImg = nullptr;
802 OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
803 ImageProcessing_ErrorCode ret = OH_ImageProcessing_EnhanceDetail(instance, srcImg, dstImg);
804 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
805 OH_ImageProcessing_Destroy(instance);
806 OH_ImageProcessing_DeinitializeEnvironment();
807 }
808
809 // detail enhance nullptr impl
810 HWTEST_F(DetailEnhancerImageNdkUnitTest, vpeImageNdk_43_1, TestSize.Level1)
811 {
812 OH_ImageProcessing_InitializeEnvironment();
813 OH_ImageProcessing* instance = nullptr;
814 OH_PixelmapNative* srcImg = nullptr;
815 OH_PixelmapNative* dstImg = nullptr;
816 OH_ImageProcessing::Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
817 ImageProcessing_ErrorCode ret = instance->GetObj()->EnhanceDetail(srcImg, dstImg);
818 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
819 OH_ImageProcessing::Destroy(instance);
820 OH_ImageProcessing_DeinitializeEnvironment();
821 }
822
823 }
824 } // namespace Media
825 } // namespace OHOS