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