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 #include "image_ffi.h"
16
17 #include <cstdint>
18
19 #include "cj_color_manager.h"
20 #include "image_creator_impl.h"
21 #include "image_log.h"
22 #include "image_packer_impl.h"
23 #include "image_receiver_impl.h"
24 #include "image_source_impl.h"
25 #include "image_type.h"
26 #include "js_native_api.h"
27 #include "js_native_api_types.h"
28 #include "media_errors.h"
29 #include "pixel_map_impl.h"
30 #include "pixel_map_napi.h"
31
32 using namespace OHOS::FFI;
33
34 namespace OHOS {
35 namespace Media {
36 extern "C" {
ParseCRegion(CRegion region)37 static Rect ParseCRegion(CRegion region)
38 {
39 Rect rt = {
40 .left = region.x,
41 .top = region.y,
42 .width = region.size.width,
43 .height = region.size.height,
44 };
45 return rt;
46 }
47
48 //--------------------- ImageSource ------------------------------------------------------------------------
49 static const std::string FILE_URL_PREFIX = "file://";
FileUrlToRawPath(const std::string & path)50 static std::string FileUrlToRawPath(const std::string& path)
51 {
52 if (path.size() > FILE_URL_PREFIX.size() && (path.compare(0, FILE_URL_PREFIX.size(), FILE_URL_PREFIX) == 0)) {
53 return path.substr(FILE_URL_PREFIX.size());
54 }
55 return path;
56 }
57
FfiOHOSCreateImageSourceByPath(char * uri,uint32_t * errCode)58 int64_t FfiOHOSCreateImageSourceByPath(char* uri, uint32_t* errCode)
59 {
60 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByPath start");
61 std::string path = FileUrlToRawPath(uri);
62 std::unique_ptr<ImageSource> ptr_ = ImageSourceImpl::CreateImageSource(path, errCode);
63 if (*errCode != SUCCESS_CODE) {
64 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
65 return INIT_FAILED;
66 }
67 auto nativeImage = FFIData::Create<ImageSourceImpl>(move(ptr_));
68 if (!nativeImage) {
69 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
70 *errCode = ERR_IMAGE_INIT_ABNORMAL;
71 return INIT_FAILED;
72 }
73 nativeImage->SetPathName(path);
74 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByPath success");
75 return nativeImage->GetID();
76 }
77
ParseCSourceOptions(CSourceOptions opts)78 static SourceOptions ParseCSourceOptions(CSourceOptions opts)
79 {
80 SourceOptions options;
81 options.baseDensity = opts.baseDensity;
82 options.pixelFormat = PixelFormat(opts.pixelFormat);
83 options.size.height = opts.height;
84 options.size.width = opts.width;
85 IMAGE_LOGD("[ImageSource] SourceOptions height is %{public}d, width is %{public}d", options.size.height,
86 options.size.width);
87 return options;
88 }
89
FfiOHOSCreateImageSourceByPathWithOption(char * uri,CSourceOptions opts,uint32_t * errCode)90 int64_t FfiOHOSCreateImageSourceByPathWithOption(char* uri, CSourceOptions opts, uint32_t* errCode)
91 {
92 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByPathWithOption start");
93 std::string path = FileUrlToRawPath(uri);
94 SourceOptions options = ParseCSourceOptions(opts);
95 std::unique_ptr<ImageSource> ptr_ = ImageSourceImpl::CreateImageSourceWithOption(path, options, errCode);
96 if (*errCode != SUCCESS_CODE) {
97 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPathWithOption failed");
98 return INIT_FAILED;
99 }
100 auto nativeImage = FFIData::Create<ImageSourceImpl>(move(ptr_));
101 if (!nativeImage) {
102 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
103 *errCode = ERR_IMAGE_INIT_ABNORMAL;
104 return INIT_FAILED;
105 }
106 nativeImage->SetPathName(path);
107 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByPathWithOption success");
108 return nativeImage->GetID();
109 }
110
FfiOHOSCreateImageSourceByFd(int fd,uint32_t * errCode)111 int64_t FfiOHOSCreateImageSourceByFd(int fd, uint32_t* errCode)
112 {
113 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByFd start");
114 std::unique_ptr<ImageSource> ptr_ = ImageSourceImpl::CreateImageSource(fd, errCode);
115 if (*errCode != SUCCESS_CODE) {
116 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByFd failed");
117 return INIT_FAILED;
118 }
119 auto nativeImage = FFIData::Create<ImageSourceImpl>(move(ptr_));
120 if (!nativeImage) {
121 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
122 *errCode = ERR_IMAGE_INIT_ABNORMAL;
123 return INIT_FAILED;
124 }
125 nativeImage->SetFd(fd);
126 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByFd success");
127 return nativeImage->GetID();
128 }
129
FfiOHOSCreateImageSourceByFdWithOption(int fd,CSourceOptions opts,uint32_t * errCode)130 int64_t FfiOHOSCreateImageSourceByFdWithOption(int fd, CSourceOptions opts, uint32_t* errCode)
131 {
132 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByFdWithOption start");
133 SourceOptions options = ParseCSourceOptions(opts);
134 std::unique_ptr<ImageSource> ptr_ = ImageSourceImpl::CreateImageSourceWithOption(fd, options, errCode);
135 if (*errCode != SUCCESS_CODE) {
136 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByFdWithOption failed");
137 return INIT_FAILED;
138 }
139 auto nativeImage = FFIData::Create<ImageSourceImpl>(move(ptr_));
140 if (!nativeImage) {
141 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
142 *errCode = ERR_IMAGE_INIT_ABNORMAL;
143 return INIT_FAILED;
144 }
145 nativeImage->SetFd(fd);
146 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByFdWithOption success");
147 return nativeImage->GetID();
148 }
149
FfiOHOSCreateImageSourceByBuffer(uint8_t * data,uint32_t size,uint32_t * errCode)150 int64_t FfiOHOSCreateImageSourceByBuffer(uint8_t* data, uint32_t size, uint32_t* errCode)
151 {
152 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByBuffer start");
153 std::unique_ptr<ImageSource> ptr_ = ImageSourceImpl::CreateImageSource(data, size, errCode);
154 if (*errCode != SUCCESS_CODE) {
155 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByBuffer failed");
156 return INIT_FAILED;
157 }
158 auto nativeImage = FFIData::Create<ImageSourceImpl>(move(ptr_));
159 if (!nativeImage) {
160 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
161 *errCode = ERR_IMAGE_INIT_ABNORMAL;
162 return INIT_FAILED;
163 }
164 nativeImage->SetBuffer(data, size);
165 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByBuffer success");
166 return nativeImage->GetID();
167 }
168
FfiOHOSCreateImageSourceByBufferWithOption(uint8_t * data,uint32_t size,CSourceOptions opts,uint32_t * errCode)169 int64_t FfiOHOSCreateImageSourceByBufferWithOption(uint8_t* data, uint32_t size, CSourceOptions opts, uint32_t* errCode)
170 {
171 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByBufferWithOption start");
172 SourceOptions options = ParseCSourceOptions(opts);
173 std::unique_ptr<ImageSource> ptr_ = ImageSourceImpl::CreateImageSourceWithOption(data, size, options, errCode);
174 if (*errCode != SUCCESS_CODE) {
175 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByBufferWithOption failed");
176 return INIT_FAILED;
177 }
178 auto nativeImage = FFIData::Create<ImageSourceImpl>(move(ptr_));
179 if (!nativeImage) {
180 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
181 *errCode = ERR_IMAGE_INIT_ABNORMAL;
182 return INIT_FAILED;
183 }
184 nativeImage->SetBuffer(data, size);
185 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByBufferWithOption success");
186 return nativeImage->GetID();
187 }
188
FfiOHOSCreateImageSourceByRawFile(int fd,int32_t offset,int32_t length,CSourceOptions opts,uint32_t * errCode)189 int64_t FfiOHOSCreateImageSourceByRawFile(
190 int fd, int32_t offset, int32_t length, CSourceOptions opts, uint32_t* errCode)
191 {
192 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByRawFile start");
193 SourceOptions options = ParseCSourceOptions(opts);
194 std::unique_ptr<ImageSource> ptr_ = ImageSourceImpl::CreateImageSource(fd, offset, length, options, *errCode);
195 if (*errCode != SUCCESS_CODE) {
196 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByRawFile failed");
197 return INIT_FAILED;
198 }
199 auto nativeImage = FFIData::Create<ImageSourceImpl>(move(ptr_));
200 if (!nativeImage) {
201 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
202 *errCode = ERR_IMAGE_INIT_ABNORMAL;
203 return INIT_FAILED;
204 }
205 IMAGE_LOGD("[ImageSource] FfiOHOSCreateImageSourceByRawFile success");
206 return nativeImage->GetID();
207 }
208
FfiOHOSCreateIncrementalSource(const uint8_t * data,uint32_t size,CSourceOptions opts,uint32_t * errCode)209 int64_t FfiOHOSCreateIncrementalSource(const uint8_t* data, uint32_t size, CSourceOptions opts, uint32_t* errCode)
210 {
211 IMAGE_LOGD("[ImageSource] FfiOHOSCreateIncrementalSource start");
212 SourceOptions options = ParseCSourceOptions(opts);
213 auto ptr = ImageSourceImpl::CreateIncrementalSource(data, size, options, *errCode);
214 if (*errCode != SUCCESS_CODE) {
215 return INIT_FAILED;
216 }
217 auto nativeImage = FFIData::Create<ImageSourceImpl>(move(std::get<0>(ptr)), move(std::get<1>(ptr)));
218 if (!nativeImage) {
219 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
220 *errCode = ERR_IMAGE_INIT_ABNORMAL;
221 return INIT_FAILED;
222 }
223 IMAGE_LOGD("[ImageSource] FfiOHOSCreateIncrementalSource success");
224
225 return nativeImage->GetID();
226 }
227
FfiOHOSImageSourceGetImageInfo(int64_t id,uint32_t index,uint32_t * errCode)228 CImageInfo FfiOHOSImageSourceGetImageInfo(int64_t id, uint32_t index, uint32_t* errCode)
229 {
230 IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceGetImageInfo start");
231 auto instance = FFIData::GetData<ImageSourceImpl>(id);
232 CImageInfo ret = {};
233 if (!instance) {
234 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
235 *errCode = ERR_IMAGE_INIT_ABNORMAL;
236 return ret;
237 }
238 ImageInfo info;
239 *errCode = instance->GetImageInfo(index, info);
240 if (*errCode != 0) {
241 return ret;
242 }
243 ret.height = info.size.height;
244 ret.width = info.size.width;
245 ret.density = info.baseDensity;
246 IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceGetImageInfo success");
247 return ret;
248 }
249
ParseImageSourceImageInfo(ImageInfo info,ImageSource * imageSource)250 static CImageInfoV2 ParseImageSourceImageInfo(ImageInfo info, ImageSource* imageSource)
251 {
252 CImageInfoV2 ret = {};
253 ret.height = info.size.height;
254 ret.width = info.size.width;
255 ret.density = info.baseDensity;
256 ret.pixelFormat = static_cast<int32_t>(info.pixelFormat);
257 ret.alphaType = static_cast<int32_t>(info.alphaType);
258 ret.mimeType = Utils::MallocCString(info.encodedFormat);
259 ret.isHdr = imageSource->IsHdrImage();
260 return ret;
261 }
262
FfiOHOSImageSourceGetImageInfoV2(int64_t id,uint32_t index,uint32_t * errCode)263 CImageInfoV2 FfiOHOSImageSourceGetImageInfoV2(int64_t id, uint32_t index, uint32_t* errCode)
264 {
265 IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceGetImageInfo start");
266 auto instance = FFIData::GetData<ImageSourceImpl>(id);
267 CImageInfoV2 ret = {};
268 if (!instance) {
269 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
270 *errCode = ERR_IMAGE_INIT_ABNORMAL;
271 return ret;
272 }
273 ImageInfo info;
274 *errCode = instance->GetImageInfo(index, info);
275 if (*errCode != 0) {
276 return ret;
277 }
278 ret = ParseImageSourceImageInfo(info, instance->nativeImgSrc.get());
279 IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceGetImageInfo success");
280 return ret;
281 }
282
FreeArrayPtr(char ** ptr,int count)283 void FreeArrayPtr(char** ptr, int count)
284 {
285 for (int i = 0; i < count; i++) {
286 free(ptr[i]);
287 }
288 }
289
FfiOHOSGetSupportedFormats(int64_t id,uint32_t * errCode)290 CArrString FfiOHOSGetSupportedFormats(int64_t id, uint32_t* errCode)
291 {
292 IMAGE_LOGD("[ImageSource] FfiOHOSGetSupportedFormats start");
293 CArrString ret = { .head = nullptr, .size = 0 };
294 *errCode = ERR_IMAGE_INIT_ABNORMAL;
295 auto instance = FFIData::GetData<ImageSourceImpl>(id);
296 if (!instance) {
297 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
298 return ret;
299 }
300 std::set<std::string> formats;
301 *errCode = instance->GetSupportedFormats(formats);
302 if (*errCode == SUCCESS_CODE) {
303 size_t size = formats.size();
304 if (size == 0) {
305 IMAGE_LOGE("[ImageSource] FfiOHOSGetSupportedFormats size cannot be equal to 0.");
306 *errCode = ERR_IMAGE_MALLOC_ABNORMAL;
307 return ret;
308 }
309
310 auto arr = static_cast<char**>(malloc(sizeof(char*) * size));
311 if (!arr) {
312 IMAGE_LOGE("[ImageSource] FfiOHOSGetSupportedFormats failed to malloc arr.");
313 *errCode = ERR_IMAGE_MALLOC_ABNORMAL;
314 return ret;
315 }
316
317 int32_t i = 0;
318 for (const std::string& str : formats) {
319 auto temp = Utils::MallocCString(str);
320 if (!temp) {
321 IMAGE_LOGE("[ImageSource] FfiOHOSGetSupportedFormats failed to copy string.");
322 FreeArrayPtr(arr, i);
323 free(arr);
324 *errCode = ERR_IMAGE_MALLOC_ABNORMAL;
325 return ret;
326 }
327 arr[i] = temp;
328 i++;
329 }
330 ret.head = arr;
331 ret.size = static_cast<int64_t>(size);
332 }
333 IMAGE_LOGD("[ImageSource] FfiOHOSGetSupportedFormats success");
334 return ret;
335 }
336
FfiOHOSGetImageProperty(int64_t id,char * key,uint32_t index,char * defaultValue,uint32_t * errCode)337 char* FfiOHOSGetImageProperty(int64_t id, char* key, uint32_t index, char* defaultValue, uint32_t* errCode)
338 {
339 IMAGE_LOGD("[ImageSource] FfiOHOSGetImageProperty start");
340 char* ret = nullptr;
341 *errCode = ERR_IMAGE_INIT_ABNORMAL;
342 auto instance = FFIData::GetData<ImageSourceImpl>(id);
343 if (!instance) {
344 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
345 return ret;
346 }
347 std::string skey = key;
348 std::string value = defaultValue;
349 *errCode = instance->GetImageProperty(skey, index, value);
350 if (*errCode != SUCCESS_CODE) {
351 return ret;
352 }
353 ret = Utils::MallocCString(value);
354 IMAGE_LOGD("[ImageSource] FfiOHOSGetImageProperty success");
355 return ret;
356 }
357
FfiOHOSModifyImageProperty(int64_t id,char * key,char * value)358 uint32_t FfiOHOSModifyImageProperty(int64_t id, char* key, char* value)
359 {
360 IMAGE_LOGD("[ImageSource] FfiOHOSModifyImageProperty start");
361 auto instance = FFIData::GetData<ImageSourceImpl>(id);
362 if (!instance) {
363 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
364 return ERR_IMAGE_INIT_ABNORMAL;
365 }
366 uint32_t ret = instance->ModifyImageProperty(key, value);
367 IMAGE_LOGD("[ImageSource] FfiOHOSModifyImageProperty success");
368 return ret;
369 }
370
FfiOHOSGetFrameCount(int64_t id)371 RetDataUI32 FfiOHOSGetFrameCount(int64_t id)
372 {
373 IMAGE_LOGD("[ImageSource] FfiOHOSGetFrameCount start");
374 RetDataUI32 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = 0 };
375 auto instance = FFIData::GetData<ImageSourceImpl>(id);
376 if (!instance) {
377 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
378 return ret;
379 }
380 ret.data = instance->GetFrameCount(ret.code);
381 IMAGE_LOGD("[ImageSource] FfiOHOSGetFrameCount success");
382 return ret;
383 }
384
FfiOHOSUpdateData(int64_t id,UpdateDataInfo info)385 uint32_t FfiOHOSUpdateData(int64_t id, UpdateDataInfo info)
386 {
387 IMAGE_LOGD("[ImageSource] FfiOHOSUpdateData start");
388 auto instance = FFIData::GetData<ImageSourceImpl>(id);
389 if (!instance) {
390 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
391 return ERR_IMAGE_INIT_ABNORMAL;
392 }
393 uint8_t* buffer = info.data;
394 if (info.offset < info.arrSize) {
395 buffer = buffer + info.offset;
396 }
397 uint32_t lastSize = info.arrSize - info.offset;
398 uint32_t size = info.updateLen < lastSize ? info.updateLen : lastSize;
399 uint32_t ret = instance->UpdateData(buffer, size, info.isCompleted);
400 if (ret == 0) {
401 auto incPixelMap = instance->GetIncrementalPixelMap();
402 if (incPixelMap != nullptr) {
403 uint8_t decodeProgress = 0;
404 uint32_t err = incPixelMap->PromoteDecoding(decodeProgress);
405 if (!(err == SUCCESS_CODE || (err == ERR_IMAGE_SOURCE_DATA_INCOMPLETE && !info.isCompleted))) {
406 IMAGE_LOGE("UpdateData PromoteDecoding error");
407 }
408 if (info.isCompleted) {
409 incPixelMap->DetachFromDecoding();
410 }
411 }
412 }
413
414 IMAGE_LOGD("[ImageSource] FfiOHOSUpdateData success");
415 return ret;
416 }
417
FfiOHOSRelease(int64_t id)418 uint32_t FfiOHOSRelease(int64_t id)
419 {
420 IMAGE_LOGD("[ImageSource] FfiOHOSRelease start");
421 auto instance = FFIData::GetData<ImageSourceImpl>(id);
422 if (!instance) {
423 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
424 return ERR_IMAGE_INIT_ABNORMAL;
425 }
426 instance->Release();
427 IMAGE_LOGD("[ImageSource] FfiOHOSRelease success");
428 return SUCCESS_CODE;
429 }
430
ParseCDecodingOptions(CDecodingOptions & opts)431 static DecodeOptions ParseCDecodingOptions(CDecodingOptions& opts)
432 {
433 DecodeOptions decodeOpts = {};
434 decodeOpts.fitDensity = opts.fitDensity;
435 decodeOpts.desiredSize.height = opts.desiredSize.height;
436 decodeOpts.desiredSize.width = opts.desiredSize.width;
437 IMAGE_LOGD("[ImageSource] desiredSize height is %{public}d, width is %{public}d", decodeOpts.desiredSize.height,
438 decodeOpts.desiredSize.width);
439 decodeOpts.desiredRegion.height = opts.desiredRegion.size.height;
440 decodeOpts.desiredRegion.width = opts.desiredRegion.size.width;
441 decodeOpts.desiredRegion.left = opts.desiredRegion.x;
442 decodeOpts.desiredRegion.top = opts.desiredRegion.y;
443 IMAGE_LOGD("[ImageSource] desiredRegion height is %{public}d, width is %{public}d,"
444 "left is %{public}d, top is %{public}d",
445 decodeOpts.desiredRegion.height, decodeOpts.desiredRegion.width, decodeOpts.desiredRegion.left,
446 decodeOpts.desiredRegion.top);
447 decodeOpts.rotateDegrees = opts.rotateDegrees;
448 decodeOpts.sampleSize = opts.sampleSize;
449 decodeOpts.desiredPixelFormat = PixelFormat(opts.desiredPixelFormat);
450 decodeOpts.editable = opts.editable;
451 if (opts.desiredColorSpace != 0) {
452 auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(opts.desiredColorSpace);
453 if (colorSpace != nullptr) {
454 decodeOpts.desiredColorSpaceInfo = colorSpace->GetColorSpaceToken();
455 }
456 }
457 return decodeOpts;
458 }
459
ParseCDecodingOptionsV2(CDecodingOptionsV2 & opts)460 static DecodeOptions ParseCDecodingOptionsV2(CDecodingOptionsV2& opts)
461 {
462 DecodeOptions decodeOpts = {};
463 decodeOpts.fitDensity = opts.fitDensity;
464 decodeOpts.desiredSize.height = opts.desiredSize.height;
465 decodeOpts.desiredSize.width = opts.desiredSize.width;
466 IMAGE_LOGD("[ImageSource] desiredSize height is %{public}d, width is %{public}d", decodeOpts.desiredSize.height,
467 decodeOpts.desiredSize.width);
468 decodeOpts.desiredRegion.height = opts.desiredRegion.size.height;
469 decodeOpts.desiredRegion.width = opts.desiredRegion.size.width;
470 decodeOpts.desiredRegion.left = opts.desiredRegion.x;
471 decodeOpts.desiredRegion.top = opts.desiredRegion.y;
472 IMAGE_LOGD("[ImageSource] desiredRegion height is %{public}d, width is %{public}d,"
473 "left is %{public}d, top is %{public}d",
474 decodeOpts.desiredRegion.height, decodeOpts.desiredRegion.width, decodeOpts.desiredRegion.left,
475 decodeOpts.desiredRegion.top);
476 decodeOpts.rotateDegrees = opts.rotateDegrees;
477 decodeOpts.sampleSize = opts.sampleSize;
478 decodeOpts.desiredPixelFormat = PixelFormat(opts.desiredPixelFormat);
479 decodeOpts.editable = opts.editable;
480 if (opts.desiredColorSpace != 0) {
481 auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(opts.desiredColorSpace);
482 if (colorSpace != nullptr) {
483 decodeOpts.desiredColorSpaceInfo = colorSpace->GetColorSpaceToken();
484 }
485 }
486 decodeOpts.desiredDynamicRange = DecodeDynamicRange(opts.desiredDynamicRange);
487 return decodeOpts;
488 }
489
FfiOHOSImageSourceCreatePixelMapList(int64_t id,uint32_t index,CDecodingOptions opts,uint32_t * errorCode)490 CArrI64 FfiOHOSImageSourceCreatePixelMapList(int64_t id, uint32_t index, CDecodingOptions opts, uint32_t* errorCode)
491 {
492 IMAGE_LOGD("[ImageSource] CreatePixelMapList start");
493 CArrI64 ret = { .head = nullptr, .size = 0 };
494 auto instance = FFIData::GetData<ImageSourceImpl>(id);
495 if (!instance) {
496 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
497 *errorCode = ERR_IMAGE_INIT_ABNORMAL;
498 return ret;
499 }
500 DecodeOptions decodeOpts = ParseCDecodingOptions(opts);
501 std::vector<int64_t> data = instance->CreatePixelMapList(index, decodeOpts, errorCode);
502 if (*errorCode == SUCCESS_CODE) {
503 auto size = data.size();
504 if (size == 0) {
505 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
506 IMAGE_LOGE("[ImageSource] CreatePixelMapList size error.");
507 return ret;
508 }
509
510 auto arr = static_cast<int64_t*>(malloc(sizeof(int64_t) * size));
511 if (!arr) {
512 IMAGE_LOGE("[ImageSource] FfiOHOSImageSourceCreatePixelMapList failed to malloc arr.");
513 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
514 return ret;
515 }
516 for (int i = 0; i < static_cast<int>(size); ++i) {
517 arr[i] = data[i];
518 }
519 ret.head = arr;
520 ret.size = static_cast<int64_t>(data.size());
521 }
522 IMAGE_LOGD("[ImageSource] CreatePixelMapList success");
523 return ret;
524 }
525
FfiOHOSImageSourceCreatePixelMapListV2(int64_t id,uint32_t index,CDecodingOptionsV2 opts,uint32_t * errorCode)526 CArrI64 FfiOHOSImageSourceCreatePixelMapListV2(int64_t id, uint32_t index, CDecodingOptionsV2 opts, uint32_t* errorCode)
527 {
528 IMAGE_LOGD("[ImageSource] CreatePixelMapList start");
529 CArrI64 ret = { .head = nullptr, .size = 0 };
530 auto instance = FFIData::GetData<ImageSourceImpl>(id);
531 if (!instance) {
532 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
533 *errorCode = ERR_IMAGE_INIT_ABNORMAL;
534 return ret;
535 }
536 DecodeOptions decodeOpts = ParseCDecodingOptionsV2(opts);
537 std::vector<int64_t> data = instance->CreatePixelMapList(index, decodeOpts, errorCode);
538 if (*errorCode == SUCCESS_CODE) {
539 auto size = data.size();
540 if (size > 0) {
541 auto arr = static_cast<int64_t*>(malloc(sizeof(int64_t) * size));
542 if (!arr) {
543 IMAGE_LOGE("[ImageSource] FfiOHOSImageSourceCreatePixelMapList failed to malloc arr.");
544 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
545 return ret;
546 }
547 for (int i = 0; i < static_cast<int>(size); ++i) {
548 arr[i] = data[i];
549 }
550 ret.head = arr;
551 ret.size = static_cast<int64_t>(data.size());
552 } else {
553 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
554 IMAGE_LOGE("[ImageSource] CreatePixelMapList size error.");
555 return ret;
556 }
557 }
558 IMAGE_LOGD("[ImageSource] CreatePixelMapList success");
559 return ret;
560 }
561
FfiOHOSImageSourceGetDelayTime(int64_t id,uint32_t * errorCode)562 CArrI32 FfiOHOSImageSourceGetDelayTime(int64_t id, uint32_t* errorCode)
563 {
564 IMAGE_LOGD("[ImageSource] GetDelayTime start");
565 CArrI32 ret = { .head = nullptr, .size = 0 };
566 auto instance = FFIData::GetData<ImageSourceImpl>(id);
567 if (!instance) {
568 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
569 *errorCode = ERR_IMAGE_INIT_ABNORMAL;
570 return ret;
571 }
572 auto data = instance->GetDelayTime(errorCode);
573 if (*errorCode == SUCCESS_CODE) {
574 auto size = data->size();
575 if (size <= 0) {
576 IMAGE_LOGE("[ImageSource] FfiOHOSImageSourceGetDelayTime size cannot be less than or equal to 0.");
577 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
578 return ret;
579 }
580 auto arr = static_cast<int32_t*>(malloc(sizeof(int32_t) * size));
581 if (!arr) {
582 IMAGE_LOGE("[ImageSource] FfiOHOSImageSourceGetDelayTime failed to malloc arr.");
583 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
584 return ret;
585 }
586 for (int i = 0; i < static_cast<int>(size); ++i) {
587 arr[i] = data->operator[](i);
588 }
589 ret.head = arr;
590 ret.size = static_cast<int64_t>(data->size());
591 }
592 IMAGE_LOGD("[ImageSource] GetDelayTime success");
593 return ret;
594 }
595
FfiImageImageSourceImplGetDisposalTypeList(int64_t id,uint32_t * errorCode)596 CArrI32 FfiImageImageSourceImplGetDisposalTypeList(int64_t id, uint32_t* errorCode)
597 {
598 IMAGE_LOGD("[ImageSource] FfiImageImageSourceImplGetDisposalTypeList start");
599 CArrI32 ret = { .head = nullptr, .size = 0 };
600 auto instance = FFIData::GetData<ImageSourceImpl>(id);
601 if (!instance) {
602 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
603 *errorCode = ERR_IMAGE_INIT_ABNORMAL;
604 return ret;
605 }
606 std::unique_ptr<std::vector<int32_t>> data = instance->GetDisposalTypeList(errorCode);
607 if (*errorCode == SUCCESS_CODE && data != nullptr) {
608 auto size = data->size();
609 if (size <= 0) {
610 return ret;
611 }
612 int32_t* arr = static_cast<int32_t*>(malloc(sizeof(int32_t) * size));
613 if (!arr) {
614 IMAGE_LOGE("[ImageSource] FfiImageImageSourceImplGetDisposalTypeList failed to malloc arr.");
615 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
616 return ret;
617 }
618 for (int i = 0; i < static_cast<int>(size); ++i) {
619 arr[i] = data->operator[](i);
620 }
621 ret.head = arr;
622 ret.size = static_cast<int64_t>(data->size());
623 }
624 IMAGE_LOGD("[ImageSource] FfiImageImageSourceImplGetDisposalTypeList success");
625 return ret;
626 }
627
FfiImageImageSourceImplGetImageProperties(int64_t id,CArrString key,char ** value)628 uint32_t FfiImageImageSourceImplGetImageProperties(int64_t id, CArrString key, char** value)
629 {
630 IMAGE_LOGD("[ImageSource] FfiImageImageSourceImplGetImageProperties start");
631 auto instance = FFIData::GetData<ImageSourceImpl>(id);
632 if (!instance) {
633 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
634 return ERR_IMAGE_INIT_ABNORMAL;
635 }
636 std::vector<std::string> keyStrArray;
637 for (int64_t i = 0; i < key.size; i++) {
638 keyStrArray.push_back(key.head[i]);
639 }
640 std::vector<std::string> valueStrArray;
641 uint32_t errCode = instance->GetImageProperties(keyStrArray, valueStrArray);
642 if (errCode != SUCCESS) {
643 return errCode;
644 }
645 for (size_t i = 0; i < valueStrArray.size(); i++) {
646 value[i] = Utils::MallocCString(valueStrArray[i]);
647 }
648 IMAGE_LOGD("[ImageSource] FfiImageImageSourceImplGetImageProperties success");
649 return errCode;
650 }
651
FfiImageImageSourceImplModifyImageProperties(int64_t id,CArrString key,CArrString value)652 uint32_t FfiImageImageSourceImplModifyImageProperties(int64_t id, CArrString key, CArrString value)
653 {
654 IMAGE_LOGD("[ImageSource] FfiImageImageSourceImplModifyImageProperties start");
655 auto instance = FFIData::GetData<ImageSourceImpl>(id);
656 if (!instance) {
657 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
658 return ERR_IMAGE_INIT_ABNORMAL;
659 }
660 IMAGE_LOGD("[ImageSource] FfiImageImageSourceImplModifyImageProperties success");
661 return instance->ModifyImageProperties(key.head, value.head, key.size);
662 }
663
FfiOHOSImageSourceCreatePixelMap(int64_t id,uint32_t index,CDecodingOptions opts)664 RetDataI64U32 FfiOHOSImageSourceCreatePixelMap(int64_t id, uint32_t index, CDecodingOptions opts)
665 {
666 IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceCreatePixelMap start");
667 RetDataI64U32 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = 0 };
668 auto instance = FFIData::GetData<ImageSourceImpl>(id);
669 if (!instance) {
670 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
671 return ret;
672 }
673 DecodeOptions decodeOpts = ParseCDecodingOptions(opts);
674 ret.data = instance->CreatePixelMap(index, decodeOpts, ret.code);
675 IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceCreatePixelMap success");
676 return ret;
677 }
678
FfiOHOSImageSourceCreatePixelMapV2(int64_t id,uint32_t index,CDecodingOptionsV2 opts)679 RetDataI64U32 FfiOHOSImageSourceCreatePixelMapV2(int64_t id, uint32_t index, CDecodingOptionsV2 opts)
680 {
681 IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceCreatePixelMap start");
682 RetDataI64U32 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = 0 };
683 auto instance = FFIData::GetData<ImageSourceImpl>(id);
684 if (!instance) {
685 IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
686 return ret;
687 }
688 DecodeOptions decodeOpts = ParseCDecodingOptionsV2(opts);
689 ret.data = instance->CreatePixelMap(index, decodeOpts, ret.code);
690 IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceCreatePixelMap success");
691 return ret;
692 }
693
694 //--------------------- PixelMap ---------------------------------------------------------------------------
695
ParsePixelMapCInitializationOptions(CInitializationOptionsV2 opts)696 static InitializationOptions ParsePixelMapCInitializationOptions(CInitializationOptionsV2 opts)
697 {
698 InitializationOptions option;
699 option.alphaType = AlphaType(opts.alphaType);
700 option.editable = opts.editable;
701 option.srcPixelFormat = PixelFormat(opts.srcPixelFormat);
702 option.pixelFormat = PixelFormat(opts.pixelFormat);
703 option.scaleMode = ScaleMode(opts.scaleMode);
704 option.size.height = opts.height;
705 option.size.width = opts.width;
706 return option;
707 }
708
FfiOHOSCreatePixelMap(uint8_t * colors,uint32_t colorLength,CInitializationOptions opts)709 int64_t FfiOHOSCreatePixelMap(uint8_t* colors, uint32_t colorLength, CInitializationOptions opts)
710 {
711 IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMap start");
712 InitializationOptions option;
713 option.alphaType = AlphaType(opts.alphaType);
714 option.editable = opts.editable;
715 option.pixelFormat = PixelFormat(opts.pixelFormat);
716 option.scaleMode = ScaleMode(opts.scaleMode);
717 option.size.height = opts.height;
718 option.size.width = opts.width;
719 std::unique_ptr<PixelMap> ptr_ =
720 PixelMapImpl::CreatePixelMap(reinterpret_cast<uint32_t*>(colors), colorLength, option);
721 if (!ptr_) {
722 return INIT_FAILED;
723 }
724 auto native = FFIData::Create<PixelMapImpl>(move(ptr_));
725 if (!native) {
726 IMAGE_LOGE("[ImageSource] FfiOHOSCreatePixelMap failed");
727 return INIT_FAILED;
728 }
729 IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMap success");
730 return native->GetID();
731 }
732
FfiOHOSCreatePixelMapV2(uint8_t * colors,uint32_t colorLength,CInitializationOptionsV2 opts)733 int64_t FfiOHOSCreatePixelMapV2(uint8_t* colors, uint32_t colorLength, CInitializationOptionsV2 opts)
734 {
735 IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMap start");
736 InitializationOptions option = ParsePixelMapCInitializationOptions(opts);
737 std::unique_ptr<PixelMap> ptr_ =
738 PixelMapImpl::CreatePixelMap(reinterpret_cast<uint32_t*>(colors), colorLength, option);
739 if (!ptr_) {
740 return INIT_FAILED;
741 }
742 auto native = FFIData::Create<PixelMapImpl>(move(ptr_));
743 if (!native) {
744 IMAGE_LOGE("[ImageSource] FfiOHOSCreatePixelMap failed");
745 return INIT_FAILED;
746 }
747 IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMap success");
748 return native->GetID();
749 }
750
FfiImagePixelMapImplCreatePixelMap(CInitializationOptionsV2 opts)751 int64_t FfiImagePixelMapImplCreatePixelMap(CInitializationOptionsV2 opts)
752 {
753 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePixelMap start");
754 InitializationOptions option = ParsePixelMapCInitializationOptions(opts);
755 std::unique_ptr<PixelMap> ptr_ = PixelMapImpl::CreatePixelMap(option);
756 if (!ptr_) {
757 return INIT_FAILED;
758 }
759 auto native = FFIData::Create<PixelMapImpl>(move(ptr_));
760 if (!native) {
761 IMAGE_LOGE("[ImageSource] FfiImagePixelMapImplCreatePixelMap failed");
762 return INIT_FAILED;
763 }
764 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePixelMap success");
765 return native->GetID();
766 }
767
FfiOHOSPixelMapRelease(int64_t id)768 uint32_t FfiOHOSPixelMapRelease(int64_t id)
769 {
770 IMAGE_LOGD("[PixelMap] FfiOHOSRelease start");
771 auto instance = FFIData::GetData<PixelMapImpl>(id);
772 if (!instance) {
773 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
774 return ERR_IMAGE_INIT_ABNORMAL;
775 }
776 std::shared_ptr<PixelMap> ptr_ = instance->GetRealPixelMap();
777 ptr_.reset();
778 IMAGE_LOGD("[PixelMap] FfiOHOSRelease success");
779 return SUCCESS_CODE;
780 }
781
FfiOHOSCreateAlphaPixelMap(int64_t id,uint32_t * errCode)782 int64_t FfiOHOSCreateAlphaPixelMap(int64_t id, uint32_t* errCode)
783 {
784 IMAGE_LOGD("[PixelMap] FfiOHOSCreateAlphaPixelMap start");
785 auto instance = FFIData::GetData<PixelMapImpl>(id);
786 if (!instance) {
787 *errCode = ERR_IMAGE_INIT_ABNORMAL;
788 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
789 return 0;
790 }
791 std::shared_ptr<PixelMap> ptr_ = instance->GetRealPixelMap();
792 if (!ptr_) {
793 *errCode = ERR_IMAGE_INIT_ABNORMAL;
794 IMAGE_LOGE("[PixelMap] ptr is nullptr!");
795 return 0;
796 }
797 InitializationOptions opts;
798 opts.pixelFormat = PixelFormat::ALPHA_8;
799 auto tmpPixelMap = PixelMapImpl::CreateAlphaPixelMap(*ptr_, opts);
800 if (!tmpPixelMap) {
801 *errCode = ERR_IMAGE_INIT_ABNORMAL;
802 IMAGE_LOGE("[PixelMap] tmpPixelMap is nullptr!");
803 return 0;
804 }
805 auto native = FFIData::Create<PixelMapImpl>(move(tmpPixelMap));
806 if (!native) {
807 IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
808 *errCode = ERR_IMAGE_INIT_ABNORMAL;
809 return INIT_FAILED;
810 }
811 IMAGE_LOGD("[PixelMap] FfiOHOSCreateAlphaPixelMap success");
812 *errCode = SUCCESS_CODE;
813 return native->GetID();
814 }
815
FfiOHOSReadPixelsToBuffer(int64_t id,uint64_t bufferSize,uint8_t * dst)816 uint32_t FfiOHOSReadPixelsToBuffer(int64_t id, uint64_t bufferSize, uint8_t* dst)
817 {
818 IMAGE_LOGD("[PixelMap] FfiOHOSReadPixelsToBuffer start");
819 auto instance = FFIData::GetData<PixelMapImpl>(id);
820 if (!instance || !instance->GetRealPixelMap()) {
821 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
822 return ERR_IMAGE_INIT_ABNORMAL;
823 }
824 uint32_t ret = instance->ReadPixelsToBuffer(bufferSize, dst);
825 IMAGE_LOGD("[PixelMap] FfiOHOSReadPixelsToBuffer success");
826 return ret;
827 }
828
FfiOHOSWriteBufferToPixels(int64_t id,uint8_t * source,uint64_t bufferSize)829 uint32_t FfiOHOSWriteBufferToPixels(int64_t id, uint8_t* source, uint64_t bufferSize)
830 {
831 IMAGE_LOGD("[PixelMap] FfiOHOSWriteBufferToPixels start");
832 auto instance = FFIData::GetData<PixelMapImpl>(id);
833 if (!instance || !instance->GetRealPixelMap()) {
834 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
835 return ERR_IMAGE_INIT_ABNORMAL;
836 }
837 uint32_t ret = instance->WriteBufferToPixels(source, bufferSize);
838 IMAGE_LOGD("[PixelMap] FfiOHOSWriteBufferToPixels success");
839 return ret;
840 }
841
FfiOHOSGetDensity(int64_t id,uint32_t * errCode)842 int32_t FfiOHOSGetDensity(int64_t id, uint32_t* errCode)
843 {
844 IMAGE_LOGD("[PixelMap] FfiOHOSGetDensity start");
845 auto instance = FFIData::GetData<PixelMapImpl>(id);
846 if (!instance || !instance->GetRealPixelMap()) {
847 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
848 *errCode = ERR_IMAGE_INIT_ABNORMAL;
849 return 0;
850 }
851 int32_t ret = instance->GetDensity();
852 *errCode = SUCCESS_CODE;
853 IMAGE_LOGD("[PixelMap] FfiOHOSGetDensity success");
854 return ret;
855 }
856
FfiOHOSOpacity(int64_t id,float percent)857 uint32_t FfiOHOSOpacity(int64_t id, float percent)
858 {
859 IMAGE_LOGD("[PixelMap] FfiOHOSOpacity start");
860 auto instance = FFIData::GetData<PixelMapImpl>(id);
861 if (!instance || !instance->GetRealPixelMap()) {
862 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
863 return ERR_IMAGE_INIT_ABNORMAL;
864 }
865 uint32_t ret = instance->Opacity(percent);
866 IMAGE_LOGD("[PixelMap] FfiOHOSOpacity success");
867 return ret;
868 }
869
FfiOHOSCrop(int64_t id,CRegion rect)870 uint32_t FfiOHOSCrop(int64_t id, CRegion rect)
871 {
872 IMAGE_LOGD("[PixelMap] FfiOHOSCrop start");
873 auto instance = FFIData::GetData<PixelMapImpl>(id);
874 if (!instance || !instance->GetRealPixelMap()) {
875 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
876 return ERR_IMAGE_INIT_ABNORMAL;
877 }
878 Rect rt;
879 rt.left = rect.x;
880 rt.top = rect.y;
881 rt.width = rect.size.width;
882 rt.height = rect.size.height;
883 uint32_t ret = instance->Crop(rt);
884 IMAGE_LOGD("[PixelMap] FfiOHOSCrop success");
885 return ret;
886 }
887
FfiOHOSGetPixelBytesNumber(int64_t id,uint32_t * errCode)888 uint32_t FfiOHOSGetPixelBytesNumber(int64_t id, uint32_t* errCode)
889 {
890 IMAGE_LOGD("[PixelMap] FfiOHOSGetPixelBytesNumber start");
891 auto instance = FFIData::GetData<PixelMapImpl>(id);
892 if (!instance || !instance->GetRealPixelMap()) {
893 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
894 *errCode = ERR_IMAGE_INIT_ABNORMAL;
895 return 0;
896 }
897 uint32_t ret = instance->GetPixelBytesNumber();
898 *errCode = SUCCESS_CODE;
899 IMAGE_LOGD("[PixelMap] FfiOHOSGetPixelBytesNumber success");
900 return ret;
901 }
902
FfiOHOSGetBytesNumberPerRow(int64_t id,uint32_t * errCode)903 uint32_t FfiOHOSGetBytesNumberPerRow(int64_t id, uint32_t* errCode)
904 {
905 IMAGE_LOGD("[PixelMap] FfiOHOSGetBytesNumberPerRow start");
906 auto instance = FFIData::GetData<PixelMapImpl>(id);
907 if (!instance || !instance->GetRealPixelMap()) {
908 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
909 *errCode = ERR_IMAGE_INIT_ABNORMAL;
910 return 0;
911 }
912 uint32_t ret = instance->GetBytesNumberPerRow();
913 *errCode = SUCCESS_CODE;
914 IMAGE_LOGD("[PixelMap] FfiOHOSGetBytesNumberPerRow success");
915 return ret;
916 }
917
FfiOHOSGetImageInfo(int64_t id,uint32_t * errCode)918 CImageInfo FfiOHOSGetImageInfo(int64_t id, uint32_t* errCode)
919 {
920 IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfo start");
921 CImageInfo ret = {};
922 auto instance = FFIData::GetData<PixelMapImpl>(id);
923 if (!instance || !instance->GetRealPixelMap()) {
924 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
925 *errCode = ERR_IMAGE_INIT_ABNORMAL;
926 return ret;
927 }
928 ImageInfo info;
929 instance->GetImageInfo(info);
930 ret.height = info.size.height;
931 ret.width = info.size.width;
932 ret.density = info.baseDensity;
933 IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfo success");
934 return ret;
935 }
936
ParsePixelMapImageInfo(ImageInfo info,PixelMap * pixelMap)937 static CImageInfoV2 ParsePixelMapImageInfo(ImageInfo info, PixelMap* pixelMap)
938 {
939 CImageInfoV2 ret = {};
940 ret.height = info.size.height;
941 ret.width = info.size.width;
942 ret.density = info.baseDensity;
943 ret.pixelFormat = static_cast<int32_t>(info.pixelFormat);
944 ret.alphaType = static_cast<int32_t>(info.alphaType);
945 ret.stride = static_cast<int32_t>(pixelMap->GetRowStride());
946 ret.mimeType = Utils::MallocCString(info.encodedFormat);
947 ret.isHdr = pixelMap->IsHdr();
948 return ret;
949 }
950
FfiOHOSGetImageInfoV2(int64_t id,uint32_t * errCode)951 CImageInfoV2 FfiOHOSGetImageInfoV2(int64_t id, uint32_t* errCode)
952 {
953 IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfo start");
954 CImageInfoV2 ret = {};
955 auto instance = FFIData::GetData<PixelMapImpl>(id);
956 if (!instance || !instance->GetRealPixelMap()) {
957 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
958 *errCode = ERR_IMAGE_INIT_ABNORMAL;
959 return ret;
960 }
961 ImageInfo info;
962 instance->GetImageInfo(info);
963 ret = ParsePixelMapImageInfo(info, instance->GetRealPixelMap().get());
964 IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfo success");
965 return ret;
966 }
967
FfiOHOSScale(int64_t id,float xAxis,float yAxis)968 uint32_t FfiOHOSScale(int64_t id, float xAxis, float yAxis)
969 {
970 IMAGE_LOGD("[PixelMap] FfiOHOSScale start");
971 auto instance = FFIData::GetData<PixelMapImpl>(id);
972 if (!instance || !instance->GetRealPixelMap()) {
973 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
974 return ERR_IMAGE_INIT_ABNORMAL;
975 }
976 instance->Scale(xAxis, yAxis);
977 IMAGE_LOGD("[PixelMap] FfiOHOSScale success");
978 return SUCCESS_CODE;
979 }
980
ParseAntiAliasingOption(int32_t val)981 static AntiAliasingOption ParseAntiAliasingOption(int32_t val)
982 {
983 if (val <= static_cast<int32_t>(AntiAliasingOption::SPLINE)) {
984 return AntiAliasingOption(val);
985 }
986 return AntiAliasingOption::NONE;
987 }
988
FfiImagePixelMapImplScale(int64_t id,float xAxis,float yAxis,int32_t antiAliasing)989 uint32_t FfiImagePixelMapImplScale(int64_t id, float xAxis, float yAxis, int32_t antiAliasing)
990 {
991 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplScale start");
992 auto instance = FFIData::GetData<PixelMapImpl>(id);
993 if (!instance || !instance->GetRealPixelMap()) {
994 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
995 return ERR_IMAGE_INIT_ABNORMAL;
996 }
997 instance->Scale(xAxis, yAxis, ParseAntiAliasingOption(antiAliasing));
998 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplScale success");
999 return SUCCESS_CODE;
1000 }
1001
FfiOHOSFlip(int64_t id,bool xAxis,bool yAxis)1002 uint32_t FfiOHOSFlip(int64_t id, bool xAxis, bool yAxis)
1003 {
1004 IMAGE_LOGD("[PixelMap] FfiOHOSFlip start");
1005 auto instance = FFIData::GetData<PixelMapImpl>(id);
1006 if (!instance || !instance->GetRealPixelMap()) {
1007 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1008 return ERR_IMAGE_INIT_ABNORMAL;
1009 }
1010 instance->Flip(xAxis, yAxis);
1011 IMAGE_LOGD("[PixelMap] FfiOHOSFlip success");
1012 return SUCCESS_CODE;
1013 }
1014
FfiOHOSRotate(int64_t id,float degrees)1015 uint32_t FfiOHOSRotate(int64_t id, float degrees)
1016 {
1017 IMAGE_LOGD("[PixelMap] FfiOHOSRotate start");
1018 auto instance = FFIData::GetData<PixelMapImpl>(id);
1019 if (!instance || !instance->GetRealPixelMap()) {
1020 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1021 return ERR_IMAGE_INIT_ABNORMAL;
1022 }
1023 instance->Rotate(degrees);
1024 IMAGE_LOGD("[PixelMap] FfiOHOSRotate success");
1025 return SUCCESS_CODE;
1026 }
1027
FfiOHOSTranslate(int64_t id,float xAxis,float yAxis)1028 uint32_t FfiOHOSTranslate(int64_t id, float xAxis, float yAxis)
1029 {
1030 IMAGE_LOGD("[PixelMap] FfiOHOSTranslate start");
1031 auto instance = FFIData::GetData<PixelMapImpl>(id);
1032 if (!instance || !instance->GetRealPixelMap()) {
1033 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1034 return ERR_IMAGE_INIT_ABNORMAL;
1035 }
1036 instance->Translate(xAxis, yAxis);
1037 IMAGE_LOGD("[PixelMap] FfiOHOSTranslate success");
1038 return SUCCESS_CODE;
1039 }
1040
FfiOHOSReadPixels(int64_t id,CPositionArea area)1041 uint32_t FfiOHOSReadPixels(int64_t id, CPositionArea area)
1042 {
1043 IMAGE_LOGD("[PixelMap] FfiOHOSReadPixels start");
1044 auto instance = FFIData::GetData<PixelMapImpl>(id);
1045 if (!instance || !instance->GetRealPixelMap()) {
1046 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1047 return ERR_IMAGE_INIT_ABNORMAL;
1048 }
1049 Rect rt = ParseCRegion(area.region);
1050 uint32_t ret = instance->ReadPixels(area.bufferSize, area.offset, area.stride, rt, area.dst);
1051 IMAGE_LOGD("[PixelMap] FfiOHOSReadPixels success");
1052 return ret;
1053 }
1054
FfiOHOSWritePixels(int64_t id,CPositionArea area)1055 uint32_t FfiOHOSWritePixels(int64_t id, CPositionArea area)
1056 {
1057 IMAGE_LOGD("[PixelMap] FfiOHOSWritePixels start");
1058 auto instance = FFIData::GetData<PixelMapImpl>(id);
1059 if (!instance || !instance->GetRealPixelMap()) {
1060 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1061 return ERR_IMAGE_INIT_ABNORMAL;
1062 }
1063 Rect rt = ParseCRegion(area.region);
1064 uint32_t ret = instance->WritePixels(area.dst, area.bufferSize, area.offset, area.stride, rt);
1065 IMAGE_LOGD("[PixelMap] FfiOHOSWritePixels success");
1066 return ret;
1067 }
1068
FfiOHOSGetIsEditable(int64_t id,uint32_t * errCode)1069 bool FfiOHOSGetIsEditable(int64_t id, uint32_t* errCode)
1070 {
1071 IMAGE_LOGD("[PixelMap] FfiOHOSGetIsEditable start");
1072 auto instance = FFIData::GetData<PixelMapImpl>(id);
1073 bool ret = false;
1074 if (!instance || !instance->GetRealPixelMap()) {
1075 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1076 *errCode = ERR_IMAGE_INIT_ABNORMAL;
1077 return ret;
1078 }
1079 ret = instance->GetIsEditable();
1080 *errCode = SUCCESS_CODE;
1081 IMAGE_LOGD("[PixelMap] FfiOHOSGetIsEditable success");
1082 return ret;
1083 }
1084
FfiOHOSGetIsStrideAlignment(int64_t id,uint32_t * errCode)1085 bool FfiOHOSGetIsStrideAlignment(int64_t id, uint32_t* errCode)
1086 {
1087 IMAGE_LOGD("[PixelMap] FfiOHOSGetIsStrideAlignment start");
1088 auto instance = FFIData::GetData<PixelMapImpl>(id);
1089 bool ret = false;
1090 if (!instance || !instance->GetRealPixelMap()) {
1091 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1092 *errCode = ERR_IMAGE_INIT_ABNORMAL;
1093 return ret;
1094 }
1095 ret = instance->GetIsStrideAlignment();
1096 *errCode = SUCCESS_CODE;
1097 IMAGE_LOGD("[PixelMap] FfiOHOSGetIsStrideAlignment success");
1098 return ret;
1099 }
1100
FfiOHOSPixelMapSetColorSpace(int64_t id,int64_t colorSpaceId)1101 uint32_t FfiOHOSPixelMapSetColorSpace(int64_t id, int64_t colorSpaceId)
1102 {
1103 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapSetColorSpace start");
1104 auto instance = FFIData::GetData<PixelMapImpl>(id);
1105 if (!instance || !instance->GetRealPixelMap()) {
1106 IMAGE_LOGE("[PixelMap] PixelMapImpl instance not exist %{public}" PRId64, id);
1107 return ERR_IMAGE_INIT_ABNORMAL;
1108 }
1109 auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(colorSpaceId);
1110 if (!colorSpace) {
1111 IMAGE_LOGE("[PixelMap] CjColorManager instance not exist %{public}" PRId64, colorSpaceId);
1112 return ERR_IMAGE_INVALID_PARAMETER;
1113 }
1114 uint32_t ret = instance->SetColorSpace(colorSpace->GetColorSpaceToken());
1115 IMAGE_LOGD("[PixelMap] FFfiOHOSPixelMapSetColorSpace success");
1116 return ret;
1117 }
1118
FfiOHOSPixelMapGetColorSpace(int64_t id,int32_t * errCode)1119 int64_t FfiOHOSPixelMapGetColorSpace(int64_t id, int32_t* errCode)
1120 {
1121 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapGetColorSpace start");
1122 auto instance = FFIData::GetData<PixelMapImpl>(id);
1123 if (!instance || !instance->GetRealPixelMap()) {
1124 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1125 *errCode = ERR_IMAGE_DATA_ABNORMAL;
1126 return 0;
1127 }
1128 auto colorSpace = instance->GetColorSpace();
1129 if (!colorSpace) {
1130 *errCode = ERR_IMAGE_DATA_UNSUPPORT;
1131 return 0;
1132 }
1133 auto native = FFIData::Create<ColorManager::CjColorManager>(colorSpace);
1134 if (!native) {
1135 *errCode = ERR_IMAGE_INIT_ABNORMAL;
1136 return 0;
1137 }
1138
1139 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapGetColorSpace success");
1140 *errCode = SUCCESS_CODE;
1141 return native->GetID();
1142 }
1143
FfiOHOSPixelMapApplyColorSpace(int64_t id,int64_t colorSpaceId)1144 uint32_t FfiOHOSPixelMapApplyColorSpace(int64_t id, int64_t colorSpaceId)
1145 {
1146 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapApplyColorSpace start");
1147 auto instance = FFIData::GetData<PixelMapImpl>(id);
1148 if (!instance || !instance->GetRealPixelMap()) {
1149 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1150 return ERR_IMAGE_INIT_ABNORMAL;
1151 }
1152 auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(colorSpaceId);
1153 if (!colorSpace) {
1154 IMAGE_LOGE("[PixelMap] CjColorManager instance not exist %{public}" PRId64, colorSpaceId);
1155 return ERR_IMAGE_INIT_ABNORMAL;
1156 }
1157 uint32_t ret = instance->ApplyColorSpace(colorSpace->GetColorSpaceToken());
1158 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapApplyColorSpace success");
1159 return ret;
1160 }
1161
FfiImagePixelMapImplCreatePremultipliedPixelMap(int64_t srcId,int64_t dstId)1162 uint32_t FfiImagePixelMapImplCreatePremultipliedPixelMap(int64_t srcId, int64_t dstId)
1163 {
1164 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePremultipliedPixelMap start");
1165 auto src = FFIData::GetData<PixelMapImpl>(srcId);
1166 auto dst = FFIData::GetData<PixelMapImpl>(dstId);
1167 if (!src || !dst) {
1168 return ERR_IMAGE_GET_DATA_ABNORMAL;
1169 }
1170 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePremultipliedPixelMap success");
1171 return PixelMapImpl::CreatePremultipliedPixelMap(src->GetRealPixelMap(), dst->GetRealPixelMap());
1172 }
1173
FfiImagePixelMapImplCreateUnpremultipliedPixelMap(int64_t srcId,int64_t dstId)1174 uint32_t FfiImagePixelMapImplCreateUnpremultipliedPixelMap(int64_t srcId, int64_t dstId)
1175 {
1176 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreateUnpremultipliedPixelMap start");
1177 auto src = FFIData::GetData<PixelMapImpl>(srcId);
1178 auto dst = FFIData::GetData<PixelMapImpl>(dstId);
1179 if (!src || !dst) {
1180 return ERR_IMAGE_GET_DATA_ABNORMAL;
1181 }
1182 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreateUnpremultipliedPixelMap success");
1183 return PixelMapImpl::CreateUnpremultipliedPixelMap(src->GetRealPixelMap(), dst->GetRealPixelMap());
1184 }
1185
FfiImagePixelMapImplSetTransferDetached(int64_t id,bool detached)1186 uint32_t FfiImagePixelMapImplSetTransferDetached(int64_t id, bool detached)
1187 {
1188 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplSetTransferDetached start");
1189 auto instance = FFIData::GetData<PixelMapImpl>(id);
1190 if (!instance) {
1191 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1192 return ERR_IMAGE_INIT_ABNORMAL;
1193 }
1194 instance->SetTransferDetach(detached);
1195 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplSetTransferDetached success");
1196 return SUCCESS;
1197 }
1198
FfiImagePixelMapImplToSdr(int64_t id)1199 uint32_t FfiImagePixelMapImplToSdr(int64_t id)
1200 {
1201 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplToSdr start");
1202 auto instance = FFIData::GetData<PixelMapImpl>(id);
1203 if (!instance) {
1204 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
1205 return ERR_IMAGE_INIT_ABNORMAL;
1206 }
1207 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplToSdr success");
1208 return instance->ToSdr();
1209 }
1210
1211 //--------------------- ImageReceiver ------------------------------------------------------------------------
1212
FfiOHOSReceiverGetSize(int64_t id,CSize * retVal)1213 uint32_t FfiOHOSReceiverGetSize(int64_t id, CSize* retVal)
1214 {
1215 IMAGE_LOGD("FfiOHOSReceiverGetSize start");
1216 auto instance = FFIData::GetData<ImageReceiverImpl>(id);
1217 if (!instance) {
1218 return ERR_IMAGE_INIT_ABNORMAL;
1219 }
1220 uint32_t retCode = instance->GetSize(retVal);
1221 IMAGE_LOGD("FfiOHOSReceiverGetSize success");
1222 return retCode;
1223 }
1224
FfiOHOSReceiverGetCapacity(int64_t id,int32_t * retVal)1225 uint32_t FfiOHOSReceiverGetCapacity(int64_t id, int32_t* retVal)
1226 {
1227 IMAGE_LOGD("FfiOHOSReceiverGetCapacity start");
1228 auto instance = FFIData::GetData<ImageReceiverImpl>(id);
1229 if (!instance) {
1230 return ERR_IMAGE_INIT_ABNORMAL;
1231 }
1232 uint32_t retCode = instance->GetCapacity(retVal);
1233 IMAGE_LOGD("FfiOHOSReceiverGetCapacity success");
1234 return retCode;
1235 }
1236
FfiOHOSReceiverGetFormat(int64_t id,int32_t * retVal)1237 uint32_t FfiOHOSReceiverGetFormat(int64_t id, int32_t* retVal)
1238 {
1239 IMAGE_LOGD("FfiOHOSReceiverGetFormat start");
1240 auto instance = FFIData::GetData<ImageReceiverImpl>(id);
1241 if (!instance) {
1242 return ERR_IMAGE_INIT_ABNORMAL;
1243 }
1244 uint32_t retCode = instance->GetFormat(retVal);
1245 IMAGE_LOGD("FfiOHOSReceiverGetFormat success");
1246 return retCode;
1247 }
1248
FfiOHOSCreateImageReceiver(int32_t width,int32_t height,int32_t format,int32_t capacity)1249 int64_t FfiOHOSCreateImageReceiver(int32_t width, int32_t height, int32_t format, int32_t capacity)
1250 {
1251 IMAGE_LOGD("FfiOHOSCreateImageReceiver start");
1252 auto id = ImageReceiverImpl::CreateImageReceiver(width, height, format, capacity);
1253 IMAGE_LOGD("FfiOHOSCreateImageReceiver success");
1254 return id;
1255 }
1256
FfiOHOSGetReceivingSurfaceId(int64_t id)1257 char* FfiOHOSGetReceivingSurfaceId(int64_t id)
1258 {
1259 IMAGE_LOGD("FfiOHOSGetReceivingSurfaceId start");
1260 auto instance = FFIData::GetData<ImageReceiverImpl>(id);
1261 if (!instance) {
1262 IMAGE_LOGE("ImageReceiver instance not exist %{public}" PRId64, id);
1263 return nullptr;
1264 }
1265 char* ret = instance->GetReceivingSurfaceId();
1266 IMAGE_LOGD("FfiOHOSGetReceivingSurfaceId success");
1267 return ret;
1268 }
1269
FfiOHOSReadNextImage(int64_t id)1270 int64_t FfiOHOSReadNextImage(int64_t id)
1271 {
1272 IMAGE_LOGD("FfiOHOSReadNextImage start");
1273 auto instance = FFIData::GetData<ImageReceiverImpl>(id);
1274 if (!instance) {
1275 IMAGE_LOGE("ImageReceiver instance not exist %{public}" PRId64, id);
1276 return INIT_FAILED;
1277 }
1278 auto image = instance->ReadNextImage();
1279 if (!image) {
1280 IMAGE_LOGE("ImageImpl Create is nullptr.");
1281 return INIT_FAILED;
1282 }
1283 IMAGE_LOGD("FfiOHOSReadNextImage success");
1284 return image->GetID();
1285 }
1286
FfiOHOSReadLatestImage(int64_t id)1287 int64_t FfiOHOSReadLatestImage(int64_t id)
1288 {
1289 IMAGE_LOGD("FfiOHOSReadLatestImage start.");
1290 auto instance = FFIData::GetData<ImageReceiverImpl>(id);
1291 if (!instance) {
1292 IMAGE_LOGE("ImageReceiver instance not exist %{public}" PRId64, id);
1293 return INIT_FAILED;
1294 }
1295 auto image = instance->ReadLatestImage();
1296 if (!image) {
1297 IMAGE_LOGE("ImageImpl Create is nullptr.");
1298 return INIT_FAILED;
1299 }
1300
1301 IMAGE_LOGD("FfiOHOSReadLatestImage success.");
1302 return image->GetID();
1303 }
1304
FfiOHOSReceiverRelease(int64_t id)1305 void FfiOHOSReceiverRelease(int64_t id)
1306 {
1307 IMAGE_LOGD("FfiOHOSReceiverRelease start");
1308 auto instance = FFIData::GetData<ImageReceiverImpl>(id);
1309 if (!instance) {
1310 IMAGE_LOGE("ImageReceiver instance not exist %{public}" PRId64, id);
1311 return;
1312 }
1313 instance->Release();
1314 IMAGE_LOGD("FfiOHOSReceiverRelease success");
1315 }
1316
FfiOHOSImageGetClipRect(int64_t id,CRegion * retVal)1317 uint32_t FfiOHOSImageGetClipRect(int64_t id, CRegion* retVal)
1318 {
1319 IMAGE_LOGD("FfiOHOSImageGetClipRect start");
1320 auto instance = FFIData::GetData<ImageImpl>(id);
1321 if (!instance) {
1322 return ERR_IMAGE_INIT_ABNORMAL;
1323 }
1324 int64_t retCode = instance->GetClipRect(retVal);
1325 IMAGE_LOGD("FfiOHOSImageGetClipRect success");
1326 return retCode;
1327 }
1328
FfiOHOSImageGetSize(int64_t id,CSize * retVal)1329 uint32_t FfiOHOSImageGetSize(int64_t id, CSize* retVal)
1330 {
1331 IMAGE_LOGD("FfiOHOSImageGetSize start");
1332 auto instance = FFIData::GetData<ImageImpl>(id);
1333 if (!instance) {
1334 return ERR_IMAGE_INIT_ABNORMAL;
1335 }
1336 uint32_t retCode = instance->GetSize(retVal);
1337 IMAGE_LOGD("FfiOHOSImageGetSize success");
1338 return retCode;
1339 }
1340
FfiOHOSImageGetFormat(int64_t id,int32_t * retVal)1341 uint32_t FfiOHOSImageGetFormat(int64_t id, int32_t* retVal)
1342 {
1343 IMAGE_LOGD("FfiOHOSImageGetFormat start");
1344 auto instance = FFIData::GetData<ImageImpl>(id);
1345 if (!instance) {
1346 return ERR_IMAGE_INIT_ABNORMAL;
1347 }
1348 uint32_t retCode = instance->GetFormat(retVal);
1349 IMAGE_LOGD("FfiOHOSImageGetFormat success");
1350 return retCode;
1351 }
1352
FfiOHOSGetComponent(int64_t id,int32_t componentType,CRetComponent * ptr)1353 uint32_t FfiOHOSGetComponent(int64_t id, int32_t componentType, CRetComponent* ptr)
1354 {
1355 IMAGE_LOGD("FfiOHOSGetComponent start");
1356 auto instance = FFIData::GetData<ImageImpl>(id);
1357 if (!instance) {
1358 IMAGE_LOGE("ImageImpl instance not exist %{public}" PRId64, id);
1359 return ERR_IMAGE_INIT_ABNORMAL;
1360 }
1361 uint32_t errCode = instance->GetComponent(componentType, ptr);
1362 IMAGE_LOGD("FfiOHOSGetComponent success");
1363 return errCode;
1364 }
1365
FfiImageImageImplGetTimestamp(int64_t id)1366 int64_t FfiImageImageImplGetTimestamp(int64_t id)
1367 {
1368 IMAGE_LOGD("FfiImageImageImplGetTimestamp start");
1369 auto instance = FFIData::GetData<ImageImpl>(id);
1370 if (!instance) {
1371 IMAGE_LOGE("ImageImpl instance not exist %{public}" PRId64, id);
1372 return 0;
1373 }
1374 IMAGE_LOGD("FfiImageImageImplGetTimestamp success");
1375 return instance->GetTimestamp();
1376 }
1377
FfiOHOSImageRelease(int64_t id)1378 void FfiOHOSImageRelease(int64_t id)
1379 {
1380 IMAGE_LOGD("FfiOHOSImageRelease start");
1381 auto instance = FFIData::GetData<ImageImpl>(id);
1382 if (!instance) {
1383 IMAGE_LOGE("ImageImpl instance not exist %{public}" PRId64, id);
1384 return;
1385 }
1386 instance->Release();
1387 IMAGE_LOGD("FfiOHOSImageRelease success");
1388 }
1389
1390 //--------------------- ImagePacker ---------------------------------------------------------------------------
FFiOHOSImagePackerConstructor()1391 int64_t FFiOHOSImagePackerConstructor()
1392 {
1393 auto ret = FFIData::Create<ImagePackerImpl>();
1394 if (!ret) {
1395 return INIT_FAILED;
1396 }
1397 return ret->GetID();
1398 }
1399
ParseCPackOption(CPackingOptionV2 option)1400 static PackOption ParseCPackOption(CPackingOptionV2 option)
1401 {
1402 PackOption packOption = {
1403 .format = option.format,
1404 .quality = option.quality,
1405 .desiredDynamicRange = EncodeDynamicRange(option.desiredDynamicRange),
1406 .needsPackProperties = option.needsPackProperties,
1407 };
1408 return packOption;
1409 }
1410
FfiOHOSImagePackerPackingPixelMap(int64_t id,int64_t source,CPackingOption option)1411 RetDataCArrUI8 FfiOHOSImagePackerPackingPixelMap(int64_t id, int64_t source, CPackingOption option)
1412 {
1413 CArrUI8 data = { .head = nullptr, .size = 0 };
1414 RetDataCArrUI8 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = data };
1415 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1416 if (!imagePackerImpl) {
1417 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1418 return ret;
1419 }
1420
1421 auto pixelMapImpl = FFIData::GetData<PixelMapImpl>(source);
1422 if (pixelMapImpl != nullptr) {
1423 auto pixelMap = pixelMapImpl->GetRealPixelMap();
1424 if (!pixelMap) {
1425 return ret;
1426 }
1427 PackOption packOption = { .format = option.format, .quality = option.quality};
1428 auto [code, head, size] = imagePackerImpl->Packing(*pixelMap, packOption, option.bufferSize);
1429 if (code != SUCCESS_CODE) {
1430 IMAGE_LOGE("Packing failed, error code is %{public}d", code);
1431 }
1432 data.head = head;
1433 data.size = size;
1434 ret.code = code;
1435 ret.data = data;
1436 return ret;
1437 }
1438
1439 IMAGE_LOGE("Packing failed, invalid id of PixelMapImpl");
1440 return ret;
1441 }
1442
FfiOHOSImagePackerPackingPixelMapV2(int64_t id,int64_t source,CPackingOptionV2 option)1443 RetDataCArrUI8 FfiOHOSImagePackerPackingPixelMapV2(int64_t id, int64_t source, CPackingOptionV2 option)
1444 {
1445 CArrUI8 data = { .head = nullptr, .size = 0 };
1446 RetDataCArrUI8 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = data };
1447 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1448 if (!imagePackerImpl) {
1449 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1450 return ret;
1451 }
1452
1453 auto pixelMapImpl = FFIData::GetData<PixelMapImpl>(source);
1454 if (pixelMapImpl != nullptr) {
1455 auto pixelMap = pixelMapImpl->GetRealPixelMap();
1456 if (!pixelMap) {
1457 return ret;
1458 }
1459 PackOption packOption = { .format = option.format, .quality = option.quality};
1460 auto [code, head, size] = imagePackerImpl->Packing(*pixelMap, packOption, option.bufferSize);
1461 if (code != SUCCESS_CODE) {
1462 IMAGE_LOGE("Packing failed, error code is %{public}d", code);
1463 }
1464 data.head = head;
1465 data.size = size;
1466 ret.code = code;
1467 ret.data = data;
1468 return ret;
1469 }
1470
1471 IMAGE_LOGE("Packing failed, invalid id of PixelMapImpl");
1472 return ret;
1473 }
1474
FfiOHOSImagePackerPackingImageSource(int64_t id,int64_t source,CPackingOption option)1475 RetDataCArrUI8 FfiOHOSImagePackerPackingImageSource(int64_t id, int64_t source, CPackingOption option)
1476 {
1477 CArrUI8 data = { .head = nullptr, .size = 0 };
1478 RetDataCArrUI8 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = data };
1479 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1480 if (!imagePackerImpl) {
1481 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1482 return ret;
1483 }
1484
1485 auto imageSourceImpl = FFIData::GetData<ImageSourceImpl>(source);
1486 if (imageSourceImpl != nullptr) {
1487 PackOption packOption = { .format = option.format, .quality = option.quality};
1488 auto imageSource = imageSourceImpl->nativeImgSrc;
1489 if (!imageSource) {
1490 return ret;
1491 }
1492 auto [code, head, size] = imagePackerImpl->Packing(*imageSource, packOption, option.bufferSize);
1493 if (code != SUCCESS_CODE) {
1494 IMAGE_LOGE("Packing failed, error code is %{public}d", code);
1495 }
1496 data.head = head;
1497 data.size = size;
1498 ret.code = code;
1499 ret.data = data;
1500 return ret;
1501 }
1502
1503 IMAGE_LOGE("Packing failed, invalid id of ImageSourceImpl");
1504 return ret;
1505 }
1506
FfiOHOSImagePackerPackingImageSourceV2(int64_t id,int64_t source,CPackingOptionV2 option)1507 RetDataCArrUI8 FfiOHOSImagePackerPackingImageSourceV2(int64_t id, int64_t source, CPackingOptionV2 option)
1508 {
1509 CArrUI8 data = { .head = nullptr, .size = 0 };
1510 RetDataCArrUI8 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = data };
1511 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1512 if (!imagePackerImpl) {
1513 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1514 return ret;
1515 }
1516
1517 auto imageSourceImpl = FFIData::GetData<ImageSourceImpl>(source);
1518 if (imageSourceImpl != nullptr) {
1519 PackOption packOption = ParseCPackOption(option);
1520 auto imageSource = imageSourceImpl->nativeImgSrc;
1521 if (!imageSource) {
1522 return ret;
1523 }
1524 auto [code, head, size] = imagePackerImpl->Packing(*imageSource, packOption, option.bufferSize);
1525 if (code != SUCCESS_CODE) {
1526 IMAGE_LOGE("Packing failed, error code is %{public}d", code);
1527 }
1528 data.head = head;
1529 data.size = size;
1530 ret.code = code;
1531 ret.data = data;
1532 return ret;
1533 }
1534
1535 IMAGE_LOGE("Packing failed, invalid id of ImageSourceImpl");
1536 return ret;
1537 }
1538
FfiOHOSImagePackerGetSupportedFormats(int64_t id)1539 RetDataCArrString FfiOHOSImagePackerGetSupportedFormats(int64_t id)
1540 {
1541 RetDataCArrString ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = { .head = nullptr, .size = 0 } };
1542 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1543 if (!imagePackerImpl) {
1544 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1545 return ret;
1546 }
1547
1548 auto imagePacker = imagePackerImpl->GetImagePacker();
1549 if (!imagePacker) {
1550 IMAGE_LOGE("fail to get ImagePacker");
1551 return ret;
1552 }
1553
1554 std::set<std::string> formats;
1555 uint32_t formatsRet = imagePacker->GetSupportedFormats(formats);
1556 if (formatsRet != SUCCESS_CODE) {
1557 IMAGE_LOGE("fail to get supported formats");
1558 return ret;
1559 }
1560
1561 CArrString arrInfo { .head = nullptr, .size = 0 };
1562 auto size = formats.size();
1563 if (size == 0) {
1564 IMAGE_LOGE("[ImageSource] FfiOHOSImagePackerGetSupportedFormats size cannot be equal to 0.");
1565 ret.code = ERR_SHAMEM_NOT_EXIST;
1566 return ret;
1567 }
1568 auto arr = static_cast<char**>(malloc(sizeof(char*) * size));
1569 if (!arr) {
1570 IMAGE_LOGE("[ImageSource] FfiOHOSImagePackerGetSupportedFormats failed to malloc arr.");
1571 ret.code = ERR_SHAMEM_NOT_EXIST;
1572 return ret;
1573 }
1574
1575 uint32_t i = 0;
1576 for (const auto& format : formats) {
1577 auto temp = ::Utils::MallocCString(format);
1578 if (!temp) {
1579 FreeArrayPtr(arr, i);
1580 free(arr);
1581 ret.code = ERR_SHAMEM_NOT_EXIST;
1582 return ret;
1583 }
1584 arr[i++] = temp;
1585 }
1586
1587 arrInfo.head = arr;
1588 arrInfo.size = static_cast<int64_t>(formats.size());
1589 ret.code = SUCCESS_CODE;
1590 ret.data = arrInfo;
1591
1592 return ret;
1593 }
1594
FfiOHOSImagePackerPackPixelMapToFile(int64_t id,int64_t source,int fd,CPackingOption option)1595 uint32_t FfiOHOSImagePackerPackPixelMapToFile(int64_t id, int64_t source, int fd, CPackingOption option)
1596 {
1597 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1598 if (!imagePackerImpl) {
1599 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1600 return ERR_IMAGE_INIT_ABNORMAL;
1601 }
1602
1603 auto pixelMapImpl = FFIData::GetData<PixelMapImpl>(source);
1604 if (pixelMapImpl != nullptr) {
1605 auto pixelMap = pixelMapImpl->GetRealPixelMap();
1606 if (!pixelMap) {
1607 return ERR_IMAGE_INIT_ABNORMAL;
1608 }
1609
1610 PackOption packOption = { .format = option.format, .quality = option.quality};
1611 uint32_t ret = imagePackerImpl->PackToFile(*pixelMap, fd, packOption);
1612 return ret;
1613 }
1614 return ERR_IMAGE_INIT_ABNORMAL;
1615 }
1616
FfiOHOSImagePackerPackPixelMapToFileV2(int64_t id,int64_t source,int fd,CPackingOptionV2 option)1617 uint32_t FfiOHOSImagePackerPackPixelMapToFileV2(int64_t id, int64_t source, int fd, CPackingOptionV2 option)
1618 {
1619 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1620 if (!imagePackerImpl) {
1621 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1622 return ERR_IMAGE_INIT_ABNORMAL;
1623 }
1624
1625 auto pixelMapImpl = FFIData::GetData<PixelMapImpl>(source);
1626 if (pixelMapImpl != nullptr) {
1627 auto pixelMap = pixelMapImpl->GetRealPixelMap();
1628 if (!pixelMap) {
1629 return ERR_IMAGE_INIT_ABNORMAL;
1630 }
1631
1632 PackOption packOption = ParseCPackOption(option);
1633 uint32_t ret = imagePackerImpl->PackToFile(*pixelMap, fd, packOption);
1634 return ret;
1635 }
1636 return ERR_IMAGE_INIT_ABNORMAL;
1637 }
1638
FfiOHOSImagePackerImageSourcePackToFile(int64_t id,int64_t source,int fd,CPackingOption option)1639 uint32_t FfiOHOSImagePackerImageSourcePackToFile(int64_t id, int64_t source, int fd, CPackingOption option)
1640 {
1641 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1642 if (!imagePackerImpl) {
1643 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1644 return ERR_IMAGE_INIT_ABNORMAL;
1645 }
1646
1647 auto imageSourceImpl = FFIData::GetData<ImageSourceImpl>(source);
1648 if (imageSourceImpl != nullptr) {
1649 PackOption packOption = { .format = option.format, .quality = option.quality};
1650 auto imageSource = imageSourceImpl->nativeImgSrc;
1651 if (!imageSource) {
1652 return ERR_IMAGE_INIT_ABNORMAL;
1653 }
1654
1655 uint32_t ret = imagePackerImpl->PackToFile(*imageSource, fd, packOption);
1656 return ret;
1657 }
1658 return ERR_IMAGE_INIT_ABNORMAL;
1659 }
1660
FfiOHOSImagePackerImageSourcePackToFileV2(int64_t id,int64_t source,int fd,CPackingOptionV2 option)1661 uint32_t FfiOHOSImagePackerImageSourcePackToFileV2(int64_t id, int64_t source, int fd, CPackingOptionV2 option)
1662 {
1663 auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1664 if (!imagePackerImpl) {
1665 IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1666 return ERR_IMAGE_INIT_ABNORMAL;
1667 }
1668
1669 auto imageSourceImpl = FFIData::GetData<ImageSourceImpl>(source);
1670 if (imageSourceImpl != nullptr) {
1671 PackOption packOption = ParseCPackOption(option);
1672 auto imageSource = imageSourceImpl->nativeImgSrc;
1673 if (!imageSource) {
1674 return ERR_IMAGE_INIT_ABNORMAL;
1675 }
1676
1677 uint32_t ret = imagePackerImpl->PackToFile(*imageSource, fd, packOption);
1678 return ret;
1679 }
1680 return ERR_IMAGE_INIT_ABNORMAL;
1681 }
1682
FfiOHOSGetPackOptionSize()1683 uint64_t FfiOHOSGetPackOptionSize()
1684 {
1685 return sizeof(PackOption);
1686 }
1687
FFiOHOSImagePackerRelease(int64_t id)1688 void FFiOHOSImagePackerRelease(int64_t id)
1689 {
1690 IMAGE_LOGD("FFiOHOSImagePackerRelease start");
1691 auto instance = FFIData::GetData<ImagePackerImpl>(id);
1692 if (!instance) {
1693 return;
1694 }
1695 instance->Release();
1696 IMAGE_LOGD("FFiOHOSImagePackerRelease success");
1697 }
1698
1699 //--------------------- ImageCreator ---------------------------------------------------------------------------
FFiOHOSImageCreatorConstructor(int32_t width,int32_t height,int32_t format,int32_t capacity)1700 int64_t FFiOHOSImageCreatorConstructor(int32_t width, int32_t height, int32_t format, int32_t capacity)
1701 {
1702 auto ret = FFIData::Create<ImageCreatorImpl>(width, height, format, capacity);
1703 if (!ret) {
1704 return INIT_FAILED;
1705 }
1706 return ret->GetID();
1707 }
1708
FFiOHOSImageCreatorGetCapacity(int64_t id)1709 RetDataI32 FFiOHOSImageCreatorGetCapacity(int64_t id)
1710 {
1711 IMAGE_LOGD("FFiOHOSImageCreatorGetCapacity start");
1712 RetDataI32 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = 0 };
1713 auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1714 if (!instance) {
1715 IMAGE_LOGE("FFiOHOSImageCreatorGetCapacity instance not exist %{public}" PRId64, id);
1716 return ret;
1717 }
1718
1719 std::shared_ptr<ImageCreator> imageCreator = instance->GetImageCreator();
1720 if (!imageCreator) {
1721 IMAGE_LOGE("FFiOHOSImageCreatorGetCapacity imageCreator is nullptr.");
1722 return ret;
1723 }
1724
1725 std::shared_ptr<ImageCreatorContext> context = imageCreator->iraContext_;
1726 if (!context) {
1727 IMAGE_LOGE("FFiOHOSImageCreatorGetCapacity context is nullptr.");
1728 return ret;
1729 }
1730
1731 ret.data = context->GetCapicity();
1732 ret.code = SUCCESS_CODE;
1733 IMAGE_LOGD("FFiOHOSImageCreatorGetCapacity success");
1734 return ret;
1735 }
1736
FFiOHOSImageCreatorGetformat(int64_t id)1737 RetDataI32 FFiOHOSImageCreatorGetformat(int64_t id)
1738 {
1739 IMAGE_LOGD("FFiOHOSImageCreatorGetformat start");
1740 RetDataI32 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = 0 };
1741 auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1742 if (!instance) {
1743 IMAGE_LOGE("FFiOHOSImageCreatorGetformat instance not exist %{public}" PRId64, id);
1744 return ret;
1745 }
1746
1747 std::shared_ptr<ImageCreator> imageCreator = instance->GetImageCreator();
1748 if (!imageCreator) {
1749 IMAGE_LOGE("FFiOHOSImageCreatorGetformat imageCreator is nullptr.");
1750 return ret;
1751 }
1752
1753 std::shared_ptr<ImageCreatorContext> context = imageCreator->iraContext_;
1754 if (!context) {
1755 IMAGE_LOGE("FFiOHOSImageCreatorGetformat context is nullptr.");
1756 return ret;
1757 }
1758
1759 ret.data = context->GetFormat();
1760 ret.code = SUCCESS_CODE;
1761 IMAGE_LOGD("FFiOHOSImageCreatorGetformat success");
1762 return ret;
1763 }
1764
FFiOHOSImageCreatorDequeueImage(int64_t id,uint32_t * errCode)1765 int64_t FFiOHOSImageCreatorDequeueImage(int64_t id, uint32_t* errCode)
1766 {
1767 IMAGE_LOGD("FFiOHOSImageCreatorDequeueImage start");
1768 auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1769 if (!instance) {
1770 *errCode = ERR_IMAGE_INIT_ABNORMAL;
1771 return INIT_FAILED;
1772 }
1773
1774 std::shared_ptr<ImageCreator> imageCreator = instance->GetImageCreator();
1775 if (!imageCreator) {
1776 *errCode = ERR_IMAGE_INIT_ABNORMAL;
1777 return INIT_FAILED;
1778 }
1779 std::shared_ptr<NativeImage> nativeImageRes = imageCreator->DequeueNativeImage();
1780 if (!nativeImageRes) {
1781 *errCode = ERR_IMAGE_INIT_ABNORMAL;
1782 return INIT_FAILED;
1783 }
1784 auto ret = FFIData::Create<ImageImpl>(nativeImageRes);
1785 if (!ret) {
1786 *errCode = ERR_IMAGE_INIT_ABNORMAL;
1787 return INIT_FAILED;
1788 }
1789 *errCode = SUCCESS_CODE;
1790 return ret->GetID();
1791 }
1792
FFiOHOSImageCreatorQueueImage(int64_t id,int64_t imageId)1793 void FFiOHOSImageCreatorQueueImage(int64_t id, int64_t imageId)
1794 {
1795 IMAGE_LOGD("FFiOHOSImageCreatorQueueImage start");
1796 auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1797 if (!instance) {
1798 IMAGE_LOGE("[ImageCreator] instance not exist %{public}" PRId64, id);
1799 return;
1800 }
1801 auto imageInstance = FFIData::GetData<ImageImpl>(imageId);
1802 if (!imageInstance) {
1803 IMAGE_LOGE("[ImageCreator] imageInstance not exist %{public}" PRId64, imageId);
1804 return;
1805 }
1806 std::shared_ptr<ImageCreator> imageCreator = instance->GetImageCreator();
1807 if (!imageCreator) {
1808 IMAGE_LOGE("[ImageCreator] imageCreator can not be nullptr");
1809 return;
1810 }
1811 imageCreator->QueueNativeImage(imageInstance->GetNativeImage());
1812 IMAGE_LOGD("FFiOHOSImageCreatorQueueImage success");
1813 }
1814
FFiOHOSImageCreatorRelease(int64_t id)1815 void FFiOHOSImageCreatorRelease(int64_t id)
1816 {
1817 IMAGE_LOGD("FFiOHOSImageCreatorRelease start");
1818 auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1819 if (!instance) {
1820 IMAGE_LOGE("[ImageCreator] instance not exist %{public}" PRId64, id);
1821 return;
1822 }
1823 instance->Release();
1824 IMAGE_LOGD("FFiOHOSImageCreatorRelease success");
1825 }
1826
FfiImageImageCreatorImplOn(int64_t id,char * name,int64_t callbackId)1827 uint32_t FfiImageImageCreatorImplOn(int64_t id, char* name, int64_t callbackId)
1828 {
1829 IMAGE_LOGD("FfiImageImageCreatorImplOn start");
1830 auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1831 if (!instance) {
1832 IMAGE_LOGE("[ImageCreator] instance not exist %{public}" PRId64, id);
1833 return ERR_IMAGE_INIT_ABNORMAL;
1834 }
1835 auto cFunc = reinterpret_cast<void (*)()>(callbackId);
1836 std::function<void()> func = CJLambda::Create(cFunc);
1837 return instance->CjOn(name, func);
1838 }
1839
FfiConvertPixelMap2Napi(napi_env env,uint64_t id)1840 napi_value FfiConvertPixelMap2Napi(napi_env env, uint64_t id)
1841 {
1842 napi_value undefined = nullptr;
1843 napi_get_undefined(env, &undefined);
1844 auto instance = FFIData::GetData<PixelMapImpl>(id);
1845 if (instance == nullptr || instance->GetRealPixelMap() == nullptr) {
1846 IMAGE_LOGE("[PixelMap]: instance not exist %{public}" PRId64, id);
1847 return undefined;
1848 }
1849
1850 napi_value result = PixelMapNapi::CreatePixelMap(env, instance->GetRealPixelMap());
1851 napi_valuetype type = napi_undefined;
1852 if (napi_typeof(env, result, &type) != napi_ok || type == napi_undefined) {
1853 IMAGE_LOGE("[PixelMap]: create napiobj failed.");
1854 return undefined;
1855 }
1856 PixelMapNapi* pixelMapNapi = nullptr;
1857 napi_status status = napi_unwrap(env, result, reinterpret_cast<void**>(&pixelMapNapi));
1858 if (status != napi_ok || pixelMapNapi == nullptr) {
1859 IMAGE_LOGE("[PixelMap]: unwrap failed");
1860 return undefined;
1861 }
1862 pixelMapNapi->setPixelNapiEditable(instance->GetPixelMapImplEditable());
1863 pixelMapNapi->SetTransferDetach(instance->GetTransferDetach());
1864 return result;
1865 }
1866
FfiCreatePixelMapFromNapi(napi_env env,napi_value pixelmap)1867 int64_t FfiCreatePixelMapFromNapi(napi_env env, napi_value pixelmap)
1868 {
1869 if (env == nullptr || pixelmap == nullptr) {
1870 IMAGE_LOGE("[PixelMap]: parameter nullptr!");
1871 return ERR_IMAGE_INIT_ABNORMAL;
1872 }
1873
1874 napi_valuetype type = napi_undefined;
1875 if (napi_typeof(env, pixelmap, &type) != napi_ok || type != napi_object) {
1876 IMAGE_LOGE("[PixelMap]: parameter napi value type is not object!");
1877 return ERR_IMAGE_INIT_ABNORMAL;
1878 }
1879
1880 PixelMapNapi* obj = nullptr;
1881 napi_status status = napi_unwrap(env, pixelmap, reinterpret_cast<void**>(&obj));
1882 if (status != napi_ok || obj == nullptr) {
1883 IMAGE_LOGE("[PixelMap]: unwrap failed");
1884 return ERR_IMAGE_INIT_ABNORMAL;
1885 }
1886
1887 std::shared_ptr<PixelMap>* nativeObj = obj->GetPixelMap();
1888 if (nativeObj == nullptr) {
1889 IMAGE_LOGE("[PixelMap]: native pixelmap has released.");
1890 return ERR_IMAGE_INIT_ABNORMAL;
1891 }
1892
1893 auto native = FFIData::Create<PixelMapImpl>(*nativeObj, obj->GetPixelNapiEditable(), obj->GetTransferDetach());
1894 if (native == nullptr) {
1895 IMAGE_LOGE("[PixelMap]: Create ffidata failed.");
1896 return ERR_IMAGE_INIT_ABNORMAL;
1897 }
1898
1899 return native->GetID();
1900 }
1901 }
1902 } // namespace Media
1903 } // namespace OHOS