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 
FfiOHOSImageSourceGetImageInfo(int64_t id,uint32_t index,uint32_t * errCode)226     CImageInfo FfiOHOSImageSourceGetImageInfo(int64_t id, uint32_t index, uint32_t* errCode)
227     {
228         IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceGetImageInfo start");
229         *errCode = ERR_IMAGE_INIT_ABNORMAL;
230         auto instance = FFIData::GetData<ImageSourceImpl>(id);
231         CImageInfo ret;
232         if (!instance) {
233             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
234             return ret;
235         }
236         ImageInfo info;
237         *errCode = instance->GetImageInfo(index, info);
238         if (*errCode != 0) {
239             return ret;
240         }
241         ret.height = info.size.height;
242         ret.width = info.size.width;
243         ret.density = info.baseDensity;
244         IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceGetImageInfo success");
245         return ret;
246     }
247 
FreeArrayPtr(char ** ptr,int count)248     void FreeArrayPtr(char** ptr, int count)
249     {
250         for (int i = 0; i < count; i++) {
251             free(ptr[i]);
252         }
253     }
254 
FfiOHOSGetSupportedFormats(int64_t id,uint32_t * errCode)255     CArrString FfiOHOSGetSupportedFormats(int64_t id, uint32_t* errCode)
256     {
257         IMAGE_LOGD("[ImageSource] FfiOHOSGetSupportedFormats start");
258         CArrString ret = { .head = nullptr, .size = 0 };
259         *errCode = ERR_IMAGE_INIT_ABNORMAL;
260         auto instance = FFIData::GetData<ImageSourceImpl>(id);
261         if (!instance) {
262             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
263             return ret;
264         }
265         std::set<std::string> formats;
266         *errCode = instance->GetSupportedFormats(formats);
267         if (*errCode == SUCCESS_CODE) {
268             size_t size =  formats.size();
269             if (size == 0) {
270                 IMAGE_LOGE("[ImageSource] FfiOHOSGetSupportedFormats size cannot be equal to 0.");
271                 *errCode = ERR_IMAGE_MALLOC_ABNORMAL;
272                 return ret;
273             }
274 
275             auto arr = static_cast<char**>(malloc(sizeof(char*) * size));
276             if (!arr) {
277                 IMAGE_LOGE("[ImageSource] FfiOHOSGetSupportedFormats failed to malloc arr.");
278                 *errCode = ERR_IMAGE_MALLOC_ABNORMAL;
279                 return ret;
280             }
281 
282             int32_t i = 0;
283             for (const std::string& str: formats) {
284                 auto temp = Utils::MallocCString(str);
285                 if (!temp) {
286                     IMAGE_LOGE("[ImageSource] FfiOHOSGetSupportedFormats failed to copy string.");
287                     FreeArrayPtr(arr, i);
288                     free(arr);
289                     *errCode = ERR_IMAGE_MALLOC_ABNORMAL;
290                     return ret;
291                 }
292                 arr[i] = temp;
293                 i++;
294             }
295             ret.head = arr;
296             ret.size = static_cast<int64_t>(size);
297         }
298         IMAGE_LOGD("[ImageSource] FfiOHOSGetSupportedFormats success");
299         return ret;
300     }
301 
FfiOHOSGetImageProperty(int64_t id,char * key,uint32_t index,char * defaultValue,uint32_t * errCode)302     char* FfiOHOSGetImageProperty(int64_t id, char* key, uint32_t index, char* defaultValue, uint32_t* errCode)
303     {
304         IMAGE_LOGD("[ImageSource] FfiOHOSGetImageProperty start");
305         char* ret = nullptr;
306         *errCode = ERR_IMAGE_INIT_ABNORMAL;
307         auto instance = FFIData::GetData<ImageSourceImpl>(id);
308         if (!instance) {
309             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
310             return ret;
311         }
312         std::string skey = key;
313         std::string value = defaultValue;
314         *errCode = instance->GetImageProperty(skey, index, value);
315         ret = Utils::MallocCString(value);
316         IMAGE_LOGD("[ImageSource] FfiOHOSGetImageProperty success");
317         return ret;
318     }
319 
FfiOHOSModifyImageProperty(int64_t id,char * key,char * value)320     uint32_t FfiOHOSModifyImageProperty(int64_t id, char* key, char* value)
321     {
322         IMAGE_LOGD("[ImageSource] FfiOHOSModifyImageProperty start");
323         auto instance = FFIData::GetData<ImageSourceImpl>(id);
324         if (!instance) {
325             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
326             return ERR_IMAGE_INIT_ABNORMAL;
327         }
328         uint32_t ret =  instance->ModifyImageProperty(key, value);
329         IMAGE_LOGD("[ImageSource] FfiOHOSModifyImageProperty success");
330         return ret;
331     }
332 
FfiOHOSGetFrameCount(int64_t id)333     RetDataUI32 FfiOHOSGetFrameCount(int64_t id)
334     {
335         IMAGE_LOGD("[ImageSource] FfiOHOSGetFrameCount start");
336         RetDataUI32 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = 0 };
337         auto instance = FFIData::GetData<ImageSourceImpl>(id);
338         if (!instance) {
339             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
340             return ret;
341         }
342         ret.data = instance->GetFrameCount(ret.code);
343         IMAGE_LOGD("[ImageSource] FfiOHOSGetFrameCount success");
344         return ret;
345     }
346 
FfiOHOSUpdateData(int64_t id,UpdateDataInfo info)347     uint32_t FfiOHOSUpdateData(int64_t id, UpdateDataInfo info)
348     {
349         IMAGE_LOGD("[ImageSource] FfiOHOSUpdateData start");
350         auto instance = FFIData::GetData<ImageSourceImpl>(id);
351         if (!instance) {
352             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
353             return ERR_IMAGE_INIT_ABNORMAL;
354         }
355         uint8_t *buffer = info.data;
356         if (info.offset < info.arrSize) {
357             buffer = buffer + info.offset;
358         }
359         uint32_t lastSize = info.arrSize - info.offset;
360         uint32_t size = info.updateLen < lastSize ? info.updateLen : lastSize;
361         uint32_t ret = instance->UpdateData(buffer, size, info.isCompleted);
362         if (ret == 0) {
363             auto incPixelMap = instance->GetIncrementalPixelMap();
364             if (incPixelMap != nullptr) {
365                 uint8_t decodeProgress = 0;
366                 uint32_t err = incPixelMap->PromoteDecoding(decodeProgress);
367                 if (!(err == SUCCESS_CODE || (err == ERR_IMAGE_SOURCE_DATA_INCOMPLETE && !info.isCompleted))) {
368                     IMAGE_LOGE("UpdateData PromoteDecoding error");
369                 }
370                 if (info.isCompleted) {
371                     incPixelMap->DetachFromDecoding();
372                 }
373             }
374         }
375 
376         IMAGE_LOGD("[ImageSource] FfiOHOSUpdateData success");
377         return ret;
378     }
379 
FfiOHOSRelease(int64_t id)380     uint32_t FfiOHOSRelease(int64_t id)
381     {
382         IMAGE_LOGD("[ImageSource] FfiOHOSRelease start");
383         auto instance = FFIData::GetData<ImageSourceImpl>(id);
384         if (!instance) {
385             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
386             return ERR_IMAGE_INIT_ABNORMAL;
387         }
388         instance->Release();
389         IMAGE_LOGD("[ImageSource] FfiOHOSRelease success");
390         return SUCCESS_CODE;
391     }
392 
ParseCDecodingOptions(CDecodingOptions & opts)393     static DecodeOptions ParseCDecodingOptions(CDecodingOptions &opts)
394     {
395         DecodeOptions decodeOpts;
396         decodeOpts.fitDensity = opts.fitDensity;
397         decodeOpts.desiredSize.height = opts.desiredSize.height;
398         decodeOpts.desiredSize.width = opts.desiredSize.width;
399         IMAGE_LOGD("[ImageSource] desiredSize height is %{public}d, width is %{public}d",
400             decodeOpts.desiredSize.height, decodeOpts.desiredSize.width);
401         decodeOpts.desiredRegion.height = opts.desiredRegion.size.height;
402         decodeOpts.desiredRegion.width = opts.desiredRegion.size.width;
403         decodeOpts.desiredRegion.left = opts.desiredRegion.x;
404         decodeOpts.desiredRegion.top = opts.desiredRegion.y;
405         IMAGE_LOGD("[ImageSource] desiredRegion height is %{public}d, width is %{public}d," \
406             "left is %{public}d, top is %{public}d",
407             decodeOpts.desiredRegion.height, decodeOpts.desiredRegion.width,
408             decodeOpts.desiredRegion.left, decodeOpts.desiredRegion.top);
409         decodeOpts.rotateDegrees = opts.rotateDegrees;
410         decodeOpts.sampleSize = opts.sampleSize;
411         decodeOpts.desiredPixelFormat = PixelFormat(opts.desiredPixelFormat);
412         decodeOpts.editable = opts.editable;
413         if (opts.desiredColorSpace != 0) {
414             auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(opts.desiredColorSpace);
415             if (colorSpace != nullptr) {
416                 decodeOpts.desiredColorSpaceInfo = colorSpace->GetColorSpaceToken();
417             }
418         }
419         return decodeOpts;
420     }
421 
FfiOHOSImageSourceCreatePixelMapList(int64_t id,uint32_t index,CDecodingOptions opts,uint32_t * errorCode)422     CArrI64 FfiOHOSImageSourceCreatePixelMapList(int64_t id, uint32_t index, CDecodingOptions opts,
423         uint32_t* errorCode)
424     {
425         IMAGE_LOGD("[ImageSource] CreatePixelMapList start");
426         CArrI64 ret = {.head = nullptr, .size = 0 };
427         auto instance = FFIData::GetData<ImageSourceImpl>(id);
428         if (!instance) {
429             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
430             *errorCode = ERR_IMAGE_INIT_ABNORMAL;
431             return ret;
432         }
433         DecodeOptions decodeOpts = ParseCDecodingOptions(opts);
434         std::vector<int64_t> data = instance->CreatePixelMapList(index, decodeOpts, errorCode);
435         if (*errorCode == SUCCESS_CODE) {
436             auto size = data.size();
437             if (size == 0) {
438                 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
439                 IMAGE_LOGE("[ImageSource] CreatePixelMapList size error.");
440                 return ret;
441             }
442 
443             auto arr = static_cast<int64_t*>(malloc(sizeof(int64_t) * size));
444             if (!arr) {
445                 IMAGE_LOGE("[ImageSource] FfiOHOSImageSourceCreatePixelMapList failed to malloc arr.");
446                 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
447                 return ret;
448             }
449             for (int i = 0; i < static_cast<int>(size); ++i) {
450                 arr[i] = data[i];
451             }
452             ret.head = arr;
453             ret.size = static_cast<int64_t>(data.size());
454         }
455         IMAGE_LOGD("[ImageSource] CreatePixelMapList success");
456         return ret;
457     }
458 
FfiOHOSImageSourceGetDelayTime(int64_t id,uint32_t * errorCode)459     CArrI32 FfiOHOSImageSourceGetDelayTime(int64_t id, uint32_t* errorCode)
460     {
461         IMAGE_LOGD("[ImageSource] GetDelayTime start");
462         CArrI32 ret = {.head = nullptr, .size = 0 };
463         auto instance = FFIData::GetData<ImageSourceImpl>(id);
464         if (!instance) {
465             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
466             *errorCode = ERR_IMAGE_INIT_ABNORMAL;
467             return ret;
468         }
469         auto data = instance->GetDelayTime(errorCode);
470         if (*errorCode == SUCCESS_CODE) {
471             auto size = data->size();
472             if (size <= 0) {
473                 IMAGE_LOGE("[ImageSource] FfiOHOSImageSourceGetDelayTime size cannot be less than or equal to 0.");
474                 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
475                 return ret;
476             }
477             auto arr = static_cast<int32_t*>(malloc(sizeof(int32_t) * size));
478             if (!arr) {
479                 IMAGE_LOGE("[ImageSource] FfiOHOSImageSourceGetDelayTime failed to malloc arr.");
480                 *errorCode = ERR_IMAGE_MALLOC_ABNORMAL;
481                 return ret;
482             }
483             for (int i = 0; i < static_cast<int>(size); ++i) {
484                 arr[i] = data->operator[](i);
485             }
486             ret.head = arr;
487             ret.size = static_cast<int64_t>(data->size());
488         }
489         IMAGE_LOGD("[ImageSource] GetDelayTime success");
490         return ret;
491     }
492 
FfiOHOSImageSourceCreatePixelMap(int64_t id,uint32_t index,CDecodingOptions & opts)493     RetDataI64U32 FfiOHOSImageSourceCreatePixelMap(int64_t id, uint32_t index, CDecodingOptions &opts)
494     {
495         IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceCreatePixelMap start");
496         RetDataI64U32 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = 0 };
497         auto instance = FFIData::GetData<ImageSourceImpl>(id);
498         if (!instance) {
499             IMAGE_LOGE("[ImageSource] instance not exist %{public}" PRId64, id);
500             return ret;
501         }
502         DecodeOptions decodeOpts = ParseCDecodingOptions(opts);
503         ret.data = instance->CreatePixelMap(index, decodeOpts, ret.code);
504         IMAGE_LOGD("[ImageSource] FfiOHOSImageSourceCreatePixelMap success");
505         return ret;
506     }
507 
508     //--------------------- PixelMap ---------------------------------------------------------------------------
509 
FfiOHOSCreatePixelMap(uint8_t * colors,uint32_t colorLength,CInitializationOptions opts)510     int64_t FfiOHOSCreatePixelMap(uint8_t *colors, uint32_t colorLength, CInitializationOptions opts)
511     {
512         IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMap start");
513         InitializationOptions option;
514         option.alphaType = AlphaType(opts.alphaType);
515         option.editable = opts.editable;
516         option.pixelFormat = PixelFormat(opts.pixelFormat);
517         option.scaleMode = ScaleMode(opts.scaleMode);
518         option.size.height = opts.height;
519         option.size.width = opts.width;
520         std::unique_ptr<PixelMap> ptr_ =
521             PixelMapImpl::CreatePixelMap(reinterpret_cast<uint32_t*>(colors), colorLength, option);
522         if (!ptr_) {
523             return INIT_FAILED;
524         }
525         auto native = FFIData::Create<PixelMapImpl>(move(ptr_));
526         if (!native) {
527             IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
528             return INIT_FAILED;
529         }
530         IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMap success");
531         return native->GetID();
532     }
533 
FfiOHOSPixelMapRelease(int64_t id)534     uint32_t FfiOHOSPixelMapRelease(int64_t id)
535     {
536         IMAGE_LOGD("[PixelMap] FfiOHOSRelease start");
537         auto instance = FFIData::GetData<PixelMapImpl>(id);
538         if (!instance) {
539             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
540             return ERR_IMAGE_INIT_ABNORMAL;
541         }
542         std::shared_ptr<PixelMap> ptr_ = instance->GetRealPixelMap();
543         ptr_.reset();
544         IMAGE_LOGD("[PixelMap] FfiOHOSRelease success");
545         return SUCCESS_CODE;
546     }
547 
FfiOHOSCreateAlphaPixelMap(int64_t id,uint32_t * errCode)548     int64_t FfiOHOSCreateAlphaPixelMap(int64_t id, uint32_t* errCode)
549     {
550         IMAGE_LOGD("[PixelMap] FfiOHOSCreateAlphaPixelMap start");
551         auto instance = FFIData::GetData<PixelMapImpl>(id);
552         if (!instance) {
553             *errCode = ERR_IMAGE_INIT_ABNORMAL;
554             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
555             return 0;
556         }
557         std::shared_ptr<PixelMap> ptr_ = instance->GetRealPixelMap();
558         if (!ptr_) {
559             *errCode = ERR_IMAGE_INIT_ABNORMAL;
560             IMAGE_LOGE("[PixelMap] ptr is nullptr!");
561             return 0;
562         }
563         InitializationOptions opts;
564         opts.pixelFormat = PixelFormat::ALPHA_8;
565         auto tmpPixelMap = PixelMapImpl::CreateAlphaPixelMap(*ptr_, opts);
566         if (!tmpPixelMap) {
567             *errCode = ERR_IMAGE_INIT_ABNORMAL;
568             IMAGE_LOGE("[PixelMap] tmpPixelMap is nullptr!");
569             return 0;
570         }
571         auto native = FFIData::Create<PixelMapImpl>(move(tmpPixelMap));
572         if (!native) {
573             IMAGE_LOGE("[ImageSource] FfiOHOSCreateImageSourceByPath failed");
574             *errCode = ERR_IMAGE_INIT_ABNORMAL;
575             return INIT_FAILED;
576         }
577         IMAGE_LOGD("[PixelMap] FfiOHOSCreateAlphaPixelMap success");
578         *errCode = SUCCESS_CODE;
579         return native->GetID();
580     }
581 
FfiOHOSReadPixelsToBuffer(int64_t id,uint64_t bufferSize,uint8_t * dst)582     uint32_t FfiOHOSReadPixelsToBuffer(int64_t id, uint64_t bufferSize, uint8_t *dst)
583     {
584         IMAGE_LOGD("[PixelMap] FfiOHOSReadPixelsToBuffer start");
585         auto instance = FFIData::GetData<PixelMapImpl>(id);
586         if (!instance || !instance->GetRealPixelMap()) {
587             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
588             return ERR_IMAGE_INIT_ABNORMAL;
589         }
590         uint32_t ret = instance->ReadPixelsToBuffer(bufferSize, dst);
591         IMAGE_LOGD("[PixelMap] FfiOHOSReadPixelsToBuffer success");
592         return ret;
593     }
594 
FfiOHOSWriteBufferToPixels(int64_t id,uint8_t * source,uint64_t bufferSize)595     uint32_t FfiOHOSWriteBufferToPixels(int64_t id, uint8_t *source, uint64_t bufferSize)
596     {
597         IMAGE_LOGD("[PixelMap] FfiOHOSWriteBufferToPixels start");
598         auto instance = FFIData::GetData<PixelMapImpl>(id);
599         if (!instance || !instance->GetRealPixelMap()) {
600             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
601             return ERR_IMAGE_INIT_ABNORMAL;
602         }
603         uint32_t ret = instance->WriteBufferToPixels(source, bufferSize);
604         IMAGE_LOGD("[PixelMap] FfiOHOSWriteBufferToPixels success");
605         return ret;
606     }
607 
FfiOHOSGetDensity(int64_t id,uint32_t * errCode)608     int32_t FfiOHOSGetDensity(int64_t id, uint32_t* errCode)
609     {
610         IMAGE_LOGD("[PixelMap] FfiOHOSGetDensity start");
611         auto instance = FFIData::GetData<PixelMapImpl>(id);
612         if (!instance || !instance->GetRealPixelMap()) {
613             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
614             *errCode = ERR_IMAGE_INIT_ABNORMAL;
615             return 0;
616         }
617         int32_t ret = instance->GetDensity();
618         *errCode = SUCCESS_CODE;
619         IMAGE_LOGD("[PixelMap] FfiOHOSGetDensity success");
620         return ret;
621     }
622 
FfiOHOSOpacity(int64_t id,float percent)623     uint32_t FfiOHOSOpacity(int64_t id, float percent)
624     {
625         IMAGE_LOGD("[PixelMap] FfiOHOSOpacity start");
626         auto instance = FFIData::GetData<PixelMapImpl>(id);
627         if (!instance || !instance->GetRealPixelMap()) {
628             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
629             return ERR_IMAGE_INIT_ABNORMAL;
630         }
631         uint32_t ret = instance->Opacity(percent);
632         IMAGE_LOGD("[PixelMap] FfiOHOSOpacity success");
633         return ret;
634     }
635 
FfiOHOSCrop(int64_t id,CRegion rect)636     uint32_t FfiOHOSCrop(int64_t id, CRegion rect)
637     {
638         IMAGE_LOGD("[PixelMap] FfiOHOSCrop start");
639         auto instance = FFIData::GetData<PixelMapImpl>(id);
640         if (!instance || !instance->GetRealPixelMap()) {
641             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
642             return ERR_IMAGE_INIT_ABNORMAL;
643         }
644         Rect rt;
645         rt.left = rect.x;
646         rt.top = rect.y;
647         rt.width = rect.size.width;
648         rt.height = rect.size.height;
649         uint32_t ret = instance->Crop(rt);
650         IMAGE_LOGD("[PixelMap] FfiOHOSCrop success");
651         return ret;
652     }
653 
FfiOHOSGetPixelBytesNumber(int64_t id,uint32_t * errCode)654     uint32_t FfiOHOSGetPixelBytesNumber(int64_t id, uint32_t* errCode)
655     {
656         IMAGE_LOGD("[PixelMap] FfiOHOSGetPixelBytesNumber start");
657         auto instance = FFIData::GetData<PixelMapImpl>(id);
658         if (!instance || !instance->GetRealPixelMap()) {
659             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
660             *errCode = ERR_IMAGE_INIT_ABNORMAL;
661             return 0;
662         }
663         uint32_t ret = instance->GetPixelBytesNumber();
664         *errCode = SUCCESS_CODE;
665         IMAGE_LOGD("[PixelMap] FfiOHOSGetPixelBytesNumber success");
666         return ret;
667     }
668 
FfiOHOSGetBytesNumberPerRow(int64_t id,uint32_t * errCode)669     uint32_t FfiOHOSGetBytesNumberPerRow(int64_t id, uint32_t* errCode)
670     {
671         IMAGE_LOGD("[PixelMap] FfiOHOSGetBytesNumberPerRow start");
672         auto instance = FFIData::GetData<PixelMapImpl>(id);
673         if (!instance || !instance->GetRealPixelMap()) {
674             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
675             *errCode = ERR_IMAGE_INIT_ABNORMAL;
676             return 0;
677         }
678         uint32_t ret = instance->GetBytesNumberPerRow();
679         *errCode = SUCCESS_CODE;
680         IMAGE_LOGD("[PixelMap] FfiOHOSGetBytesNumberPerRow success");
681         return ret;
682     }
683 
FfiOHOSGetImageInfo(int64_t id,uint32_t * errCode)684     CImageInfo FfiOHOSGetImageInfo(int64_t id, uint32_t* errCode)
685     {
686         IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfo start");
687         CImageInfo ret;
688         *errCode = ERR_IMAGE_INIT_ABNORMAL;
689         auto instance = FFIData::GetData<PixelMapImpl>(id);
690         if (!instance || !instance->GetRealPixelMap()) {
691             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
692             return ret;
693         }
694         ImageInfo info;
695         instance->GetImageInfo(info);
696         ret.height = info.size.height;
697         ret.width = info.size.width;
698         ret.density = info.baseDensity;
699         *errCode = SUCCESS_CODE;
700         IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfo success");
701         return ret;
702     }
703 
FfiOHOSScale(int64_t id,float xAxis,float yAxis)704     uint32_t FfiOHOSScale(int64_t id, float xAxis, float yAxis)
705     {
706         IMAGE_LOGD("[PixelMap] FfiOHOSScale start");
707         auto instance = FFIData::GetData<PixelMapImpl>(id);
708         if (!instance || !instance->GetRealPixelMap()) {
709             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
710             return ERR_IMAGE_INIT_ABNORMAL;
711         }
712         instance->Scale(xAxis, yAxis);
713         IMAGE_LOGD("[PixelMap] FfiOHOSScale success");
714         return SUCCESS_CODE;
715     }
716 
FfiOHOSFlip(int64_t id,bool xAxis,bool yAxis)717     uint32_t FfiOHOSFlip(int64_t id, bool xAxis, bool yAxis)
718     {
719         IMAGE_LOGD("[PixelMap] FfiOHOSFlip start");
720         auto instance = FFIData::GetData<PixelMapImpl>(id);
721         if (!instance || !instance->GetRealPixelMap()) {
722             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
723             return ERR_IMAGE_INIT_ABNORMAL;
724         }
725         instance->Flip(xAxis, yAxis);
726         IMAGE_LOGD("[PixelMap] FfiOHOSFlip success");
727         return SUCCESS_CODE;
728     }
729 
FfiOHOSRotate(int64_t id,float degrees)730     uint32_t FfiOHOSRotate(int64_t id, float degrees)
731     {
732         IMAGE_LOGD("[PixelMap] FfiOHOSRotate start");
733         auto instance = FFIData::GetData<PixelMapImpl>(id);
734         if (!instance || !instance->GetRealPixelMap()) {
735             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
736             return ERR_IMAGE_INIT_ABNORMAL;
737         }
738         instance->Rotate(degrees);
739         IMAGE_LOGD("[PixelMap] FfiOHOSRotate success");
740         return SUCCESS_CODE;
741     }
742 
FfiOHOSTranslate(int64_t id,float xAxis,float yAxis)743     uint32_t FfiOHOSTranslate(int64_t id, float xAxis, float yAxis)
744     {
745         IMAGE_LOGD("[PixelMap] FfiOHOSTranslate start");
746         auto instance = FFIData::GetData<PixelMapImpl>(id);
747         if (!instance || !instance->GetRealPixelMap()) {
748             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
749             return ERR_IMAGE_INIT_ABNORMAL;
750         }
751         instance->Translate(xAxis, yAxis);
752         IMAGE_LOGD("[PixelMap] FfiOHOSTranslate success");
753         return SUCCESS_CODE;
754     }
755 
FfiOHOSReadPixels(int64_t id,CPositionArea area)756     uint32_t FfiOHOSReadPixels(int64_t id, CPositionArea area)
757     {
758         IMAGE_LOGD("[PixelMap] FfiOHOSReadPixels start");
759         auto instance = FFIData::GetData<PixelMapImpl>(id);
760         if (!instance || !instance->GetRealPixelMap()) {
761             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
762             return ERR_IMAGE_INIT_ABNORMAL;
763         }
764         Rect rt = ParseCRegion(area.region);
765         uint32_t ret = instance->ReadPixels(area.bufferSize, area.offset, area.stride, rt, area.dst);
766         IMAGE_LOGD("[PixelMap] FfiOHOSReadPixels success");
767         return ret;
768     }
769 
FfiOHOSWritePixels(int64_t id,CPositionArea area)770     uint32_t FfiOHOSWritePixels(int64_t id, CPositionArea area)
771     {
772         IMAGE_LOGD("[PixelMap] FfiOHOSWritePixels start");
773         auto instance = FFIData::GetData<PixelMapImpl>(id);
774         if (!instance || !instance->GetRealPixelMap()) {
775             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
776             return ERR_IMAGE_INIT_ABNORMAL;
777         }
778         Rect rt = ParseCRegion(area.region);
779         uint32_t ret = instance->WritePixels(area.dst, area.bufferSize, area.offset, area.stride, rt);
780         IMAGE_LOGD("[PixelMap] FfiOHOSWritePixels success");
781         return ret;
782     }
783 
FfiOHOSGetIsEditable(int64_t id,uint32_t * errCode)784     bool FfiOHOSGetIsEditable(int64_t id, uint32_t* errCode)
785     {
786         IMAGE_LOGD("[PixelMap] FfiOHOSGetIsEditable start");
787         auto instance = FFIData::GetData<PixelMapImpl>(id);
788         bool ret = false;
789         if (!instance || !instance->GetRealPixelMap()) {
790             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
791             *errCode = ERR_IMAGE_INIT_ABNORMAL;
792             return ret;
793         }
794         ret = instance->GetIsEditable();
795         *errCode = SUCCESS_CODE;
796         IMAGE_LOGD("[PixelMap] FfiOHOSGetIsEditable success");
797         return ret;
798     }
799 
FfiOHOSGetIsStrideAlignment(int64_t id,uint32_t * errCode)800     bool FfiOHOSGetIsStrideAlignment(int64_t id, uint32_t* errCode)
801     {
802         IMAGE_LOGD("[PixelMap] FfiOHOSGetIsStrideAlignment start");
803         auto instance = FFIData::GetData<PixelMapImpl>(id);
804         bool ret = false;
805         if (!instance || !instance->GetRealPixelMap()) {
806             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
807             *errCode = ERR_IMAGE_INIT_ABNORMAL;
808             return ret;
809         }
810         ret = instance->GetIsStrideAlignment();
811         *errCode = SUCCESS_CODE;
812         IMAGE_LOGD("[PixelMap] FfiOHOSGetIsStrideAlignment success");
813         return ret;
814     }
815 
FfiOHOSPixelMapSetColorSpace(int64_t id,int64_t colorSpaceId)816     uint32_t FfiOHOSPixelMapSetColorSpace(int64_t id, int64_t colorSpaceId)
817     {
818         IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapSetColorSpace start");
819         auto instance = FFIData::GetData<PixelMapImpl>(id);
820         if (!instance || !instance->GetRealPixelMap()) {
821             IMAGE_LOGE("[PixelMap] PixelMapImpl instance not exist %{public}" PRId64, id);
822             return ERR_IMAGE_INIT_ABNORMAL;
823         }
824         auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(colorSpaceId);
825         if (!colorSpace) {
826             IMAGE_LOGE("[PixelMap] CjColorManager instance not exist %{public}" PRId64, colorSpaceId);
827             return ERR_IMAGE_INVALID_PARAMETER;
828         }
829         uint32_t ret = instance->SetColorSpace(colorSpace->GetColorSpaceToken());
830         IMAGE_LOGD("[PixelMap] FFfiOHOSPixelMapSetColorSpace success");
831         return ret;
832     }
833 
FfiOHOSPixelMapGetColorSpace(int64_t id,int32_t * errCode)834     int64_t FfiOHOSPixelMapGetColorSpace(int64_t id, int32_t* errCode)
835     {
836         IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapGetColorSpace start");
837         auto instance = FFIData::GetData<PixelMapImpl>(id);
838         if (!instance || !instance->GetRealPixelMap()) {
839             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
840             *errCode = ERR_IMAGE_DATA_ABNORMAL;
841             return 0;
842         }
843         auto colorSpace = instance->GetColorSpace();
844         if (!colorSpace) {
845             *errCode = ERR_IMAGE_DATA_UNSUPPORT;
846             return 0;
847         }
848         auto native = FFIData::Create<ColorManager::CjColorManager>(colorSpace);
849         if (!native) {
850             *errCode = ERR_IMAGE_INIT_ABNORMAL;
851             return 0;
852         }
853 
854         IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapGetColorSpace success");
855         *errCode = SUCCESS_CODE;
856         return native->GetID();
857     }
858 
FfiOHOSPixelMapApplyColorSpace(int64_t id,int64_t colorSpaceId)859     uint32_t FfiOHOSPixelMapApplyColorSpace(int64_t id, int64_t colorSpaceId)
860     {
861         IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapApplyColorSpace start");
862         auto instance = FFIData::GetData<PixelMapImpl>(id);
863         if (!instance || !instance->GetRealPixelMap()) {
864             IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
865             return ERR_IMAGE_INIT_ABNORMAL;
866         }
867         auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(colorSpaceId);
868         if (!colorSpace) {
869             IMAGE_LOGE("[PixelMap] CjColorManager instance not exist %{public}" PRId64, colorSpaceId);
870             return ERR_IMAGE_INIT_ABNORMAL;
871         }
872         uint32_t ret = instance->ApplyColorSpace(colorSpace->GetColorSpaceToken());
873         IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapApplyColorSpace success");
874         return ret;
875     }
876 
877     //--------------------- ImageReceiver ------------------------------------------------------------------------
878 
FfiOHOSReceiverGetSize(int64_t id,CSize * retVal)879     uint32_t FfiOHOSReceiverGetSize(int64_t id, CSize *retVal)
880     {
881         IMAGE_LOGD("FfiOHOSReceiverGetSize start");
882         auto instance = FFIData::GetData<ImageReceiverImpl>(id);
883         if (!instance) {
884             return ERR_IMAGE_INIT_ABNORMAL;
885         }
886         uint32_t retCode = instance->GetSize(retVal);
887         IMAGE_LOGD("FfiOHOSReceiverGetSize success");
888         return retCode;
889     }
890 
FfiOHOSReceiverGetCapacity(int64_t id,int32_t * retVal)891     uint32_t FfiOHOSReceiverGetCapacity(int64_t id, int32_t *retVal)
892     {
893         IMAGE_LOGD("FfiOHOSReceiverGetCapacity start");
894         auto instance = FFIData::GetData<ImageReceiverImpl>(id);
895         if (!instance) {
896             return ERR_IMAGE_INIT_ABNORMAL;
897         }
898         uint32_t retCode = instance->GetCapacity(retVal);
899         IMAGE_LOGD("FfiOHOSReceiverGetCapacity success");
900         return retCode;
901     }
902 
FfiOHOSReceiverGetFormat(int64_t id,int32_t * retVal)903     uint32_t FfiOHOSReceiverGetFormat(int64_t id, int32_t *retVal)
904     {
905         IMAGE_LOGD("FfiOHOSReceiverGetFormat start");
906         auto instance = FFIData::GetData<ImageReceiverImpl>(id);
907         if (!instance) {
908             return ERR_IMAGE_INIT_ABNORMAL;
909         }
910         uint32_t retCode = instance->GetFormat(retVal);
911         IMAGE_LOGD("FfiOHOSReceiverGetFormat success");
912         return retCode;
913     }
914 
FfiOHOSCreateImageReceiver(int32_t width,int32_t height,int32_t format,int32_t capacity)915     int64_t FfiOHOSCreateImageReceiver(int32_t width, int32_t height, int32_t format, int32_t capacity)
916     {
917         IMAGE_LOGD("FfiOHOSCreateImageReceiver start");
918         auto id = ImageReceiverImpl::CreateImageReceiver(width, height, format, capacity);
919         IMAGE_LOGD("FfiOHOSCreateImageReceiver success");
920         return id;
921     }
922 
FfiOHOSGetReceivingSurfaceId(int64_t id)923     char* FfiOHOSGetReceivingSurfaceId(int64_t id)
924     {
925         IMAGE_LOGD("FfiOHOSGetReceivingSurfaceId start");
926         auto instance = FFIData::GetData<ImageReceiverImpl>(id);
927         if (!instance) {
928             IMAGE_LOGE("ImageReceiver instance not exist %{public}" PRId64, id);
929             return nullptr;
930         }
931         char *ret = instance->GetReceivingSurfaceId();
932         IMAGE_LOGD("FfiOHOSGetReceivingSurfaceId success");
933         return ret;
934     }
935 
FfiOHOSReadNextImage(int64_t id)936     int64_t FfiOHOSReadNextImage(int64_t id)
937     {
938         IMAGE_LOGD("FfiOHOSReadNextImage start");
939         auto instance = FFIData::GetData<ImageReceiverImpl>(id);
940         if (!instance) {
941             IMAGE_LOGE("ImageReceiver instance not exist %{public}" PRId64, id);
942             return INIT_FAILED;
943         }
944         auto image = instance->ReadNextImage();
945         if (!image) {
946             IMAGE_LOGE("ImageImpl Create is nullptr.");
947             return INIT_FAILED;
948         }
949         IMAGE_LOGD("FfiOHOSReadNextImage success");
950         return image->GetID();
951     }
952 
FfiOHOSReadLatestImage(int64_t id)953     int64_t FfiOHOSReadLatestImage(int64_t id)
954     {
955         IMAGE_LOGD("FfiOHOSReadLatestImage start.");
956         auto instance = FFIData::GetData<ImageReceiverImpl>(id);
957         if (!instance) {
958             IMAGE_LOGE("ImageReceiver instance not exist %{public}" PRId64, id);
959             return INIT_FAILED;
960         }
961         auto image = instance->ReadLatestImage();
962         if (!image) {
963             IMAGE_LOGE("ImageImpl Create is nullptr.");
964             return INIT_FAILED;
965         }
966 
967         IMAGE_LOGD("FfiOHOSReadLatestImage success.");
968         return image->GetID();
969     }
970 
FfiOHOSReceiverRelease(int64_t id)971     void FfiOHOSReceiverRelease(int64_t id)
972     {
973         IMAGE_LOGD("FfiOHOSReceiverRelease start");
974         auto instance = FFIData::GetData<ImageReceiverImpl>(id);
975         if (!instance) {
976             IMAGE_LOGE("ImageReceiver instance not exist %{public}" PRId64, id);
977             return;
978         }
979         instance->Release();
980         IMAGE_LOGD("FfiOHOSReceiverRelease success");
981     }
982 
FfiOHOSImageGetClipRect(int64_t id,CRegion * retVal)983     uint32_t FfiOHOSImageGetClipRect(int64_t id, CRegion *retVal)
984     {
985         IMAGE_LOGD("FfiOHOSImageGetClipRect start");
986         auto instance = FFIData::GetData<ImageImpl>(id);
987         if (!instance) {
988             return ERR_IMAGE_INIT_ABNORMAL;
989         }
990         int64_t retCode = instance->GetClipRect(retVal);
991         IMAGE_LOGD("FfiOHOSImageGetClipRect success");
992         return retCode;
993     }
994 
FfiOHOSImageGetSize(int64_t id,CSize * retVal)995     uint32_t FfiOHOSImageGetSize(int64_t id, CSize *retVal)
996     {
997         IMAGE_LOGD("FfiOHOSImageGetSize start");
998         auto instance = FFIData::GetData<ImageImpl>(id);
999         if (!instance) {
1000             return ERR_IMAGE_INIT_ABNORMAL;
1001         }
1002         uint32_t retCode = instance->GetSize(retVal);
1003         IMAGE_LOGD("FfiOHOSImageGetSize success");
1004         return retCode;
1005     }
1006 
FfiOHOSImageGetFormat(int64_t id,int32_t * retVal)1007     uint32_t FfiOHOSImageGetFormat(int64_t id, int32_t *retVal)
1008     {
1009         IMAGE_LOGD("FfiOHOSImageGetFormat start");
1010         auto instance = FFIData::GetData<ImageImpl>(id);
1011         if (!instance) {
1012             return ERR_IMAGE_INIT_ABNORMAL;
1013         }
1014         uint32_t retCode = instance->GetFormat(retVal);
1015         IMAGE_LOGD("FfiOHOSImageGetFormat success");
1016         return retCode;
1017     }
1018 
FfiOHOSGetComponent(int64_t id,int32_t componentType,CRetComponent * ptr)1019     uint32_t FfiOHOSGetComponent(int64_t id, int32_t componentType, CRetComponent *ptr)
1020     {
1021         IMAGE_LOGD("FfiOHOSGetComponent start");
1022         auto instance = FFIData::GetData<ImageImpl>(id);
1023         if (!instance) {
1024             IMAGE_LOGE("ImageImpl instance not exist %{public}" PRId64, id);
1025             return ERR_IMAGE_INIT_ABNORMAL;
1026         }
1027         uint32_t errCode = instance->GetComponent(componentType, ptr);
1028         IMAGE_LOGD("FfiOHOSGetComponent success");
1029         return errCode;
1030     }
1031 
FfiOHOSImageRelease(int64_t id)1032     void FfiOHOSImageRelease(int64_t id)
1033     {
1034         IMAGE_LOGD("FfiOHOSImageRelease start");
1035         auto instance = FFIData::GetData<ImageImpl>(id);
1036         if (!instance) {
1037             IMAGE_LOGE("ImageImpl instance not exist %{public}" PRId64, id);
1038             return;
1039         }
1040         instance->Release();
1041         IMAGE_LOGD("FfiOHOSImageRelease success");
1042     }
1043 
1044     //--------------------- ImagePacker ---------------------------------------------------------------------------
FFiOHOSImagePackerConstructor()1045     int64_t FFiOHOSImagePackerConstructor()
1046     {
1047         auto ret = FFIData::Create<ImagePackerImpl>();
1048         if (!ret) {
1049             return INIT_FAILED;
1050         }
1051         return ret->GetID();
1052     }
1053 
FfiOHOSImagePackerPackingPixelMap(int64_t id,int64_t source,CPackingOption option)1054     RetDataCArrUI8 FfiOHOSImagePackerPackingPixelMap(int64_t id, int64_t source, CPackingOption option)
1055     {
1056         CArrUI8 data = { .head = nullptr, .size = 0 };
1057         RetDataCArrUI8 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = data };
1058         auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1059         if (!imagePackerImpl) {
1060             IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1061             return ret;
1062         }
1063 
1064         auto pixelMapImpl = FFIData::GetData<PixelMapImpl>(source);
1065         if (pixelMapImpl != nullptr) {
1066             auto pixelMap = pixelMapImpl->GetRealPixelMap();
1067             if (!pixelMap) {
1068                 return ret;
1069             }
1070             PackOption packOption = { .format = option.format, .quality = option.quality};
1071             auto [code, head, size] = imagePackerImpl->Packing(*pixelMap, packOption, option.bufferSize);
1072             if (code != SUCCESS_CODE) {
1073                 IMAGE_LOGE("Packing failed, error code is %{public}d", code);
1074             }
1075             data.head = head;
1076             data.size = size;
1077             ret.code = code;
1078             ret.data = data;
1079             return ret;
1080         }
1081 
1082         IMAGE_LOGE("Packing failed, invalid id of PixelMapImpl");
1083         return ret;
1084     }
1085 
FfiOHOSImagePackerPackingImageSource(int64_t id,int64_t source,CPackingOption option)1086     RetDataCArrUI8 FfiOHOSImagePackerPackingImageSource(int64_t id, int64_t source, CPackingOption option)
1087     {
1088         CArrUI8 data = { .head = nullptr, .size = 0 };
1089         RetDataCArrUI8 ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = data };
1090         auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1091         if (!imagePackerImpl) {
1092             IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1093             return ret;
1094         }
1095 
1096         auto imageSourceImpl = FFIData::GetData<ImageSourceImpl>(source);
1097         if (imageSourceImpl != nullptr) {
1098             PackOption packOption = { .format = option.format, .quality = option.quality};
1099             auto imageSource = imageSourceImpl->nativeImgSrc;
1100             if (!imageSource) {
1101                 return ret;
1102             }
1103             auto [code, head, size] = imagePackerImpl->Packing(*imageSource, packOption, option.bufferSize);
1104             if (code != SUCCESS_CODE) {
1105                 IMAGE_LOGE("Packing failed, error code is %{public}d", code);
1106             }
1107             data.head = head;
1108             data.size = size;
1109             ret.code = code;
1110             ret.data = data;
1111             return ret;
1112         }
1113 
1114         IMAGE_LOGE("Packing failed, invalid id of ImageSourceImpl");
1115         return ret;
1116     }
1117 
FfiOHOSImagePackerGetSupportedFormats(int64_t id)1118     RetDataCArrString FfiOHOSImagePackerGetSupportedFormats(int64_t id)
1119     {
1120         RetDataCArrString ret = { .code = ERR_IMAGE_INIT_ABNORMAL, .data = { .head = nullptr, .size = 0 } };
1121         auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1122         if (!imagePackerImpl) {
1123             IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1124             return ret;
1125         }
1126 
1127         auto imagePacker = imagePackerImpl->GetImagePacker();
1128         if (!imagePacker) {
1129             IMAGE_LOGE("fail to get ImagePacker");
1130             return ret;
1131         }
1132 
1133         std::set<std::string> formats;
1134         uint32_t formatsRet = imagePacker->GetSupportedFormats(formats);
1135         if (formatsRet != SUCCESS_CODE) {
1136             IMAGE_LOGE("fail to get supported formats");
1137             return ret;
1138         }
1139 
1140         CArrString arrInfo { .head = nullptr, .size = 0 };
1141         auto size = formats.size();
1142         if (size == 0) {
1143             IMAGE_LOGE("[ImageSource] FfiOHOSImagePackerGetSupportedFormats size cannot be equal to 0.");
1144             ret.code = ERR_SHAMEM_NOT_EXIST;
1145             return ret;
1146         }
1147         auto arr = static_cast<char**>(malloc(sizeof(char*) * size));
1148         if (!arr) {
1149             IMAGE_LOGE("[ImageSource] FfiOHOSImagePackerGetSupportedFormats failed to malloc arr.");
1150             ret.code = ERR_SHAMEM_NOT_EXIST;
1151             return ret;
1152         }
1153 
1154         uint32_t i = 0;
1155         for (const auto& format : formats) {
1156             auto temp = ::Utils::MallocCString(format);
1157             if (!temp) {
1158                 FreeArrayPtr(arr, i);
1159                 free(arr);
1160                 ret.code = ERR_SHAMEM_NOT_EXIST;
1161                 return ret;
1162             }
1163             arr[i++] = temp;
1164         }
1165 
1166         arrInfo.head = arr;
1167         arrInfo.size = static_cast<int64_t>(formats.size());
1168         ret.code = SUCCESS_CODE;
1169         ret.data = arrInfo;
1170 
1171         return ret;
1172     }
1173 
FfiOHOSImagePackerPackPixelMapToFile(int64_t id,int64_t source,int fd,CPackingOption option)1174     uint32_t FfiOHOSImagePackerPackPixelMapToFile(int64_t id, int64_t source, int fd, CPackingOption option)
1175     {
1176         auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1177         if (!imagePackerImpl) {
1178             IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1179             return ERR_IMAGE_INIT_ABNORMAL;
1180         }
1181 
1182         auto pixelMapImpl = FFIData::GetData<PixelMapImpl>(source);
1183         if (pixelMapImpl != nullptr) {
1184             auto pixelMap = pixelMapImpl->GetRealPixelMap();
1185             if (!pixelMap) {
1186                 return ERR_IMAGE_INIT_ABNORMAL;
1187             }
1188 
1189             PackOption packOption = { .format = option.format, .quality = option.quality};
1190             uint32_t ret = imagePackerImpl->PackToFile(*pixelMap, fd, packOption);
1191             return ret;
1192         }
1193         return ERR_IMAGE_INIT_ABNORMAL;
1194     }
1195 
FfiOHOSImagePackerImageSourcePackToFile(int64_t id,int64_t source,int fd,CPackingOption option)1196     uint32_t FfiOHOSImagePackerImageSourcePackToFile(int64_t id, int64_t source, int fd, CPackingOption option)
1197     {
1198         auto imagePackerImpl = FFIData::GetData<ImagePackerImpl>(id);
1199         if (!imagePackerImpl) {
1200             IMAGE_LOGE("Packing failed, invalid id of ImagePackerImpl");
1201             return ERR_IMAGE_INIT_ABNORMAL;
1202         }
1203 
1204         auto imageSourceImpl = FFIData::GetData<ImageSourceImpl>(source);
1205         if (imageSourceImpl != nullptr) {
1206             PackOption packOption = { .format = option.format, .quality = option.quality};
1207             auto imageSource = imageSourceImpl->nativeImgSrc;
1208             if (!imageSource) {
1209                 return ERR_IMAGE_INIT_ABNORMAL;
1210             }
1211 
1212             uint32_t ret = imagePackerImpl->PackToFile(*imageSource, fd, packOption);
1213             return ret;
1214         }
1215         return ERR_IMAGE_INIT_ABNORMAL;
1216     }
1217 
FfiOHOSGetPackOptionSize()1218     uint64_t FfiOHOSGetPackOptionSize()
1219     {
1220         return sizeof(PackOption);
1221     }
1222 
FFiOHOSImagePackerRelease(int64_t id)1223     void FFiOHOSImagePackerRelease(int64_t id)
1224     {
1225         IMAGE_LOGD("FFiOHOSImagePackerRelease start");
1226         auto instance = FFIData::GetData<ImagePackerImpl>(id);
1227         if (!instance) {
1228             return;
1229         }
1230         instance->Release();
1231         IMAGE_LOGD("FFiOHOSImagePackerRelease success");
1232     }
1233 
1234     //--------------------- ImageCreator ---------------------------------------------------------------------------
FFiOHOSImageCreatorConstructor(int32_t width,int32_t height,int32_t format,int32_t capacity)1235     int64_t FFiOHOSImageCreatorConstructor(int32_t width, int32_t height, int32_t format, int32_t capacity)
1236     {
1237         auto ret = FFIData::Create<ImageCreatorImpl>(width, height, format, capacity);
1238         if (!ret) {
1239             return INIT_FAILED;
1240         }
1241         return ret->GetID();
1242     }
1243 
FFiOHOSImageCreatorGetCapacity(int64_t id)1244     RetDataI32 FFiOHOSImageCreatorGetCapacity(int64_t id)
1245     {
1246         IMAGE_LOGD("FFiOHOSImageCreatorGetCapacity start");
1247         RetDataI32 ret = {.code = ERR_IMAGE_INIT_ABNORMAL, .data = 0};
1248         auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1249         if (!instance) {
1250             IMAGE_LOGE("FFiOHOSImageCreatorGetCapacity instance not exist %{public}" PRId64, id);
1251             return ret;
1252         }
1253 
1254         std::shared_ptr<ImageCreator> imageCreator = instance->GetImageCreator();
1255         if (!imageCreator) {
1256             IMAGE_LOGE("FFiOHOSImageCreatorGetCapacity imageCreator is nullptr.");
1257             return ret;
1258         }
1259 
1260         std::shared_ptr<ImageCreatorContext> context = imageCreator->iraContext_;
1261         if (!context) {
1262             IMAGE_LOGE("FFiOHOSImageCreatorGetCapacity context is nullptr.");
1263             return ret;
1264         }
1265 
1266         ret.data = context->GetCapicity();
1267         ret.code = SUCCESS_CODE;
1268         IMAGE_LOGD("FFiOHOSImageCreatorGetCapacity success");
1269         return ret;
1270     }
1271 
FFiOHOSImageCreatorGetformat(int64_t id)1272     RetDataI32 FFiOHOSImageCreatorGetformat(int64_t id)
1273     {
1274         IMAGE_LOGD("FFiOHOSImageCreatorGetformat start");
1275         RetDataI32 ret = {.code = ERR_IMAGE_INIT_ABNORMAL, .data = 0};
1276         auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1277         if (!instance) {
1278             IMAGE_LOGE("FFiOHOSImageCreatorGetformat instance not exist %{public}" PRId64, id);
1279             return ret;
1280         }
1281 
1282         std::shared_ptr<ImageCreator> imageCreator = instance->GetImageCreator();
1283         if (!imageCreator) {
1284             IMAGE_LOGE("FFiOHOSImageCreatorGetformat imageCreator is nullptr.");
1285             return ret;
1286         }
1287 
1288         std::shared_ptr<ImageCreatorContext> context = imageCreator->iraContext_;
1289         if (!context) {
1290             IMAGE_LOGE("FFiOHOSImageCreatorGetformat context is nullptr.");
1291             return ret;
1292         }
1293 
1294         ret.data = context->GetFormat();
1295         ret.code = SUCCESS_CODE;
1296         IMAGE_LOGD("FFiOHOSImageCreatorGetformat success");
1297         return ret;
1298     }
1299 
FFiOHOSImageCreatorDequeueImage(int64_t id,uint32_t * errCode)1300     int64_t FFiOHOSImageCreatorDequeueImage(int64_t id, uint32_t* errCode)
1301     {
1302         IMAGE_LOGD("FFiOHOSImageCreatorDequeueImage start");
1303         auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1304         if (!instance) {
1305             *errCode = ERR_IMAGE_INIT_ABNORMAL;
1306             return INIT_FAILED;
1307         }
1308 
1309         std::shared_ptr<ImageCreator> imageCreator = instance->GetImageCreator();
1310         if (!imageCreator) {
1311             *errCode = ERR_IMAGE_INIT_ABNORMAL;
1312             return INIT_FAILED;
1313         }
1314         std::shared_ptr<NativeImage> nativeImageRes = imageCreator->DequeueNativeImage();
1315         if (!nativeImageRes) {
1316             *errCode = ERR_IMAGE_INIT_ABNORMAL;
1317             return INIT_FAILED;
1318         }
1319         auto ret = FFIData::Create<ImageImpl>(nativeImageRes);
1320         if (!ret) {
1321             *errCode = ERR_IMAGE_INIT_ABNORMAL;
1322             return INIT_FAILED;
1323         }
1324         *errCode = SUCCESS_CODE;
1325         return ret->GetID();
1326     }
1327 
FFiOHOSImageCreatorQueueImage(int64_t id,int64_t imageId)1328     void FFiOHOSImageCreatorQueueImage(int64_t id, int64_t imageId)
1329     {
1330         IMAGE_LOGD("FFiOHOSImageCreatorQueueImage start");
1331         auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1332         if (!instance) {
1333             IMAGE_LOGE("[ImageCreator] instance not exist %{public}" PRId64, id);
1334             return;
1335         }
1336         auto imageInstance = FFIData::GetData<ImageImpl>(imageId);
1337         if (!imageInstance) {
1338             IMAGE_LOGE("[ImageCreator] imageInstance not exist %{public}" PRId64, imageId);
1339             return;
1340         }
1341         std::shared_ptr<ImageCreator> imageCreator = instance->GetImageCreator();
1342         if (!imageCreator) {
1343             IMAGE_LOGE("[ImageCreator] imageCreator can not be nullptr");
1344             return;
1345         }
1346         imageCreator->QueueNativeImage(imageInstance->GetNativeImage());
1347         IMAGE_LOGD("FFiOHOSImageCreatorQueueImage success");
1348     }
1349 
FFiOHOSImageCreatorRelease(int64_t id)1350     void FFiOHOSImageCreatorRelease(int64_t id)
1351     {
1352         IMAGE_LOGD("FFiOHOSImageCreatorRelease start");
1353         auto instance = FFIData::GetData<ImageCreatorImpl>(id);
1354         if (!instance) {
1355             IMAGE_LOGE("[ImageCreator] instance not exist %{public}" PRId64, id);
1356             return;
1357         }
1358         instance->Release();
1359         IMAGE_LOGD("FFiOHOSImageCreatorRelease success");
1360     }
1361 }
1362 }
1363 }