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 "cj_color_manager.h"
16 #include "image_ffi.h"
17 #include "image_log.h"
18 #include "js_native_api.h"
19 #include "js_native_api_types.h"
20 #include "media_errors.h"
21 #include "pixel_map_impl.h"
22 #include "pixel_map_napi.h"
23
24 using namespace OHOS::FFI;
25
26 namespace OHOS {
27 namespace Media {
28 extern "C" {
ParseCRegion(CRegion region)29 static Rect ParseCRegion(CRegion region)
30 {
31 Rect rt = {
32 .left = region.x,
33 .top = region.y,
34 .width = region.size.width,
35 .height = region.size.height,
36 };
37 return rt;
38 }
39
ParsePixelMapCInitializationOptions(CInitializationOptionsV2 opts)40 static InitializationOptions ParsePixelMapCInitializationOptions(CInitializationOptionsV2 opts)
41 {
42 InitializationOptions option;
43 option.alphaType = AlphaType(opts.alphaType);
44 option.editable = opts.editable;
45 option.srcPixelFormat = PixelFormat(opts.srcPixelFormat);
46 option.pixelFormat = PixelFormat(opts.pixelFormat);
47 option.scaleMode = ScaleMode(opts.scaleMode);
48 option.size.height = opts.height;
49 option.size.width = opts.width;
50 return option;
51 }
52
FfiOHOSCreatePixelMap(uint8_t * colors,uint32_t colorLength,CInitializationOptions opts)53 int64_t FfiOHOSCreatePixelMap(uint8_t* colors, uint32_t colorLength, CInitializationOptions opts)
54 {
55 IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMap start");
56 InitializationOptions option;
57 option.alphaType = AlphaType(opts.alphaType);
58 option.editable = opts.editable;
59 option.pixelFormat = PixelFormat(opts.pixelFormat);
60 option.scaleMode = ScaleMode(opts.scaleMode);
61 option.size.height = opts.height;
62 option.size.width = opts.width;
63 std::unique_ptr<PixelMap> ptr_ =
64 PixelMapImpl::CreatePixelMap(reinterpret_cast<uint32_t*>(colors), colorLength, option);
65 if (!ptr_) {
66 return INIT_FAILED;
67 }
68 auto native = FFIData::Create<PixelMapImpl>(move(ptr_));
69 if (!native) {
70 IMAGE_LOGE("[ImageSource] FfiOHOSCreatePixelMap failed");
71 return INIT_FAILED;
72 }
73 IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMap success");
74 return native->GetID();
75 }
76
FfiOHOSCreatePixelMapV2(uint8_t * colors,uint32_t colorLength,CInitializationOptionsV2 opts)77 int64_t FfiOHOSCreatePixelMapV2(uint8_t* colors, uint32_t colorLength, CInitializationOptionsV2 opts)
78 {
79 IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMapV2 start");
80 InitializationOptions option = ParsePixelMapCInitializationOptions(opts);
81 std::unique_ptr<PixelMap> ptr_ =
82 PixelMapImpl::CreatePixelMap(reinterpret_cast<uint32_t*>(colors), colorLength, option);
83 if (!ptr_) {
84 return INIT_FAILED;
85 }
86 auto native = FFIData::Create<PixelMapImpl>(move(ptr_));
87 if (!native) {
88 IMAGE_LOGE("[ImageSource] FfiOHOSCreatePixelMapV2 failed");
89 return INIT_FAILED;
90 }
91 IMAGE_LOGD("[PixelMap] FfiOHOSCreatePixelMapV2 success");
92 return native->GetID();
93 }
94
FfiImagePixelMapImplCreatePixelMap(CInitializationOptionsV2 opts)95 int64_t FfiImagePixelMapImplCreatePixelMap(CInitializationOptionsV2 opts)
96 {
97 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePixelMap start");
98 InitializationOptions option = ParsePixelMapCInitializationOptions(opts);
99 std::unique_ptr<PixelMap> ptr_ = PixelMapImpl::CreatePixelMap(option);
100 if (!ptr_) {
101 return INIT_FAILED;
102 }
103 auto native = FFIData::Create<PixelMapImpl>(move(ptr_));
104 if (!native) {
105 IMAGE_LOGE("[ImageSource] FfiImagePixelMapImplCreatePixelMap failed");
106 return INIT_FAILED;
107 }
108 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePixelMap success");
109 return native->GetID();
110 }
111
FfiOHOSPixelMapRelease(int64_t id)112 uint32_t FfiOHOSPixelMapRelease(int64_t id)
113 {
114 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapRelease start");
115 auto instance = FFIData::GetData<PixelMapImpl>(id);
116 if (!instance) {
117 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
118 return ERR_IMAGE_INIT_ABNORMAL;
119 }
120 std::shared_ptr<PixelMap> ptr_ = instance->GetRealPixelMap();
121 ptr_.reset();
122 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapRelease success");
123 return SUCCESS_CODE;
124 }
125
FfiOHOSCreateAlphaPixelMap(int64_t id,uint32_t * errCode)126 int64_t FfiOHOSCreateAlphaPixelMap(int64_t id, uint32_t* errCode)
127 {
128 IMAGE_LOGD("[PixelMap] FfiOHOSCreateAlphaPixelMap start");
129 auto instance = FFIData::GetData<PixelMapImpl>(id);
130 if (!instance) {
131 *errCode = ERR_IMAGE_INIT_ABNORMAL;
132 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
133 return 0;
134 }
135 std::shared_ptr<PixelMap> ptr_ = instance->GetRealPixelMap();
136 if (!ptr_) {
137 *errCode = ERR_IMAGE_INIT_ABNORMAL;
138 IMAGE_LOGE("[PixelMap] ptr is nullptr!");
139 return 0;
140 }
141 InitializationOptions opts;
142 opts.pixelFormat = PixelFormat::ALPHA_8;
143 auto tmpPixelMap = PixelMapImpl::CreateAlphaPixelMap(*ptr_, opts);
144 if (!tmpPixelMap) {
145 *errCode = ERR_IMAGE_INIT_ABNORMAL;
146 IMAGE_LOGE("[PixelMap] tmpPixelMap is nullptr!");
147 return 0;
148 }
149 auto native = FFIData::Create<PixelMapImpl>(move(tmpPixelMap));
150 if (!native) {
151 IMAGE_LOGE("[ImageSource] FfiOHOSCreateAlphaPixelMap failed");
152 *errCode = ERR_IMAGE_INIT_ABNORMAL;
153 return 0;
154 }
155 IMAGE_LOGD("[PixelMap] FfiOHOSCreateAlphaPixelMap success");
156 *errCode = SUCCESS_CODE;
157 return native->GetID();
158 }
159
FfiOHOSReadPixelsToBuffer(int64_t id,uint64_t bufferSize,uint8_t * dst)160 uint32_t FfiOHOSReadPixelsToBuffer(int64_t id, uint64_t bufferSize, uint8_t* dst)
161 {
162 IMAGE_LOGD("[PixelMap] FfiOHOSReadPixelsToBuffer start");
163 auto instance = FFIData::GetData<PixelMapImpl>(id);
164 if (!instance || !instance->GetRealPixelMap()) {
165 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
166 return ERR_IMAGE_INIT_ABNORMAL;
167 }
168 uint32_t ret = instance->ReadPixelsToBuffer(bufferSize, dst);
169 IMAGE_LOGD("[PixelMap] FfiOHOSReadPixelsToBuffer success");
170 return ret;
171 }
172
FfiOHOSWriteBufferToPixels(int64_t id,uint8_t * source,uint64_t bufferSize)173 uint32_t FfiOHOSWriteBufferToPixels(int64_t id, uint8_t* source, uint64_t bufferSize)
174 {
175 IMAGE_LOGD("[PixelMap] FfiOHOSWriteBufferToPixels start");
176 auto instance = FFIData::GetData<PixelMapImpl>(id);
177 if (!instance || !instance->GetRealPixelMap()) {
178 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
179 return ERR_IMAGE_INIT_ABNORMAL;
180 }
181 uint32_t ret = instance->WriteBufferToPixels(source, bufferSize);
182 IMAGE_LOGD("[PixelMap] FfiOHOSWriteBufferToPixels success");
183 return ret;
184 }
185
FfiOHOSGetDensity(int64_t id,uint32_t * errCode)186 int32_t FfiOHOSGetDensity(int64_t id, uint32_t* errCode)
187 {
188 IMAGE_LOGD("[PixelMap] FfiOHOSGetDensity start");
189 auto instance = FFIData::GetData<PixelMapImpl>(id);
190 if (!instance || !instance->GetRealPixelMap()) {
191 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
192 *errCode = ERR_IMAGE_INIT_ABNORMAL;
193 return 0;
194 }
195 int32_t ret = instance->GetDensity();
196 *errCode = SUCCESS_CODE;
197 IMAGE_LOGD("[PixelMap] FfiOHOSGetDensity success");
198 return ret;
199 }
200
FfiOHOSOpacity(int64_t id,float percent)201 uint32_t FfiOHOSOpacity(int64_t id, float percent)
202 {
203 IMAGE_LOGD("[PixelMap] FfiOHOSOpacity start");
204 auto instance = FFIData::GetData<PixelMapImpl>(id);
205 if (!instance || !instance->GetRealPixelMap()) {
206 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
207 return ERR_IMAGE_INIT_ABNORMAL;
208 }
209 uint32_t ret = instance->Opacity(percent);
210 IMAGE_LOGD("[PixelMap] FfiOHOSOpacity success");
211 return ret;
212 }
213
FfiOHOSCrop(int64_t id,CRegion rect)214 uint32_t FfiOHOSCrop(int64_t id, CRegion rect)
215 {
216 IMAGE_LOGD("[PixelMap] FfiOHOSCrop start");
217 auto instance = FFIData::GetData<PixelMapImpl>(id);
218 if (!instance || !instance->GetRealPixelMap()) {
219 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
220 return ERR_IMAGE_INIT_ABNORMAL;
221 }
222 Rect rt = ParseCRegion(rect);
223 uint32_t ret = instance->Crop(rt);
224 IMAGE_LOGD("[PixelMap] FfiOHOSCrop success");
225 return ret;
226 }
227
FfiOHOSGetPixelBytesNumber(int64_t id,uint32_t * errCode)228 uint32_t FfiOHOSGetPixelBytesNumber(int64_t id, uint32_t* errCode)
229 {
230 IMAGE_LOGD("[PixelMap] FfiOHOSGetPixelBytesNumber start");
231 auto instance = FFIData::GetData<PixelMapImpl>(id);
232 if (!instance || !instance->GetRealPixelMap()) {
233 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
234 *errCode = ERR_IMAGE_INIT_ABNORMAL;
235 return 0;
236 }
237 uint32_t ret = instance->GetPixelBytesNumber();
238 *errCode = SUCCESS_CODE;
239 IMAGE_LOGD("[PixelMap] FfiOHOSGetPixelBytesNumber success");
240 return ret;
241 }
242
FfiOHOSGetBytesNumberPerRow(int64_t id,uint32_t * errCode)243 uint32_t FfiOHOSGetBytesNumberPerRow(int64_t id, uint32_t* errCode)
244 {
245 IMAGE_LOGD("[PixelMap] FfiOHOSGetBytesNumberPerRow start");
246 auto instance = FFIData::GetData<PixelMapImpl>(id);
247 if (!instance || !instance->GetRealPixelMap()) {
248 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
249 *errCode = ERR_IMAGE_INIT_ABNORMAL;
250 return 0;
251 }
252 uint32_t ret = instance->GetBytesNumberPerRow();
253 *errCode = SUCCESS_CODE;
254 IMAGE_LOGD("[PixelMap] FfiOHOSGetBytesNumberPerRow success");
255 return ret;
256 }
257
FfiOHOSGetImageInfo(int64_t id,uint32_t * errCode)258 CImageInfo FfiOHOSGetImageInfo(int64_t id, uint32_t* errCode)
259 {
260 IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfo start");
261 CImageInfo ret = {};
262 auto instance = FFIData::GetData<PixelMapImpl>(id);
263 if (!instance || !instance->GetRealPixelMap()) {
264 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
265 *errCode = ERR_IMAGE_INIT_ABNORMAL;
266 return ret;
267 }
268 ImageInfo info;
269 instance->GetImageInfo(info);
270 ret.height = info.size.height;
271 ret.width = info.size.width;
272 ret.density = info.baseDensity;
273 IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfo success");
274 return ret;
275 }
276
ParsePixelMapImageInfo(ImageInfo info,PixelMap * pixelMap)277 static CImageInfoV2 ParsePixelMapImageInfo(ImageInfo info, PixelMap* pixelMap)
278 {
279 CImageInfoV2 ret = {};
280 ret.height = info.size.height;
281 ret.width = info.size.width;
282 ret.density = info.baseDensity;
283 ret.pixelFormat = static_cast<int32_t>(info.pixelFormat);
284 ret.alphaType = static_cast<int32_t>(info.alphaType);
285 ret.stride = static_cast<int32_t>(pixelMap->GetRowStride());
286 ret.mimeType = Utils::MallocCString(info.encodedFormat);
287 ret.isHdr = pixelMap->IsHdr();
288 return ret;
289 }
290
FfiOHOSGetImageInfoV2(int64_t id,uint32_t * errCode)291 CImageInfoV2 FfiOHOSGetImageInfoV2(int64_t id, uint32_t* errCode)
292 {
293 IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfoV2 start");
294 CImageInfoV2 ret = {};
295 auto instance = FFIData::GetData<PixelMapImpl>(id);
296 if (!instance || !instance->GetRealPixelMap()) {
297 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
298 *errCode = ERR_IMAGE_INIT_ABNORMAL;
299 return ret;
300 }
301 ImageInfo info;
302 instance->GetImageInfo(info);
303 ret = ParsePixelMapImageInfo(info, instance->GetRealPixelMap().get());
304 IMAGE_LOGD("[PixelMap] FfiOHOSGetImageInfoV2 success");
305 return ret;
306 }
307
FfiOHOSScale(int64_t id,float xAxis,float yAxis)308 uint32_t FfiOHOSScale(int64_t id, float xAxis, float yAxis)
309 {
310 IMAGE_LOGD("[PixelMap] FfiOHOSScale start");
311 auto instance = FFIData::GetData<PixelMapImpl>(id);
312 if (!instance || !instance->GetRealPixelMap()) {
313 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
314 return ERR_IMAGE_INIT_ABNORMAL;
315 }
316 instance->Scale(xAxis, yAxis);
317 IMAGE_LOGD("[PixelMap] FfiOHOSScale success");
318 return SUCCESS_CODE;
319 }
320
ParseAntiAliasingOption(int32_t val)321 static AntiAliasingOption ParseAntiAliasingOption(int32_t val)
322 {
323 if (val <= static_cast<int32_t>(AntiAliasingOption::SPLINE)) {
324 return AntiAliasingOption(val);
325 }
326 return AntiAliasingOption::NONE;
327 }
328
FfiImagePixelMapImplScale(int64_t id,float xAxis,float yAxis,int32_t antiAliasing)329 uint32_t FfiImagePixelMapImplScale(int64_t id, float xAxis, float yAxis, int32_t antiAliasing)
330 {
331 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplScale start");
332 auto instance = FFIData::GetData<PixelMapImpl>(id);
333 if (!instance || !instance->GetRealPixelMap()) {
334 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
335 return ERR_IMAGE_INIT_ABNORMAL;
336 }
337 instance->Scale(xAxis, yAxis, ParseAntiAliasingOption(antiAliasing));
338 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplScale success");
339 return SUCCESS_CODE;
340 }
341
FfiOHOSFlip(int64_t id,bool xAxis,bool yAxis)342 uint32_t FfiOHOSFlip(int64_t id, bool xAxis, bool yAxis)
343 {
344 IMAGE_LOGD("[PixelMap] FfiOHOSFlip start");
345 auto instance = FFIData::GetData<PixelMapImpl>(id);
346 if (!instance || !instance->GetRealPixelMap()) {
347 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
348 return ERR_IMAGE_INIT_ABNORMAL;
349 }
350 instance->Flip(xAxis, yAxis);
351 IMAGE_LOGD("[PixelMap] FfiOHOSFlip success");
352 return SUCCESS_CODE;
353 }
354
FfiOHOSRotate(int64_t id,float degrees)355 uint32_t FfiOHOSRotate(int64_t id, float degrees)
356 {
357 IMAGE_LOGD("[PixelMap] FfiOHOSRotate start");
358 auto instance = FFIData::GetData<PixelMapImpl>(id);
359 if (!instance || !instance->GetRealPixelMap()) {
360 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
361 return ERR_IMAGE_INIT_ABNORMAL;
362 }
363 instance->Rotate(degrees);
364 IMAGE_LOGD("[PixelMap] FfiOHOSRotate success");
365 return SUCCESS_CODE;
366 }
367
FfiOHOSTranslate(int64_t id,float xAxis,float yAxis)368 uint32_t FfiOHOSTranslate(int64_t id, float xAxis, float yAxis)
369 {
370 IMAGE_LOGD("[PixelMap] FfiOHOSTranslate start");
371 auto instance = FFIData::GetData<PixelMapImpl>(id);
372 if (!instance || !instance->GetRealPixelMap()) {
373 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
374 return ERR_IMAGE_INIT_ABNORMAL;
375 }
376 instance->Translate(xAxis, yAxis);
377 IMAGE_LOGD("[PixelMap] FfiOHOSTranslate success");
378 return SUCCESS_CODE;
379 }
380
FfiOHOSReadPixels(int64_t id,CPositionArea area)381 uint32_t FfiOHOSReadPixels(int64_t id, CPositionArea area)
382 {
383 IMAGE_LOGD("[PixelMap] FfiOHOSReadPixels start");
384 auto instance = FFIData::GetData<PixelMapImpl>(id);
385 if (!instance || !instance->GetRealPixelMap()) {
386 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
387 return ERR_IMAGE_INIT_ABNORMAL;
388 }
389 Rect rt = ParseCRegion(area.region);
390 uint32_t ret = instance->ReadPixels(area.bufferSize, area.offset, area.stride, rt, area.dst);
391 IMAGE_LOGD("[PixelMap] FfiOHOSReadPixels success");
392 return ret;
393 }
394
FfiOHOSWritePixels(int64_t id,CPositionArea area)395 uint32_t FfiOHOSWritePixels(int64_t id, CPositionArea area)
396 {
397 IMAGE_LOGD("[PixelMap] FfiOHOSWritePixels start");
398 auto instance = FFIData::GetData<PixelMapImpl>(id);
399 if (!instance || !instance->GetRealPixelMap()) {
400 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
401 return ERR_IMAGE_INIT_ABNORMAL;
402 }
403 Rect rt = ParseCRegion(area.region);
404 uint32_t ret = instance->WritePixels(area.dst, area.bufferSize, area.offset, area.stride, rt);
405 IMAGE_LOGD("[PixelMap] FfiOHOSWritePixels success");
406 return ret;
407 }
408
FfiOHOSGetIsEditable(int64_t id,uint32_t * errCode)409 bool FfiOHOSGetIsEditable(int64_t id, uint32_t* errCode)
410 {
411 IMAGE_LOGD("[PixelMap] FfiOHOSGetIsEditable start");
412 auto instance = FFIData::GetData<PixelMapImpl>(id);
413 bool ret = false;
414 if (!instance || !instance->GetRealPixelMap()) {
415 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
416 *errCode = ERR_IMAGE_INIT_ABNORMAL;
417 return ret;
418 }
419 ret = instance->GetIsEditable();
420 *errCode = SUCCESS_CODE;
421 IMAGE_LOGD("[PixelMap] FfiOHOSGetIsEditable success");
422 return ret;
423 }
424
FfiOHOSGetIsStrideAlignment(int64_t id,uint32_t * errCode)425 bool FfiOHOSGetIsStrideAlignment(int64_t id, uint32_t* errCode)
426 {
427 IMAGE_LOGD("[PixelMap] FfiOHOSGetIsStrideAlignment start");
428 auto instance = FFIData::GetData<PixelMapImpl>(id);
429 bool ret = false;
430 if (!instance || !instance->GetRealPixelMap()) {
431 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
432 *errCode = ERR_IMAGE_INIT_ABNORMAL;
433 return ret;
434 }
435 ret = instance->GetIsStrideAlignment();
436 *errCode = SUCCESS_CODE;
437 IMAGE_LOGD("[PixelMap] FfiOHOSGetIsStrideAlignment success");
438 return ret;
439 }
440
FfiOHOSPixelMapSetColorSpace(int64_t id,int64_t colorSpaceId)441 uint32_t FfiOHOSPixelMapSetColorSpace(int64_t id, int64_t colorSpaceId)
442 {
443 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapSetColorSpace start");
444 auto instance = FFIData::GetData<PixelMapImpl>(id);
445 if (!instance || !instance->GetRealPixelMap()) {
446 IMAGE_LOGE("[PixelMap] PixelMapImpl instance not exist %{public}" PRId64, id);
447 return ERR_IMAGE_INIT_ABNORMAL;
448 }
449 auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(colorSpaceId);
450 if (!colorSpace) {
451 IMAGE_LOGE("[PixelMap] CjColorManager instance not exist %{public}" PRId64, colorSpaceId);
452 return ERR_IMAGE_INVALID_PARAMETER;
453 }
454 uint32_t ret = instance->SetColorSpace(colorSpace->GetColorSpaceToken());
455 IMAGE_LOGD("[PixelMap] FFfiOHOSPixelMapSetColorSpace success");
456 return ret;
457 }
458
FfiOHOSPixelMapGetColorSpace(int64_t id,int32_t * errCode)459 int64_t FfiOHOSPixelMapGetColorSpace(int64_t id, int32_t* errCode)
460 {
461 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapGetColorSpace start");
462 auto instance = FFIData::GetData<PixelMapImpl>(id);
463 if (!instance || !instance->GetRealPixelMap()) {
464 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
465 *errCode = ERR_IMAGE_DATA_ABNORMAL;
466 return 0;
467 }
468 auto colorSpace = instance->GetColorSpace();
469 if (!colorSpace) {
470 *errCode = ERR_IMAGE_DATA_UNSUPPORT;
471 return 0;
472 }
473 auto native = FFIData::Create<ColorManager::CjColorManager>(colorSpace);
474 if (!native) {
475 *errCode = ERR_IMAGE_INIT_ABNORMAL;
476 return 0;
477 }
478
479 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapGetColorSpace success");
480 *errCode = SUCCESS_CODE;
481 return native->GetID();
482 }
483
FfiOHOSPixelMapApplyColorSpace(int64_t id,int64_t colorSpaceId)484 uint32_t FfiOHOSPixelMapApplyColorSpace(int64_t id, int64_t colorSpaceId)
485 {
486 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapApplyColorSpace start");
487 auto instance = FFIData::GetData<PixelMapImpl>(id);
488 if (!instance || !instance->GetRealPixelMap()) {
489 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
490 return ERR_IMAGE_INIT_ABNORMAL;
491 }
492 auto colorSpace = FFIData::GetData<ColorManager::CjColorManager>(colorSpaceId);
493 if (!colorSpace) {
494 IMAGE_LOGE("[PixelMap] CjColorManager instance not exist %{public}" PRId64, colorSpaceId);
495 return ERR_IMAGE_INIT_ABNORMAL;
496 }
497 uint32_t ret = instance->ApplyColorSpace(colorSpace->GetColorSpaceToken());
498 IMAGE_LOGD("[PixelMap] FfiOHOSPixelMapApplyColorSpace success");
499 return ret;
500 }
501
FfiImagePixelMapImplCreatePremultipliedPixelMap(int64_t srcId,int64_t dstId)502 uint32_t FfiImagePixelMapImplCreatePremultipliedPixelMap(int64_t srcId, int64_t dstId)
503 {
504 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePremultipliedPixelMap start");
505 auto src = FFIData::GetData<PixelMapImpl>(srcId);
506 auto dst = FFIData::GetData<PixelMapImpl>(dstId);
507 if (!src || !dst) {
508 return ERR_IMAGE_GET_DATA_ABNORMAL;
509 }
510 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePremultipliedPixelMap success");
511 return PixelMapImpl::CreatePremultipliedPixelMap(src->GetRealPixelMap(), dst->GetRealPixelMap());
512 }
513
FfiImagePixelMapImplCreateUnpremultipliedPixelMap(int64_t srcId,int64_t dstId)514 uint32_t FfiImagePixelMapImplCreateUnpremultipliedPixelMap(int64_t srcId, int64_t dstId)
515 {
516 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreateUnpremultipliedPixelMap start");
517 auto src = FFIData::GetData<PixelMapImpl>(srcId);
518 auto dst = FFIData::GetData<PixelMapImpl>(dstId);
519 if (!src || !dst) {
520 return ERR_IMAGE_GET_DATA_ABNORMAL;
521 }
522 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreateUnpremultipliedPixelMap success");
523 return PixelMapImpl::CreateUnpremultipliedPixelMap(src->GetRealPixelMap(), dst->GetRealPixelMap());
524 }
525
FfiImagePixelMapImplSetTransferDetached(int64_t id,bool detached)526 uint32_t FfiImagePixelMapImplSetTransferDetached(int64_t id, bool detached)
527 {
528 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplSetTransferDetached start");
529 auto instance = FFIData::GetData<PixelMapImpl>(id);
530 if (!instance) {
531 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
532 return ERR_IMAGE_INIT_ABNORMAL;
533 }
534 instance->SetTransferDetach(detached);
535 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplSetTransferDetached success");
536 return SUCCESS;
537 }
538
FfiImagePixelMapImplToSdr(int64_t id)539 uint32_t FfiImagePixelMapImplToSdr(int64_t id)
540 {
541 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplToSdr start");
542 auto instance = FFIData::GetData<PixelMapImpl>(id);
543 if (!instance) {
544 IMAGE_LOGE("[PixelMap] instance not exist %{public}" PRId64, id);
545 return ERR_IMAGE_INIT_ABNORMAL;
546 }
547 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplToSdr success");
548 return instance->ToSdr();
549 }
550
FfiImagePixelMapImplMarshalling(int64_t id,int64_t rpcId)551 uint32_t FfiImagePixelMapImplMarshalling(int64_t id, int64_t rpcId)
552 {
553 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplMarshalling in");
554 auto pixelMap = FFIData::GetData<PixelMapImpl>(id);
555 if (!pixelMap) {
556 IMAGE_LOGE("[PixelMap] pixelMap not exist %{public}" PRId64, id);
557 return ERR_IMAGE_INVALID_PARAMETER;
558 }
559 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplMarshalling out");
560 return pixelMap->Marshalling(rpcId);
561 }
562
FfiImagePixelMapImplUnmarshalling(int64_t id,int64_t rpcId,uint32_t * errCode)563 int64_t FfiImagePixelMapImplUnmarshalling(int64_t id, int64_t rpcId, uint32_t* errCode)
564 {
565 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplUnmarshalling in");
566 auto pixelMap = FFIData::GetData<PixelMapImpl>(id);
567 if (!pixelMap) {
568 IMAGE_LOGE("[PixelMap] pixelMap not exist %{public}" PRId64, id);
569 *errCode = ERR_IMAGE_INVALID_PARAMETER;
570 return 0;
571 }
572 auto retPixelMap = pixelMap->Unmarshalling(rpcId, errCode);
573 if (!retPixelMap) {
574 IMAGE_LOGE("[PixelMap] retPixelMap is nullptr!");
575 return 0;
576 }
577 auto native = FFIData::Create<PixelMapImpl>(move(retPixelMap));
578 if (!native) {
579 IMAGE_LOGE("[PixelMap] native is nullptr!");
580 *errCode = ERR_IMAGE_NAPI_ERROR;
581 return 0;
582 }
583 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplUnmarshalling out");
584 return native->GetID();
585 }
586
FfiImagePixelMapImplConvertPixelMapFormat(int64_t id,int32_t targetFormat)587 uint32_t FfiImagePixelMapImplConvertPixelMapFormat(int64_t id, int32_t targetFormat)
588 {
589 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplConvertPixelMapFormat in");
590 auto pixelMap = FFIData::GetData<PixelMapImpl>(id);
591 if (!pixelMap) {
592 IMAGE_LOGE("[PixelMap] pixelMap not exist %{public}" PRId64, id);
593 return ERR_IMAGE_INVALID_PARAMETER;
594 }
595 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplConvertPixelMapFormat out");
596 return pixelMap->ConvertPixelMapFormat(PixelFormat(targetFormat));
597 }
598
FfiImagePixelMapImplCreatePixelMapFromSurface(char * surfaceId,CRegion rect,size_t argc,uint32_t * errCode)599 int64_t FfiImagePixelMapImplCreatePixelMapFromSurface(char* surfaceId, CRegion rect, size_t argc, uint32_t* errCode)
600 {
601 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePixelMapFromSurface in");
602 Rect rt = ParseCRegion(rect);
603 auto pixelMap = PixelMapImpl::CreatePixelMapFromSurface(surfaceId, rt, argc, errCode);
604 if (!pixelMap) {
605 IMAGE_LOGE("[PixelMap] pixelMap is nullptr!");
606 return 0;
607 }
608 auto native = FFIData::Create<PixelMapImpl>(move(pixelMap));
609 if (!native) {
610 IMAGE_LOGE("[PixelMap] native is nullptr!");
611 *errCode = ERR_IMAGE_PIXELMAP_CREATE_FAILED;
612 return 0;
613 }
614 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePixelMapFromSurface out");
615 return native->GetID();
616 }
617
FfiImagePixelMapImplCreatePixelMapFromParcel(int64_t rpcId,uint32_t * errCode)618 int64_t FfiImagePixelMapImplCreatePixelMapFromParcel(int64_t rpcId, uint32_t* errCode)
619 {
620 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePixelMapFromParcel in");
621 auto pixelMap = PixelMapImpl::CreatePixelMapFromParcel(rpcId, errCode);
622 if (!pixelMap) {
623 IMAGE_LOGE("[PixelMap] pixelMap is nullptr!");
624 return 0;
625 }
626 auto native = FFIData::Create<PixelMapImpl>(move(pixelMap));
627 if (!native) {
628 IMAGE_LOGE("[PixelMap] native is nullptr!");
629 *errCode = ERR_IMAGE_NAPI_ERROR;
630 return 0;
631 }
632 IMAGE_LOGD("[PixelMap] FfiImagePixelMapImplCreatePixelMapFromParcel out");
633 return native->GetID();
634 }
635
FfiConvertPixelMap2Napi(napi_env env,uint64_t id)636 napi_value FfiConvertPixelMap2Napi(napi_env env, uint64_t id)
637 {
638 napi_value undefined = nullptr;
639 napi_get_undefined(env, &undefined);
640 auto instance = FFIData::GetData<PixelMapImpl>(id);
641 if (instance == nullptr || instance->GetRealPixelMap() == nullptr) {
642 IMAGE_LOGE("[PixelMap]: instance not exist %{public}" PRId64, id);
643 return undefined;
644 }
645
646 napi_value result = PixelMapNapi::CreatePixelMap(env, instance->GetRealPixelMap());
647 napi_valuetype type = napi_undefined;
648 if (napi_typeof(env, result, &type) != napi_ok || type == napi_undefined) {
649 IMAGE_LOGE("[PixelMap]: create napiobj failed.");
650 return undefined;
651 }
652 PixelMapNapi* pixelMapNapi = nullptr;
653 napi_status status = napi_unwrap(env, result, reinterpret_cast<void**>(&pixelMapNapi));
654 if (status != napi_ok || pixelMapNapi == nullptr) {
655 IMAGE_LOGE("[PixelMap]: unwrap failed");
656 return undefined;
657 }
658 pixelMapNapi->setPixelNapiEditable(instance->GetPixelMapImplEditable());
659 pixelMapNapi->SetTransferDetach(instance->GetTransferDetach());
660 return result;
661 }
662
FfiCreatePixelMapFromNapi(napi_env env,napi_value pixelmap)663 int64_t FfiCreatePixelMapFromNapi(napi_env env, napi_value pixelmap)
664 {
665 if (env == nullptr || pixelmap == nullptr) {
666 IMAGE_LOGE("[PixelMap]: parameter nullptr!");
667 return ERR_IMAGE_INIT_ABNORMAL;
668 }
669
670 napi_valuetype type = napi_undefined;
671 if (napi_typeof(env, pixelmap, &type) != napi_ok || type != napi_object) {
672 IMAGE_LOGE("[PixelMap]: parameter napi value type is not object!");
673 return ERR_IMAGE_INIT_ABNORMAL;
674 }
675
676 PixelMapNapi* obj = nullptr;
677 napi_status status = napi_unwrap(env, pixelmap, reinterpret_cast<void**>(&obj));
678 if (status != napi_ok || obj == nullptr) {
679 IMAGE_LOGE("[PixelMap]: unwrap failed");
680 return ERR_IMAGE_INIT_ABNORMAL;
681 }
682
683 std::shared_ptr<PixelMap>* nativeObj = obj->GetPixelMap();
684 if (nativeObj == nullptr) {
685 IMAGE_LOGE("[PixelMap]: native pixelmap has released.");
686 return ERR_IMAGE_INIT_ABNORMAL;
687 }
688
689 auto native = FFIData::Create<PixelMapImpl>(*nativeObj, obj->GetPixelNapiEditable(), obj->GetTransferDetach());
690 if (native == nullptr) {
691 IMAGE_LOGE("[PixelMap]: Create ffidata failed.");
692 return ERR_IMAGE_INIT_ABNORMAL;
693 }
694
695 return native->GetID();
696 }
697 }
698 } // namespace Media
699 } // namespace OHOS