1 /*
2 * Copyright (C) 2021 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 "pixelmap_native.h"
18 #include "pixelmap_native_impl.h"
19 #include "common_utils.h"
20 #include "image_source_native.h"
21 #include "securec.h"
22 #include "image_utils.h"
23 #include "native_color_space_manager.h"
24 #include "image_mime_type.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::Media;
28
29 struct OH_Pixelmap_ImageInfo {
30 uint32_t width = 0;
31 uint32_t height = 0;
32 uint32_t rowStride = 0;
33 int32_t pixelFormat = PIXEL_FORMAT::PIXEL_FORMAT_UNKNOWN;
34 PIXELMAP_ALPHA_TYPE alphaType = PIXELMAP_ALPHA_TYPE::PIXELMAP_ALPHA_TYPE_UNKNOWN;
35 bool isHdr = false;
36 Image_MimeType mimeType;
37 };
38
39 namespace OHOS {
40 namespace Media {
41
42 constexpr int8_t ARGB_8888_BYTES = 4;
43
44 class PixelMapNdk2Test : public testing::Test {
45 public:
PixelMapNdk2Test()46 PixelMapNdk2Test() {}
~PixelMapNdk2Test()47 ~PixelMapNdk2Test() {}
48 };
49
50 const int32_t ZERO = 0;
51 const int32_t ONE = 1;
52 const int32_t TWO = 2;
53 const int32_t THREE = 3;
54 const float PRIMARIES = 0.1;
55 const int32_t VERSION_VALUE = 50;
56 constexpr int32_t bufferSize = 256;
57 static const std::string IMAGE_JPEG_PATH = "/data/local/tmp/image/test_jpeg_writeexifblob001.jpg";
58 static const std::string IMAGE_JPEG_PATH_TEST = "/data/local/tmp/image/test.jpg";
59 static const std::string IMAGE_JPEG_PATH_TEST_PICTURE = "/data/local/tmp/image/test_picture.jpg";
60
CompareImageInfo(OH_Pixelmap_ImageInfo * srcImageInfo,OH_Pixelmap_ImageInfo * dstImageInfo)61 static bool CompareImageInfo(OH_Pixelmap_ImageInfo* srcImageInfo, OH_Pixelmap_ImageInfo* dstImageInfo)
62 {
63 if (srcImageInfo == nullptr && dstImageInfo == nullptr) {
64 return true;
65 }
66
67 if ((srcImageInfo == nullptr) ^ (dstImageInfo == nullptr)) {
68 return false;
69 }
70
71 uint32_t srcWidth, srcHeight, srcRowStride = 0;
72 int32_t srcPixelFormat, srcAlphaType = 0;
73 bool srcIsHdr = false;
74 OH_PixelmapImageInfo_GetWidth(srcImageInfo, &srcWidth);
75 OH_PixelmapImageInfo_GetHeight(srcImageInfo, &srcHeight);
76 OH_PixelmapImageInfo_GetRowStride(srcImageInfo, &srcRowStride);
77 OH_PixelmapImageInfo_GetPixelFormat(srcImageInfo, &srcPixelFormat);
78 OH_PixelmapImageInfo_GetAlphaType(srcImageInfo, &srcAlphaType);
79 OH_PixelmapImageInfo_GetDynamicRange(srcImageInfo, &srcIsHdr);
80
81 uint32_t dstWidth, dstHeight, dstRowStride = 0;
82 int32_t dstPixelFormat, dstAlphaType = 0;
83 bool dstIsHdr = false;
84 OH_PixelmapImageInfo_GetWidth(dstImageInfo, &dstWidth);
85 OH_PixelmapImageInfo_GetHeight(dstImageInfo, &dstHeight);
86 OH_PixelmapImageInfo_GetRowStride(dstImageInfo, &dstRowStride);
87 OH_PixelmapImageInfo_GetPixelFormat(dstImageInfo, &dstPixelFormat);
88 OH_PixelmapImageInfo_GetAlphaType(dstImageInfo, &dstAlphaType);
89 OH_PixelmapImageInfo_GetDynamicRange(dstImageInfo, &dstIsHdr);
90
91 return srcWidth == dstWidth && srcHeight == dstHeight && srcRowStride == dstRowStride
92 && srcPixelFormat == dstPixelFormat && srcAlphaType == dstAlphaType && srcIsHdr == dstIsHdr;
93 }
94
CreatePixelmapNative(OH_PixelmapNative ** pixelmapNative)95 static void CreatePixelmapNative(OH_PixelmapNative** pixelmapNative)
96 {
97 std::string realPath;
98 if (!ImageUtils::PathToRealPath(IMAGE_JPEG_PATH_TEST_PICTURE.c_str(), realPath)) {
99 return;
100 }
101
102 char filePath[bufferSize];
103 if (strcpy_s(filePath, sizeof(filePath), realPath.c_str()) != EOK) {
104 return;
105 }
106
107 size_t length = realPath.size();
108 OH_ImageSourceNative *source = nullptr;
109 OH_ImageSourceNative_CreateFromUri(filePath, length, &source);
110
111 OH_DecodingOptions *opts = nullptr;
112 OH_DecodingOptions_Create(&opts);
113
114 OH_PixelmapNative *pixelmap = nullptr;
115 OH_ImageSourceNative_CreatePixelmap(source, opts, &pixelmap);
116 *pixelmapNative = pixelmap;
117 }
118
119 /**
120 * @tc.name: OH_PixelmapInitializationOptions_Create
121 * @tc.desc: OH_PixelmapInitializationOptions_Create
122 * @tc.type: FUNC
123 */
124 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_Create, TestSize.Level3)
125 {
126 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_Create start";
127 OH_Pixelmap_InitializationOptions *ops = nullptr;
128 Image_ErrorCode res = OH_PixelmapInitializationOptions_Create(&ops);
129 ASSERT_EQ(res, IMAGE_SUCCESS);
130 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_Create end";
131 }
132
133 /**
134 * @tc.name: OH_PixelmapInitializationOptions_SetGetWidth
135 * @tc.desc: OH_PixelmapInitializationOptions_SetGetWidth
136 * @tc.type: FUNC
137 */
138 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetWidth, TestSize.Level3)
139 {
140 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_GetWidth start";
141 OH_Pixelmap_InitializationOptions *ops = nullptr;
142 OH_PixelmapInitializationOptions_Create(&ops);
143 uint32_t width = 0;
144 OH_PixelmapInitializationOptions_SetWidth(ops, 1);
145 OH_PixelmapInitializationOptions_GetWidth(ops, &width);
146 ASSERT_EQ(width, 1);
147 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_GetWidth end";
148 }
149
150 /**
151 * @tc.name: OH_PixelmapInitializationOptions_SetGetHeight
152 * @tc.desc: OH_PixelmapInitializationOptions_SetGetHeight
153 * @tc.type: FUNC
154 */
155 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetHeight, TestSize.Level3)
156 {
157 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetGetHeight start";
158 OH_Pixelmap_InitializationOptions *ops = nullptr;
159 OH_PixelmapInitializationOptions_Create(&ops);
160 uint32_t height = 0;
161 OH_PixelmapInitializationOptions_SetHeight(ops, 1);
162 OH_PixelmapInitializationOptions_GetHeight(ops, &height);
163 ASSERT_EQ(height, 1);
164 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetGetHeight end";
165 }
166
167 /**
168 * @tc.name: OH_PixelmapInitializationOptions_SetGetPixelFormat
169 * @tc.desc: OH_PixelmapInitializationOptions_SetGetPixelFormat
170 * @tc.type: FUNC
171 */
172 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetPixelFormat, TestSize.Level3)
173 {
174 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_InitializationSetOptionsGetPixelFormat start";
175 OH_Pixelmap_InitializationOptions *ops = nullptr;
176 OH_PixelmapInitializationOptions_Create(&ops);
177 int32_t pixelFormat = 0;
178 OH_PixelmapInitializationOptions_SetPixelFormat(ops, 1);
179 OH_PixelmapInitializationOptions_GetPixelFormat(ops, &pixelFormat);
180 ASSERT_EQ(pixelFormat, 1);
181 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_InitializationSetOptionsGetPixelFormat end";
182 }
183
184 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetAlphaType, TestSize.Level3)
185 {
186 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetGetAlphaType start";
187 OH_Pixelmap_InitializationOptions *ops = nullptr;
188 OH_PixelmapInitializationOptions_Create(&ops);
189 int32_t alphaType = 0;
190 OH_PixelmapInitializationOptions_SetAlphaType(ops, 1);
191 OH_PixelmapInitializationOptions_GetAlphaType(ops, &alphaType);
192 ASSERT_EQ(alphaType, 1);
193 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetGetAlphaType end";
194 }
195
196 /**
197 * @tc.name: OH_PixelmapInitializationOptions_SetEditable
198 * @tc.desc: OH_PixelmapInitializationOptions_SetEditable
199 * @tc.type: FUNC
200 */
201 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetEditable, TestSize.Level3)
202 {
203 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetEditable start";
204 OH_Pixelmap_InitializationOptions *ops = nullptr;
205 OH_PixelmapInitializationOptions_Create(&ops);
206 bool editable = false;
207 OH_PixelmapInitializationOptions_GetEditable(ops, &editable);
208 ASSERT_EQ(editable, true);
209 OH_PixelmapInitializationOptions_SetEditable(ops, false);
210 OH_PixelmapInitializationOptions_GetEditable(ops, &editable);
211 ASSERT_EQ(editable, false);
212 ASSERT_EQ(OH_PixelmapInitializationOptions_SetEditable(nullptr, true), 401);
213 ASSERT_EQ(OH_PixelmapInitializationOptions_SetEditable(nullptr, false), 401);
214 ASSERT_EQ(OH_PixelmapInitializationOptions_GetEditable(nullptr, &editable), 401);
215 ASSERT_EQ(OH_PixelmapInitializationOptions_GetEditable(nullptr, &editable), 401);
216 OH_PixelmapInitializationOptions_Release(ops);
217 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetEditable end";
218 }
219
220 /**
221 * @tc.name: OH_PixelmapNative_Destroy
222 * @tc.desc: Test OH_PixelmapNative_Destroy with valid inputs
223 * @tc.type: FUNC
224 */
225 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Destroy, TestSize.Level3)
226 {
227 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Destroy start";
228
229 size_t dataSize = ARGB_8888_BYTES;
230 uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
231 OH_Pixelmap_InitializationOptions *createOpts;
232 OH_PixelmapInitializationOptions_Create(&createOpts);
233 OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
234 OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
235 OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
236 OH_PixelmapNative *pixelMap = nullptr;
237 Image_ErrorCode errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
238 ASSERT_EQ(errCode, IMAGE_SUCCESS);
239
240 OH_PixelmapNative_Destroy(&pixelMap);
241 ASSERT_EQ(pixelMap, nullptr);
242 ASSERT_EQ(OH_PixelmapNative_Destroy(nullptr), 401);
243 OH_PixelmapInitializationOptions_Release(createOpts);
244 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Destroy end";
245 }
246
247
248 /**
249 * @tc.name: OH_PixelmapInitializationOptions_Release
250 * @tc.desc: OH_PixelmapInitializationOptions_Release
251 * @tc.type: FUNC
252 */
253 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_Release, TestSize.Level3)
254 {
255 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_Release start";
256 OH_Pixelmap_InitializationOptions *ops = nullptr;
257 Image_ErrorCode ret = OH_PixelmapInitializationOptions_Release(ops);
258 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
259 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_Release end";
260 }
261
262 /**
263 * @tc.name: OH_PixelmapImageInfo_Create
264 * @tc.desc: OH_PixelmapImageInfo_Create
265 * @tc.type: FUNC
266 */
267 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_Create, TestSize.Level3)
268 {
269 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_Create start";
270 OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
271 Image_ErrorCode ret = OH_PixelmapImageInfo_Create(&ImageInfo);
272 ASSERT_EQ(ret, IMAGE_SUCCESS);
273 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_Create end";
274 }
275
276 /**
277 * @tc.name: OH_PixelmapImageInfo_GetWidth
278 * @tc.desc: OH_PixelmapImageInfo_GetWidth
279 * @tc.type: FUNC
280 */
281 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetWidth, TestSize.Level3)
282 {
283 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetWidth start";
284 OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
285 uint32_t width = 0;
286 Image_ErrorCode ret = OH_PixelmapImageInfo_GetWidth(ImageInfo, &width);
287 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
288 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetWidth end";
289 }
290
291 /**
292 * @tc.name: OH_PixelmapImageInfo_GetHeight
293 * @tc.desc: OH_PixelmapImageInfo_GetHeight
294 * @tc.type: FUNC
295 */
296 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetHeight, TestSize.Level3)
297 {
298 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetHeight start";
299 OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
300 uint32_t height = 0;
301 Image_ErrorCode ret = OH_PixelmapImageInfo_GetHeight(ImageInfo, &height);
302 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
303 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetHeight end";
304 }
305
306 /**
307 * @tc.name: OH_PixelmapImageInfo_GetRowStride
308 * @tc.desc: OH_PixelmapImageInfo_GetRowStride
309 * @tc.type: FUNC
310 */
311 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetRowStride, TestSize.Level3)
312 {
313 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetRowStride start";
314 OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
315 uint32_t rowSize = 0;
316 Image_ErrorCode ret = OH_PixelmapImageInfo_GetRowStride(ImageInfo, &rowSize);
317 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
318 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetRowStride end";
319 }
320
321 /**
322 * @tc.name: OH_PixelmapImageInfo_GetPixelFormat
323 * @tc.desc: OH_PixelmapImageInfo_GetPixelFormat
324 * @tc.type: FUNC
325 */
326 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetPixelFormat, TestSize.Level3)
327 {
328 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetPixelFormat start";
329 OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
330 int32_t pixelFormat = 0;
331 Image_ErrorCode ret = OH_PixelmapImageInfo_GetPixelFormat(ImageInfo, &pixelFormat);
332 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
333 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetPixelFormat end";
334 }
335
336 /**
337 * @tc.name: OH_PixelmapImageInfo_GetAlphaType
338 * @tc.desc: OH_PixelmapImageInfo_GetAlphaType
339 * @tc.type: FUNC
340 */
341 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetAlphaType, TestSize.Level3)
342 {
343 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetAlphaType start";
344 OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
345 int32_t density = 0;
346 Image_ErrorCode ret = OH_PixelmapImageInfo_GetAlphaType(ImageInfo, &density);
347 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
348 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetAlphaType end";
349 }
350
351 /**
352 * @tc.name: OH_PixelmapImageInfo_Release
353 * @tc.desc: OH_PixelmapImageInfo_Release
354 * @tc.type: FUNC
355 */
356 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_Release, TestSize.Level3)
357 {
358 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_Release start";
359 OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
360 Image_ErrorCode ret = OH_PixelmapImageInfo_Release(ImageInfo);
361 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
362 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_Release end";
363 }
364
365 /**
366 * @tc.name: OH_PixelmapNative_CreatePixelMap
367 * @tc.desc: OH_PixelmapNative_CreatePixelMap
368 * @tc.type: FUNC
369 */
370 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_CreatePixelMap, TestSize.Level3)
371 {
372 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreatePixelMap start";
373 uint8_t *colors = nullptr;
374 size_t colorLength = 0;
375 OH_Pixelmap_InitializationOptions *opts = nullptr;
376 OH_PixelmapNative *pixelMap = nullptr;
377 Image_ErrorCode ret = OH_PixelmapNative_CreatePixelmap(colors, colorLength, opts, &pixelMap);
378 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
379 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreatePixelMap end";
380 }
381
382 /**
383 * @tc.name: OH_PixelmapNative_ConvertPixelmapNativeToNapi
384 * @tc.desc: test OH_PixelmapNative_ConvertPixelmapNativeToNapi
385 * @tc.type: FUNC
386 */
387 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ConvertPixelmapNativeToNapi, TestSize.Level3)
388 {
389 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertPixelmapNativeToNapi start";
390 napi_env env = nullptr;
391 OH_PixelmapNative *pixelMap = nullptr;
392 napi_value res = nullptr;
393 Image_ErrorCode ret = OH_PixelmapNative_ConvertPixelmapNativeToNapi(env, pixelMap, &res);
394 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
395 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertPixelmapNativeToNapi end";
396 }
397
398 /**
399 * @tc.name: OH_PixelmapNative_ConvertPixelmapNativeFromNapi
400 * @tc.desc: test OH_PixelmapNative_ConvertPixelmapNativeFromNapi
401 * @tc.type: FUNC
402 */
403 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ConvertPixelmapNativeFromNapi, TestSize.Level3)
404 {
405 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertPixelmapNativeFromNapi start";
406 napi_env env = nullptr;
407 napi_value source = nullptr;
408 OH_PixelmapNative *pixelMap = nullptr;
409 Image_ErrorCode ret = OH_PixelmapNative_ConvertPixelmapNativeFromNapi(env, source, &pixelMap);
410 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
411 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertPixelmapNativeFromNapi end";
412 }
413
414 /**
415 * @tc.name: OH_PixelmapNative_ReadPixels
416 * @tc.desc: OH_PixelmapNative_ReadPixels
417 * @tc.type: FUNC
418 */
419 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ReadPixels, TestSize.Level3)
420 {
421 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ReadPixels start";
422 OH_PixelmapNative *pixelMap = nullptr;
423 uint8_t *buffer = nullptr;
424 size_t *bufferSize = nullptr;
425 Image_ErrorCode ret = OH_PixelmapNative_ReadPixels(pixelMap, buffer, bufferSize);
426 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
427 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ReadPixels end";
428 }
429
430 /**
431 * @tc.name: OH_PixelmapNative_WritePixels
432 * @tc.desc: OH_PixelmapNative_WritePixels
433 * @tc.type: FUNC
434 */
435 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_WritePixels, TestSize.Level3)
436 {
437 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_WritePixels start";
438 OH_PixelmapNative *pixelMap = nullptr;
439 uint8_t *source = nullptr;
440 size_t bufferSize = 0;
441 Image_ErrorCode ret = OH_PixelmapNative_WritePixels(pixelMap, source, bufferSize);
442 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
443 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_WritePixels end";
444 }
445
446 /**
447 * @tc.name: OH_PixelmapNative_GetArgbPixels_Test001
448 * @tc.desc: Test OH_PixelmapNative_GetArgbPixels with valid inputs
449 * @tc.type: FUNC
450 */
451 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_GetArgbPixels_Test001, TestSize.Level3)
452 {
453 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetArgbPixels_Test001 start";
454
455 size_t dataSize = ARGB_8888_BYTES;
456 uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
457 OH_Pixelmap_InitializationOptions *createOpts;
458 OH_PixelmapInitializationOptions_Create(&createOpts);
459 OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
460 OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
461 OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
462 OH_PixelmapNative *pixelMap = nullptr;
463 Image_ErrorCode errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
464 ASSERT_EQ(errCode, IMAGE_SUCCESS);
465
466 uint8_t result[ARGB_8888_BYTES];
467 errCode = OH_PixelmapNative_GetArgbPixels(pixelMap, result, &dataSize);
468 ASSERT_EQ(errCode, IMAGE_SUCCESS);
469 ASSERT_EQ(result[0], data[3]);
470 ASSERT_EQ(result[1], data[2]);
471 ASSERT_EQ(result[2], data[1]);
472 ASSERT_EQ(result[3], data[0]);
473
474 OH_PixelmapNative_Release(pixelMap);
475 OH_PixelmapInitializationOptions_Release(createOpts);
476
477 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetArgbPixels_Test001 end";
478 }
479
480 /**
481 * @tc.name: OH_PixelmapNative_GetArgbPixels_Test002
482 * @tc.desc: Test OH_PixelmapNative_GetArgbPixels with invalid inputs
483 * @tc.type: FUNC
484 */
485 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_GetArgbPixels_Test002, TestSize.Level3)
486 {
487 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetArgbPixels_Test002 start";
488 OH_PixelmapNative *pixelMap = nullptr;
489 uint8_t *buffer = nullptr;
490 size_t *bufferSize = nullptr;
491 Image_ErrorCode errCode = OH_PixelmapNative_GetArgbPixels(pixelMap, buffer, bufferSize);
492 ASSERT_EQ(errCode, IMAGE_BAD_PARAMETER);
493 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetArgbPixels_Test002 end";
494 }
495
496 /**
497 * @tc.name: OH_PixelmapNative_GetImageInfo
498 * @tc.desc: OH_PixelmapNative_GetImageInfo
499 * @tc.type: FUNC
500 */
501 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_GetImageInfo, TestSize.Level3)
502 {
503 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetImageInfo start";
504 OH_PixelmapNative *pixelMap = nullptr;
505 OH_Pixelmap_ImageInfo *imageInfo = nullptr;
506 Image_ErrorCode ret = OH_PixelmapNative_GetImageInfo(pixelMap, imageInfo);
507 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
508 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetImageInfo end";
509 }
510
511 /**
512 * @tc.name: OH_PixelmapNative_Opacity
513 * @tc.desc: OH_PixelmapNative_Opacity
514 * @tc.type: FUNC
515 */
516 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Opacity, TestSize.Level3)
517 {
518 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Opacity start";
519 OH_PixelmapNative *pixelMap = nullptr;
520 float rate = 0;
521 Image_ErrorCode ret = OH_PixelmapNative_Opacity(pixelMap, rate);
522 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
523 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Opacity end";
524 }
525
526 /**
527 * @tc.name: OH_PixelmapNative_Scale
528 * @tc.desc: OH_PixelmapNative_Scale
529 * @tc.type: FUNC
530 */
531 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Scale, TestSize.Level3)
532 {
533 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Scale start";
534 OH_PixelmapNative *pixelMap = nullptr;
535 float x = 0;
536 float y = 0;
537 Image_ErrorCode ret = OH_PixelmapNative_Scale(pixelMap, x, y);
538 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
539 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Scale end";
540 }
541
542 /**
543 * @tc.name: OH_PixelmapNative_ScaleWithAntiAliasing
544 * @tc.desc: OH_PixelmapNative_ScaleWithAntiAliasing
545 * @tc.type: FUNC
546 */
547 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ScaleWithAntiAliasing, TestSize.Level3)
548 {
549 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ScaleWithAntiAliasing start";
550 OH_PixelmapNative *pixelMap = nullptr;
551 float x = 0;
552 float y = 0;
553 Image_ErrorCode ret = OH_PixelmapNative_ScaleWithAntiAliasing(pixelMap, x, y,
554 OH_PixelmapNative_AntiAliasingLevel::OH_PixelmapNative_AntiAliasing_NONE);
555 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
556 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ScaleWithAntiAliasing end";
557 }
558
559 /**
560 * @tc.name: OH_PixelmapNative_Translate
561 * @tc.desc: OH_PixelmapNative_Translate
562 * @tc.type: FUNC
563 */
564 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Translate, TestSize.Level3)
565 {
566 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Translate start";
567 OH_PixelmapNative *pixelMap = nullptr;
568 float x = 0;
569 float y = 0;
570 Image_ErrorCode ret = OH_PixelmapNative_Translate(pixelMap, x, y);
571 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
572 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Translate end";
573 }
574
575 /**
576 * @tc.name: OH_PixelmapNative_Rotate
577 * @tc.desc: OH_PixelmapNative_Rotate
578 * @tc.type: FUNC
579 */
580 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Rotate, TestSize.Level3)
581 {
582 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Rotate start";
583 OH_PixelmapNative *pixelMap = nullptr;
584 float angle = 0;
585 Image_ErrorCode ret = OH_PixelmapNative_Rotate(pixelMap, angle);
586 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
587 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Rotate end";
588 }
589
590 /**
591 * @tc.name: OH_PixelmapNative_Flip
592 * @tc.desc: OH_PixelmapNative_Flip
593 * @tc.type: FUNC
594 */
595 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Flip, TestSize.Level3)
596 {
597 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Flip start";
598 OH_PixelmapNative *pixelMap = nullptr;
599 bool horizontal = 0;
600 bool vertical = 0;
601 Image_ErrorCode ret = OH_PixelmapNative_Flip(pixelMap, horizontal, vertical);
602 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
603 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Flip end";
604 }
605
606 /**
607 * @tc.name: OH_PixelmapNative_Crop
608 * @tc.desc: OH_PixelmapNative_Crop
609 * @tc.type: FUNC
610 */
611 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Crop, TestSize.Level3)
612 {
613 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Crop start";
614 OH_PixelmapNative *pixelMap = nullptr;
615 Image_Region *region = nullptr;
616 Image_ErrorCode ret = OH_PixelmapNative_Crop(pixelMap, region);
617 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
618 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Crop end";
619 }
620
621 /**
622 * @tc.name: OH_PixelmapNative_Release
623 * @tc.desc: OH_PixelmapNative_Release
624 * @tc.type: FUNC
625 */
626 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Release, TestSize.Level3)
627 {
628 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Release start";
629 OH_PixelmapNative *pixelMap = nullptr;
630 Image_ErrorCode ret = OH_PixelmapNative_Release(pixelMap);
631 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
632 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Release end";
633 }
634
635 /**
636 * @tc.name: OH_PixelmapImageInfo_GetMimeType001
637 * @tc.desc: test OH_PixelmapImageInfo_GetMimeType
638 * @tc.type: FUNC
639 */
640 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetMimeType001, TestSize.Level3)
641 {
642 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetMimeType001 start";
643 OH_Pixelmap_ImageInfo *info1 = nullptr;
644 Image_ErrorCode ret = OH_PixelmapImageInfo_Create(&info1);
645 ASSERT_EQ(ret, IMAGE_SUCCESS);
646 ASSERT_NE(info1, nullptr);
647 OH_Pixelmap_ImageInfo *info2 = nullptr;
648
649 Image_MimeType mimeType1;
650 Image_MimeType *mimeType2 = nullptr;
651 ret = OH_PixelmapImageInfo_GetMimeType(info1, &mimeType1);
652 EXPECT_EQ(ret, IMAGE_UNKNOWN_MIME_TYPE);
653 ret = OH_PixelmapImageInfo_GetMimeType(info2, &mimeType1);
654 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
655 ret = OH_PixelmapImageInfo_GetMimeType(info1, mimeType2);
656 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
657 ret = OH_PixelmapImageInfo_GetMimeType(info2, mimeType2);
658 EXPECT_EQ(ret, IMAGE_BAD_PARAMETER);
659
660 ret = OH_PixelmapImageInfo_Release(info1);
661 EXPECT_EQ(ret, IMAGE_SUCCESS);
662 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetMimeType001 end";
663 }
664
665 /**
666 * @tc.name: OH_PixelmapImageInfo_GetMimeType002
667 * @tc.desc: test OH_PixelmapImageInfo_GetMimeType
668 * @tc.type: FUNC
669 */
670 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetMimeType002, TestSize.Level3)
671 {
672 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetMimeType002 start";
673 OH_Pixelmap_ImageInfo *info = nullptr;
674 Image_ErrorCode ret = OH_PixelmapImageInfo_Create(&info);
675 ASSERT_EQ(ret, IMAGE_SUCCESS);
676
677 Image_MimeType mimeType;
678 ret = OH_PixelmapImageInfo_GetMimeType(info, &mimeType);
679 EXPECT_EQ(ret, IMAGE_UNKNOWN_MIME_TYPE);
680
681 info->mimeType.size = TWO;
682 ret = OH_PixelmapImageInfo_GetMimeType(info, &mimeType);
683 EXPECT_EQ(ret, IMAGE_UNKNOWN_MIME_TYPE);
684
685 ret = OH_PixelmapImageInfo_Release(info);
686 EXPECT_EQ(ret, IMAGE_SUCCESS);
687 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetMimeType002 end";
688 }
689
690 /**
691 * @tc.name: OH_PixelmapImageInfo_GetMimeType003
692 * @tc.desc: test OH_PixelmapImageInfo_GetMimeType
693 * @tc.type: FUNC
694 */
695 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetMimeType003, TestSize.Level3)
696 {
697 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetMimeType003 start";
698 size_t length = IMAGE_JPEG_PATH_TEST.size();
699 char filePath[length + 1];
700 strcpy_s(filePath, sizeof(filePath), IMAGE_JPEG_PATH_TEST.c_str());
701
702 OH_ImageSourceNative *source = nullptr;
703 Image_ErrorCode ret = OH_ImageSourceNative_CreateFromUri(filePath, length, &source);
704 EXPECT_EQ(ret, IMAGE_SUCCESS);
705 ASSERT_NE(source, nullptr);
706
707 OH_DecodingOptions *opts = nullptr;
708 OH_DecodingOptions_Create(&opts);
709 OH_PixelmapNative *pixelmap = nullptr;
710 ret = OH_ImageSourceNative_CreatePixelmap(source, opts, &pixelmap);
711 EXPECT_EQ(ret, IMAGE_SUCCESS);
712 ASSERT_NE(pixelmap, nullptr);
713
714 OH_Pixelmap_ImageInfo *imageInfo = nullptr;
715 OH_PixelmapImageInfo_Create(&imageInfo);
716 ret = OH_PixelmapNative_GetImageInfo(pixelmap, imageInfo);
717 EXPECT_EQ(ret, IMAGE_SUCCESS);
718 ASSERT_NE(imageInfo, nullptr);
719
720 Image_MimeType mimeType;
721 ret = OH_PixelmapImageInfo_GetMimeType(imageInfo, &mimeType);
722 EXPECT_EQ(ret, IMAGE_SUCCESS);
723 ASSERT_NE(mimeType.data, nullptr);
724 EXPECT_EQ(strcmp(mimeType.data, IMAGE_JPEG_FORMAT.c_str()), 0);
725
726 imageInfo->mimeType.size = 0;
727 ret = OH_PixelmapImageInfo_GetMimeType(imageInfo, &mimeType);
728 EXPECT_EQ(ret, IMAGE_UNKNOWN_MIME_TYPE);
729
730 OH_ImageSourceNative_Release(source);
731 OH_DecodingOptions_Release(opts);
732 OH_PixelmapNative_Release(pixelmap);
733 OH_PixelmapImageInfo_Release(imageInfo);
734 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetMimeType003 end";
735 }
736
737 /**
738 * @tc.name: OH_PixelmapInitializationOptions_SetGetSrcPixelFormat
739 * @tc.desc: OH_PixelmapInitializationOptions_SetGetSrcPixelFormat
740 * @tc.type: FUNC
741 */
742 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetSrcPixelFormat, TestSize.Level3)
743 {
744 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_InitializationSetOptionsGetSrcPixelFormat start";
745 OH_Pixelmap_InitializationOptions *ops = nullptr;
746 OH_PixelmapInitializationOptions_Create(&ops);
747 int32_t srcpixelFormat = 0;
748 OH_PixelmapInitializationOptions_SetSrcPixelFormat(ops, 1);
749 OH_PixelmapInitializationOptions_GetSrcPixelFormat(ops, &srcpixelFormat);
750 ASSERT_EQ(srcpixelFormat, 1);
751 Image_ErrorCode ret = OH_PixelmapInitializationOptions_Release(ops);
752 ASSERT_EQ(ret, IMAGE_SUCCESS);
753 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_InitializationSetOptionsGetSrcPixelFormat end";
754 }
755
756 /**
757 * @tc.name: OH_PixelmapNative_CreateEmptyPixelmap
758 * @tc.desc: OH_PixelmapNative_CreateEmptyPixelmap
759 * @tc.type: FUNC
760 */
761 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_CreateEmptyPixelmap, TestSize.Level3)
762 {
763 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreateEmptyPixelmap start";
764 OH_Pixelmap_InitializationOptions *options = nullptr;
765 OH_PixelmapNative **pixelmap = nullptr;
766 Image_ErrorCode ret = OH_PixelmapNative_CreateEmptyPixelmap(options, pixelmap);
767 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
768 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreateEmptyPixelmap end";
769 }
770
771 /**
772 * @tc.name: OH_PixelmapNative_ConvertAlphaFormat
773 * @tc.desc: OH_PixelmapNative_ConvertAlphaFormat
774 * @tc.type: FUNC
775 */
776 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ConvertAlphaFormat, TestSize.Level3)
777 {
778 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertAlphaFormat start";
779 OH_PixelmapNative* srcpixelmap = nullptr;
780 OH_PixelmapNative* dstpixelmap = nullptr;
781 const bool isPremul = false;
782 Image_ErrorCode ret = OH_PixelmapNative_ConvertAlphaFormat(srcpixelmap, dstpixelmap, isPremul);
783 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
784 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertAlphaFormat end";
785 }
786
CreateMetadataValue(OH_Pixelmap_HdrMetadataValue & value)787 static void CreateMetadataValue(OH_Pixelmap_HdrMetadataValue &value)
788 {
789 OH_Pixelmap_HdrMetadataType &type = value.type;
790 type = OH_Pixelmap_HdrMetadataType(THREE);
791 float base = PRIMARIES;
792 uint32_t version = VERSION_VALUE;
793
794 OH_Pixelmap_HdrStaticMetadata &staticMetadata = value.staticMetadata;
795 staticMetadata.displayPrimariesX[ZERO] = base++;
796 staticMetadata.displayPrimariesX[ONE] = base++;
797 staticMetadata.displayPrimariesX[TWO] = base++;
798 staticMetadata.displayPrimariesY[ZERO] = base++;
799 staticMetadata.displayPrimariesY[ONE] = base++;
800 staticMetadata.displayPrimariesY[TWO] = base++;
801 staticMetadata.whitePointX = base++;
802 staticMetadata.whitePointY = base++;
803 staticMetadata.maxLuminance = base++;
804 staticMetadata.minLuminance = base++;
805 staticMetadata.maxContentLightLevel = base++;
806 staticMetadata.maxFrameAverageLightLevel = base++;
807
808 OH_Pixelmap_HdrGainmapMetadata &gainmapMetadata = value.gainmapMetadata;
809 gainmapMetadata.writerVersion = version++;
810 gainmapMetadata.minVersion = version++;
811 gainmapMetadata.gainmapChannelNum = version++;
812 gainmapMetadata.useBaseColorFlag = true;
813 gainmapMetadata.baseHdrHeadroom = base++;
814 gainmapMetadata.alternateHdrHeadroom = base++;
815 gainmapMetadata.gainmapMax[ZERO] = base++;
816 gainmapMetadata.gainmapMax[ONE] = base++;
817 gainmapMetadata.gainmapMax[TWO] = base++;
818 gainmapMetadata.gainmapMax[ZERO] = base++;
819 gainmapMetadata.gainmapMax[ONE] = base++;
820 gainmapMetadata.gainmapMax[TWO] = base++;
821 gainmapMetadata.gamma[ZERO] = base++;
822 gainmapMetadata.gamma[ONE] = base++;
823 gainmapMetadata.gamma[TWO] = base++;
824 gainmapMetadata.baselineOffset[ZERO] = base++;
825 gainmapMetadata.baselineOffset[ONE] = base++;
826 gainmapMetadata.baselineOffset[TWO] = base++;
827 gainmapMetadata.alternateOffset[ZERO] = base++;
828 gainmapMetadata.alternateOffset[ONE] = base++;
829 gainmapMetadata.alternateOffset[TWO] = base++;
830 }
831
DumpMetadata(OH_Pixelmap_HdrMetadataValue value)832 static void DumpMetadata(OH_Pixelmap_HdrMetadataValue value)
833 {
834 GTEST_LOG_(INFO) << "DumpMetadata Dump IN";
835 OH_Pixelmap_HdrMetadataType &type = value.type;
836 GTEST_LOG_(INFO) << "DumpMetadata : " << type;
837 OH_Pixelmap_HdrStaticMetadata &staticMetadata = value.staticMetadata;
838 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.displayPrimariesX[ZERO];
839 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.displayPrimariesX[ONE];
840 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.displayPrimariesX[TWO];
841 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.displayPrimariesY[ZERO];
842 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.displayPrimariesY[ONE];
843 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.displayPrimariesY[TWO];
844 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.whitePointX;
845 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.whitePointY;
846 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.maxLuminance;
847 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.minLuminance;
848 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.maxContentLightLevel;
849 GTEST_LOG_(INFO) << "DumpMetadata : " << staticMetadata.maxFrameAverageLightLevel;
850 OH_Pixelmap_HdrGainmapMetadata &gainmapMetadata = value.gainmapMetadata;
851 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.writerVersion;
852 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.minVersion;
853 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gainmapChannelNum;
854 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.useBaseColorFlag;
855 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.baseHdrHeadroom;
856 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.alternateHdrHeadroom;
857 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gainmapMax[ZERO];
858 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gainmapMax[ONE];
859 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gainmapMax[TWO];
860 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gainmapMax[ZERO];
861 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gainmapMax[ONE];
862 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gainmapMax[TWO];
863 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gamma[ZERO];
864 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gamma[ONE];
865 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.gamma[TWO];
866 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.baselineOffset[ZERO];
867 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.baselineOffset[ONE];
868 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.baselineOffset[TWO];
869 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.alternateOffset[ZERO];
870 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.alternateOffset[ONE];
871 GTEST_LOG_(INFO) << "DumpMetadata : " << gainmapMetadata.alternateOffset[TWO];
872 GTEST_LOG_(INFO) << "DumpMetadata Dump OUT";
873 }
874
SetMetadata(OH_Pixelmap_HdrMetadataValue & value,OH_PixelmapNative * pixelmapNative)875 Image_ErrorCode SetMetadata(OH_Pixelmap_HdrMetadataValue &value, OH_PixelmapNative *pixelmapNative)
876 {
877 GTEST_LOG_(INFO) << "SetMetadata IN";
878 Image_ErrorCode errorCode = IMAGE_SUCCESS;
879 errorCode = OH_PixelmapNative_SetMetadata(pixelmapNative, OH_Pixelmap_HdrMetadataKey(ZERO), &value);
880 errorCode = OH_PixelmapNative_SetMetadata(pixelmapNative, OH_Pixelmap_HdrMetadataKey(ONE), &value);
881 errorCode = OH_PixelmapNative_SetMetadata(pixelmapNative, OH_Pixelmap_HdrMetadataKey(THREE), &value);
882 GTEST_LOG_(INFO) << "SetMetadata OUT";
883 return errorCode;
884 }
885
GetMetadata(OH_Pixelmap_HdrMetadataValue & value,OH_PixelmapNative * pixelmapNative)886 Image_ErrorCode GetMetadata(OH_Pixelmap_HdrMetadataValue &value,
887 OH_PixelmapNative *pixelmapNative)
888 {
889 GTEST_LOG_(INFO) << "SetMetadata IN";
890 Image_ErrorCode errorCode = IMAGE_SUCCESS;
891 OH_Pixelmap_HdrMetadataValue* vv = &value;
892 errorCode = OH_PixelmapNative_GetMetadata(pixelmapNative,
893 OH_Pixelmap_HdrMetadataKey(ZERO), &vv);
894 errorCode = OH_PixelmapNative_GetMetadata(pixelmapNative,
895 OH_Pixelmap_HdrMetadataKey(ONE), &vv);
896 errorCode = OH_PixelmapNative_GetMetadata(pixelmapNative,
897 OH_Pixelmap_HdrMetadataKey(THREE), &vv);
898 GTEST_LOG_(INFO) << "SetMetadata OUT";
899 return errorCode;
900 }
901
902 /**
903 * @tc.name: OH_PixelmapNative_SetMetadata
904 * @tc.desc: OH_PixelmapNative_SetMetadata
905 * @tc.type: FUNC
906 */
907 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_SetMetadata, TestSize.Level3)
908 {
909 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_SetMetadata start";
910 Image_ErrorCode errorCode = IMAGE_SUCCESS;
911 std::string realPath;
912 if (!ImageUtils::PathToRealPath(IMAGE_JPEG_PATH.c_str(), realPath)) {
913 if (!ImageUtils::PathToRealPath(IMAGE_JPEG_PATH_TEST.c_str(), realPath)) {
914 return;
915 }
916 }
917 char filePath[bufferSize];
918 if (strcpy_s(filePath, sizeof(filePath), realPath.c_str()) != EOK) {
919 return;
920 }
921 size_t length = realPath.size();
922 OH_ImageSourceNative *source = nullptr;
923 Image_ErrorCode ret = OH_ImageSourceNative_CreateFromUri(filePath, length, &source);
924 EXPECT_EQ(ret, IMAGE_SUCCESS);
925
926 OH_DecodingOptions *opts = nullptr;
927 OH_PixelmapNative *pixelmap = nullptr;
928 OH_DecodingOptions_Create(&opts);
929
930 ret = OH_ImageSourceNative_CreatePixelmap(source, opts, &pixelmap);
931 EXPECT_EQ(ret, IMAGE_SUCCESS);
932 OH_Pixelmap_HdrMetadataValue setValue;
933 CreateMetadataValue(setValue);
934 DumpMetadata(setValue);
935 errorCode = SetMetadata(setValue, pixelmap);
936 if (errorCode == IMAGE_DMA_NOT_EXIST) {
937 GTEST_LOG_(INFO) << "PixelMapNdk2Test pixelmap is not DMA";
938 return;
939 }
940 OH_Pixelmap_HdrMetadataValue getValue;
941 GetMetadata(getValue, pixelmap);
942 DumpMetadata(getValue);
943 EXPECT_EQ(errorCode, IMAGE_SUCCESS);
944 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_SetMetadata end";
945 }
946
947 /**
948 * @tc.name: OH_PixelmapNative_SetGetColorSpace
949 * @tc.desc: OH_PixelmapNative_SetGetColorSpace
950 * @tc.type: FUNC
951 */
952 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_SetGetColorSpace, TestSize.Level3)
953 {
954 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_SetGetColorSpace start";
955 OH_PixelmapNative *pixelmap = nullptr;
956 CreatePixelmapNative(&pixelmap);
957 EXPECT_NE(pixelmap, nullptr);
958
959 OH_NativeColorSpaceManager *setColorSpaceNative = nullptr;
960 ColorSpaceName setColorSpaceName = SRGB_LIMIT;
961 setColorSpaceNative = OH_NativeColorSpaceManager_CreateFromName(setColorSpaceName);
962 Image_ErrorCode ret = OH_PixelmapNative_SetColorSpaceNative(pixelmap, setColorSpaceNative);
963 EXPECT_EQ(ret, IMAGE_SUCCESS);
964
965 OH_NativeColorSpaceManager *getColorSpaceNative = nullptr;
966 ret = OH_PixelmapNative_GetColorSpaceNative(pixelmap, &getColorSpaceNative);
967 EXPECT_EQ(ret, IMAGE_SUCCESS);
968
969 int getColorSpaceName = OH_NativeColorSpaceManager_GetColorSpaceName(getColorSpaceNative);
970 EXPECT_EQ(setColorSpaceName, getColorSpaceName);
971
972 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_SetGetColorSpace end";
973 }
974
975 /**
976 * @tc.name: OH_PixelmapNative_GetByteCount
977 * @tc.desc: Test OH_PixelmapNative_GetByteCount and OH_PixelmapNative_GetAllocationByteCount
978 * @tc.type: FUNC
979 */
980 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_GetByteCount, TestSize.Level3)
981 {
982 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetByteCount start";
983
984 OH_Pixelmap_InitializationOptions* options = nullptr;
985 OH_PixelmapInitializationOptions_Create(&options);
986 OH_PixelmapInitializationOptions_SetWidth(options, 1);
987 OH_PixelmapInitializationOptions_SetHeight(options, 1);
988 OH_PixelmapNative* pixelmap = nullptr;
989 Image_ErrorCode ret = OH_PixelmapNative_CreateEmptyPixelmap(options, &pixelmap);
990 ASSERT_EQ(ret, IMAGE_SUCCESS);
991 uint32_t byteCount = 0;
992 ret = OH_PixelmapNative_GetByteCount(pixelmap, &byteCount);
993 ASSERT_EQ(ret, IMAGE_SUCCESS);
994 uint32_t allocByteCount = 0;
995 ret = OH_PixelmapNative_GetAllocationByteCount(pixelmap, &allocByteCount);
996 ASSERT_EQ(ret, IMAGE_SUCCESS);
997 ASSERT_TRUE(byteCount == ARGB_8888_BYTES && allocByteCount >= byteCount);
998
999 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetByteCount end";
1000 }
1001
1002 /**
1003 * @tc.name: OH_PixelmapNative_CreateScaledPixelMapWithAntiAliasing
1004 * @tc.desc: OH_PixelmapNative_CreateScaledPixelMapWithAntiAliasing
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_CreateScaledPixelMapWithAntiAliasing, TestSize.Level3)
1008 {
1009 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreateScaledPixelMapWithAntiAliasing start";
1010 OH_PixelmapNative *srcPixelmap = nullptr;
1011 CreatePixelmapNative(&srcPixelmap);
1012 EXPECT_NE(srcPixelmap, nullptr);
1013
1014 OH_Pixelmap_ImageInfo *srcImageInfoBefore = nullptr;
1015 OH_PixelmapImageInfo_Create(&srcImageInfoBefore);
1016 OH_PixelmapNative_GetImageInfo(srcPixelmap, srcImageInfoBefore);
1017
1018 OH_PixelmapNative *dstPixelmap = nullptr;
1019 float scaleX = 0.5;
1020 float scaleY = 0.5;
1021 Image_ErrorCode ret = OH_PixelmapNative_CreateScaledPixelMapWithAntiAliasing(srcPixelmap, &dstPixelmap,
1022 scaleX, scaleY, OH_PixelmapNative_AntiAliasingLevel::OH_PixelmapNative_AntiAliasing_HIGH);
1023 EXPECT_EQ(ret, IMAGE_SUCCESS);
1024
1025 EXPECT_NE(dstPixelmap, nullptr);
1026 OH_Pixelmap_ImageInfo *dstImageInfo = nullptr;
1027 OH_PixelmapImageInfo_Create(&dstImageInfo);
1028 OH_PixelmapNative_GetImageInfo(dstPixelmap, dstImageInfo);
1029
1030 OH_Pixelmap_ImageInfo *srcImageInfoAfter = nullptr;
1031 OH_PixelmapImageInfo_Create(&srcImageInfoAfter);
1032 OH_PixelmapNative_GetImageInfo(srcPixelmap, srcImageInfoAfter);
1033 EXPECT_EQ(CompareImageInfo(srcImageInfoAfter, srcImageInfoBefore), true);
1034
1035 OH_PixelmapNative *sameSrcPixelmap = nullptr;
1036 CreatePixelmapNative(&sameSrcPixelmap);
1037 EXPECT_NE(sameSrcPixelmap, nullptr);
1038 ret = OH_PixelmapNative_ScaleWithAntiAliasing(sameSrcPixelmap, scaleX, scaleY,
1039 OH_PixelmapNative_AntiAliasingLevel::OH_PixelmapNative_AntiAliasing_HIGH);
1040 EXPECT_EQ(ret, IMAGE_SUCCESS);
1041
1042 OH_Pixelmap_ImageInfo *sameSrcImageInfo = nullptr;
1043 OH_PixelmapImageInfo_Create(&sameSrcImageInfo);
1044 OH_PixelmapNative_GetImageInfo(sameSrcPixelmap, sameSrcImageInfo);
1045 EXPECT_EQ(CompareImageInfo(sameSrcImageInfo, dstImageInfo), true);
1046
1047 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreateScaledPixelMapWithAntiAliasing end";
1048 }
1049
1050 /**
1051 * @tc.name: OH_PixelmapNative_CreateScaledPixelMap
1052 * @tc.desc: OH_PixelmapNative_CreateScaledPixelMap
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_CreateScaledPixelMap, TestSize.Level3)
1056 {
1057 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreateScaledPixelMap start";
1058 OH_PixelmapNative *srcPixelmap = nullptr;
1059 CreatePixelmapNative(&srcPixelmap);
1060 EXPECT_NE(srcPixelmap, nullptr);
1061
1062 OH_Pixelmap_ImageInfo *srcImageInfoBefore = nullptr;
1063 OH_PixelmapImageInfo_Create(&srcImageInfoBefore);
1064 OH_PixelmapNative_GetImageInfo(srcPixelmap, srcImageInfoBefore);
1065
1066 OH_PixelmapNative *dstPixelmap = nullptr;
1067 float scaleX = 1.5;
1068 float scaleY = 1.5;
1069 Image_ErrorCode ret = OH_PixelmapNative_CreateScaledPixelMap(srcPixelmap, &dstPixelmap, scaleX, scaleY);
1070 EXPECT_EQ(ret, IMAGE_SUCCESS);
1071
1072 EXPECT_NE(dstPixelmap, nullptr);
1073 OH_Pixelmap_ImageInfo *dstImageInfo = nullptr;
1074 OH_PixelmapImageInfo_Create(&dstImageInfo);
1075 OH_PixelmapNative_GetImageInfo(dstPixelmap, dstImageInfo);
1076
1077 OH_Pixelmap_ImageInfo *srcImageInfoAfter = nullptr;
1078 OH_PixelmapImageInfo_Create(&srcImageInfoAfter);
1079 OH_PixelmapNative_GetImageInfo(srcPixelmap, srcImageInfoAfter);
1080 EXPECT_EQ(CompareImageInfo(srcImageInfoAfter, srcImageInfoBefore), true);
1081
1082 OH_PixelmapNative *sameSrcPixelmap = nullptr;
1083 CreatePixelmapNative(&sameSrcPixelmap);
1084 EXPECT_NE(sameSrcPixelmap, nullptr);
1085 ret = OH_PixelmapNative_Scale(sameSrcPixelmap, scaleX, scaleY);
1086 EXPECT_EQ(ret, IMAGE_SUCCESS);
1087
1088 OH_Pixelmap_ImageInfo *sameSrcImageInfo = nullptr;
1089 OH_PixelmapImageInfo_Create(&sameSrcImageInfo);
1090 OH_PixelmapNative_GetImageInfo(sameSrcPixelmap, sameSrcImageInfo);
1091 EXPECT_EQ(CompareImageInfo(sameSrcImageInfo, dstImageInfo), true);
1092
1093 GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreateScaledPixelMap end";
1094 }
1095 }
1096 }
1097
