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