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
18 #include "image_processing.h"
19 #include "image_processing_types.h"
20 #include "native_avformat.h"
21 #include "pixelmap_native.h"
22 #include "image_processing_factory.h"
23
24 using namespace std;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Media {
29 namespace VideoProcessingEngine {
30
31 class ImageProcessingUnitTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void ImageProcessingUnitTest::SetUpTestCase(void)
40 {
41 cout << "[SetUpTestCase]: " << endl;
42 }
43
TearDownTestCase(void)44 void ImageProcessingUnitTest::TearDownTestCase(void)
45 {
46 cout << "[TearDownTestCase]: " << endl;
47 }
48
SetUp(void)49 void ImageProcessingUnitTest::SetUp(void)
50 {
51 cout << "[SetUp]: SetUp!!!" << endl;
52 }
53
TearDown(void)54 void ImageProcessingUnitTest::TearDown(void)
55 {
56 cout << "[TearDown]: over!!!" << endl;
57 }
58
CreateEmptyPixelmap(OH_PixelmapNative ** pixelMap,int32_t width,int32_t height,int format)59 void CreateEmptyPixelmap(OH_PixelmapNative** pixelMap, int32_t width, int32_t height, int format)
60 {
61 OH_Pixelmap_InitializationOptions* options = nullptr;
62 (void)OH_PixelmapInitializationOptions_Create(&options);
63 (void)OH_PixelmapInitializationOptions_SetWidth(options, width);
64 (void)OH_PixelmapInitializationOptions_SetHeight(options, height);
65 (void)OH_PixelmapInitializationOptions_SetPixelFormat(options, format);
66 (void)OH_PixelmapNative_CreateEmptyPixelmap(options, pixelMap);
67 }
68
69 HWTEST_F(ImageProcessingUnitTest, create_instance_01, TestSize.Level1)
70 {
71 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
72 OH_ImageProcessing* instance = nullptr;
73 ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
74 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
75 }
76
77 HWTEST_F(ImageProcessingUnitTest, deinitialize_02, TestSize.Level1)
78 {
79 auto ret = OH_ImageProcessing_DeinitializeEnvironment();
80 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
81 }
82
83 HWTEST_F(ImageProcessingUnitTest, create_instance_02, TestSize.Level1)
84 {
85 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
86 OH_ImageProcessing* instance = nullptr;
87 ret = OH_ImageProcessing_Create(&instance, 11);
88 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
89 }
90
91 HWTEST_F(ImageProcessingUnitTest, destroy_instance_01, TestSize.Level1)
92 {
93 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
94 OH_ImageProcessing* instance = nullptr;
95 ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
96 ret = OH_ImageProcessing_Destroy(instance);
97 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
98 }
99
100 HWTEST_F(ImageProcessingUnitTest, destroy_instance_02, TestSize.Level1)
101 {
102 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
103 OH_ImageProcessing* instance = nullptr;
104 ret = OH_ImageProcessing_Destroy(instance);
105 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
106 }
107
108 /**
109 * @tc.number : VPE_IMAGE_API_TEST_0140
110 * @tc.name : call OH_ImageProcessing_IsCompositionSupported
111 * @tc.desc : function test
112 */
113 HWTEST(VpeImageApiTest, VPE_IMAGE_API_TEST_0140, TestSize.Level0)
114 {
115 ImageProcessing_ColorSpaceInfo SRC_INFO;
116 ImageProcessing_ColorSpaceInfo SRC_GAIN_INFO;
117 ImageProcessing_ColorSpaceInfo DST_INFO;
118 DST_INFO.colorSpace = 9;
119 DST_INFO.metadataType = 3;
120 DST_INFO.pixelFormat = 10;
121 SRC_INFO.colorSpace = 3;
122 SRC_INFO.metadataType = 1;
123 SRC_INFO.pixelFormat = 3;
124 bool ret = OH_ImageProcessing_IsCompositionSupported(&SRC_INFO, &SRC_GAIN_INFO, &DST_INFO);
125 ASSERT_TRUE(ret);
126 }
127 HWTEST(VpeImageApiTest, VPE_IMAGE_API_TEST_0141, TestSize.Level0)
128 {
129 ImageProcessing_ColorSpaceInfo SRC_INFO;
130 ImageProcessing_ColorSpaceInfo SRC_GAIN_INFO;
131 ImageProcessing_ColorSpaceInfo DST_INFO;
132 SRC_INFO.colorSpace = 9;
133 SRC_INFO.metadataType = 3;
134 SRC_INFO.pixelFormat = 10;
135 DST_INFO.colorSpace = 3;
136 DST_INFO.metadataType = 1;
137 DST_INFO.pixelFormat = 3;
138 bool ret = OH_ImageProcessing_IsDecompositionSupported(&SRC_INFO, &DST_INFO, &SRC_GAIN_INFO);
139 ASSERT_TRUE(ret);
140 }
141 HWTEST(VpeImageApiTest, VPE_IMAGE_API_TEST_0142, TestSize.Level0)
142 {
143 ImageProcessing_ColorSpaceInfo SRC_INFO;
144 ImageProcessing_ColorSpaceInfo DST_INFO;
145 SRC_INFO.colorSpace = 3;
146 SRC_INFO.metadataType = 0;
147 SRC_INFO.pixelFormat = 3;
148 DST_INFO.colorSpace = 4;
149 DST_INFO.metadataType = 0;
150 DST_INFO.pixelFormat = 3;
151 bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(&SRC_INFO, &DST_INFO);
152 ASSERT_TRUE(ret);
153 }
154 HWTEST(VpeImageApiTest, VPE_IMAGE_API_TEST_0143, TestSize.Level0)
155 {
156 ImageProcessing_ColorSpaceInfo SRC_INFO;
157 SRC_INFO.colorSpace = 9;
158 SRC_INFO.metadataType = 3;
159 SRC_INFO.pixelFormat = 10;
160 bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(&SRC_INFO);
161 ASSERT_TRUE(ret);
162 }
163 HWTEST_F(ImageProcessingUnitTest, set_parameter_01, TestSize.Level1)
164 {
165 OH_ImageProcessing* instance = nullptr;
166 OH_AVFormat* parameter = nullptr;
167 ImageProcessing_ErrorCode ret = OH_ImageProcessing_SetParameter(instance, parameter);
168 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
169 }
170
171 HWTEST_F(ImageProcessingUnitTest, set_parameter_02, TestSize.Level1)
172 {
173 OH_ImageProcessing* instance = nullptr;
174 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
175 OH_AVFormat* parameter = nullptr;
176 ret = OH_ImageProcessing_SetParameter(instance, parameter);
177 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
178 }
179
180 HWTEST_F(ImageProcessingUnitTest, set_parameter_03, TestSize.Level1)
181 {
182 OH_ImageProcessing* instance = nullptr;
183 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
184 OH_AVFormat* parameter = OH_AVFormat_Create();
185 OH_AVFormat_SetIntValue(parameter, IMAGE_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL, 10);
186 ret = OH_ImageProcessing_SetParameter(instance, parameter);
187 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
188 }
189
190 HWTEST_F(ImageProcessingUnitTest, get_parameter_01, TestSize.Level1)
191 {
192 OH_ImageProcessing* instance = nullptr;
193 OH_AVFormat* parameter = nullptr;
194 ImageProcessing_ErrorCode ret = OH_ImageProcessing_GetParameter(instance, parameter);
195 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
196 }
197
198 HWTEST_F(ImageProcessingUnitTest, get_parameter_02, TestSize.Level1)
199 {
200 OH_ImageProcessing* instance = nullptr;
201 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
202 OH_AVFormat* parameter = nullptr;
203 ret = OH_ImageProcessing_GetParameter(instance, parameter);
204 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER);
205 }
206
207 HWTEST_F(ImageProcessingUnitTest, get_parameter_03, TestSize.Level1)
208 {
209 OH_ImageProcessing* instance = nullptr;
210 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
211 OH_AVFormat* parameter = OH_AVFormat_Create();
212 OH_AVFormat_SetIntValue(parameter, IMAGE_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
213 IMAGE_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
214 ret = OH_ImageProcessing_SetParameter(instance, parameter);
215 ret = OH_ImageProcessing_GetParameter(instance, parameter);
216 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
217 }
218
219 HWTEST_F(ImageProcessingUnitTest, get_parameter_04, TestSize.Level1)
220 {
221 OH_ImageProcessing* instance = nullptr;
222 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
223 OH_AVFormat* parameter = OH_AVFormat_Create();
224 ret = OH_ImageProcessing_GetParameter(instance, parameter);
225 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
226 }
227
228 HWTEST_F(ImageProcessingUnitTest, process_01, TestSize.Level1)
229 {
230 OH_ImageProcessing* instance = nullptr;
231 OH_PixelmapNative* srcImg = nullptr;
232 OH_PixelmapNative* dstImg = nullptr;
233 ImageProcessing_ErrorCode ret = OH_ImageProcessing_EnhanceDetail(instance, srcImg, dstImg);
234 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
235 }
236
237 HWTEST_F(ImageProcessingUnitTest, process_02, TestSize.Level1)
238 {
239 OH_ImageProcessing* instance = nullptr;
240 OH_PixelmapNative* srcImg = nullptr;
241 OH_PixelmapNative* dstImg = nullptr;
242 CreateEmptyPixelmap(&srcImg, 720, 960, 4);
243 CreateEmptyPixelmap(&dstImg, 2880, 3840, 4);
244 ImageProcessing_ErrorCode ret = OH_ImageProcessing_EnhanceDetail(instance, srcImg, dstImg);
245 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
246 }
247
248 HWTEST_F(ImageProcessingUnitTest, process_03, TestSize.Level1)
249 {
250 OH_ImageProcessing* instance = nullptr;
251 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
252 OH_AVFormat* parameter = OH_AVFormat_Create();
253 OH_AVFormat_SetIntValue(parameter, IMAGE_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
254 IMAGE_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
255 ret = OH_ImageProcessing_SetParameter(instance, parameter);
256 OH_PixelmapNative* srcImg = nullptr;
257 OH_PixelmapNative* dstImg = nullptr;
258 CreateEmptyPixelmap(&srcImg, 720, 960, 4);
259 CreateEmptyPixelmap(&dstImg, 2880, 3840, 4);
260 ret = OH_ImageProcessing_EnhanceDetail(instance, srcImg, dstImg);
261 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
262 }
263
264 HWTEST_F(ImageProcessingUnitTest, process_04, TestSize.Level1)
265 {
266 OH_ImageProcessing* instance = nullptr;
267 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
268 OH_PixelmapNative* srcImg = nullptr;
269 OH_PixelmapNative* dstImg = nullptr;
270 CreateEmptyPixelmap(&srcImg, 720, 960, 4);
271 CreateEmptyPixelmap(&dstImg, 2880, 3840, 4);
272 ret = OH_ImageProcessing_EnhanceDetail(instance, srcImg, dstImg);
273 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
274 }
275
276 HWTEST_F(ImageProcessingUnitTest, process_05, TestSize.Level1)
277 {
278 OH_ImageProcessing* instance = nullptr;
279 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DETAIL_ENHANCER);
280 OH_PixelmapNative* srcImg = nullptr;
281 OH_PixelmapNative* dstImg = nullptr;
282 CreateEmptyPixelmap(&srcImg, 720, 960, 9);
283 CreateEmptyPixelmap(&dstImg, 2880, 3840, 9);
284 ret = OH_ImageProcessing_EnhanceDetail(instance, srcImg, dstImg);
285 EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS);
286 }
287
288 HWTEST_F(ImageProcessingUnitTest, initialize, TestSize.Level1)
289 {
290 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
291 EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
292 }
293
294 HWTEST_F(ImageProcessingUnitTest, deinitialize, TestSize.Level1)
295 {
296 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
297 ret = OH_ImageProcessing_DeinitializeEnvironment();
298 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
299 }
300
301 HWTEST_F(ImageProcessingUnitTest, process_07, TestSize.Level1)
302 {
303 ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment();
304 OH_ImageProcessing* instance = nullptr;
305 ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_COMPOSITION);
306 OH_PixelmapNative* srcImg = nullptr;
307 OH_PixelmapNative* dstImg = nullptr;
308 OH_PixelmapNative* gainmap = nullptr;
309 CreateEmptyPixelmap(&srcImg, 3840, 2160, 3);
310 CreateEmptyPixelmap(&dstImg, 3840, 2160, 10);
311 CreateEmptyPixelmap(&gainmap, 1920, 1080, 3);
312 if (dstImg == nullptr) {
313 return;
314 }
315 ret = OH_ImageProcessing_Compose(instance, srcImg, gainmap, dstImg);
316 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
317 OH_ImageProcessing_DeinitializeEnvironment();
318 }
319 HWTEST_F(ImageProcessingUnitTest, process_08, TestSize.Level1)
320 {
321 OH_ImageProcessing_InitializeEnvironment();
322 OH_ImageProcessing* instance = nullptr;
323 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_DECOMPOSITION);
324 OH_PixelmapNative* srcImg = nullptr;
325 OH_PixelmapNative* dstImg = nullptr;
326 OH_PixelmapNative* gainmap = nullptr;
327 CreateEmptyPixelmap(&srcImg, 3840, 2160, 10);
328 CreateEmptyPixelmap(&dstImg, 3840, 2160, 3);
329 CreateEmptyPixelmap(&gainmap, 1920, 1080, 3);
330 if (srcImg == nullptr) {
331 return;
332 }
333 ret = OH_ImageProcessing_Decompose(instance, srcImg, dstImg, gainmap);
334 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
335 OH_ImageProcessing_DeinitializeEnvironment();
336 }
337 HWTEST_F(ImageProcessingUnitTest, process_09, TestSize.Level1)
338 {
339 OH_ImageProcessing_InitializeEnvironment();
340 OH_ImageProcessing* instance = nullptr;
341 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION);
342 OH_PixelmapNative* srcImg = nullptr;
343 OH_PixelmapNative* dstImg = nullptr;
344 CreateEmptyPixelmap(&srcImg, 3840, 2160, 3);
345 CreateEmptyPixelmap(&dstImg, 3840, 2160, 3);
346 ret = OH_ImageProcessing_ConvertColorSpace(instance, srcImg, dstImg);
347 if (ret != 0) {
348 return;
349 }
350 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
351 OH_ImageProcessing_DeinitializeEnvironment();
352 }
353 HWTEST_F(ImageProcessingUnitTest, process_10, TestSize.Level1)
354 {
355 OH_ImageProcessing_InitializeEnvironment();
356 OH_ImageProcessing* instance = nullptr;
357 ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&instance, IMAGE_PROCESSING_TYPE_METADATA_GENERATION);
358 OH_PixelmapNative* srcImg = nullptr;
359 CreateEmptyPixelmap(&srcImg, 3840, 2160, 10);
360 if (srcImg == nullptr) {
361 return;
362 }
363 ret = OH_ImageProcessing_GenerateMetadata(instance, srcImg);
364 EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS);
365 OH_ImageProcessing_DeinitializeEnvironment();
366 }
367 } // namespace VideoProcessingEngine
368 } // namespace Media
369 } // namespace OHOS
370