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