1 /*
2  * Copyright (C) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "pixelmap_native.h"
17 
18 #include "common_utils.h"
19 #include "image_type.h"
20 #include "image_pixel_map_napi_kits.h"
21 #include "pixel_map_napi.h"
22 #include "pixelmap_native_impl.h"
23 #include "image_format_convert.h"
24 #include "surface_buffer.h"
25 
26 #include "vpe_utils.h"
27 #include "refbase.h"
28 #include "securec.h"
29 #include "color_utils.h"
30 #include "media_errors.h"
31 #include "image_log.h"
32 
33 #include "native_color_space_manager.h"
34 #include "ndk_color_space.h"
35 
36 using namespace OHOS::Media;
37 #ifdef __cplusplus
38 extern "C" {
39 #endif
40 
41 constexpr int32_t IMAGE_BASE = 62980096;
42 static constexpr int32_t IMAGE_BASE_19 = 19;
43 static constexpr int32_t IMAGE_BASE_16 = 16;
44 static constexpr int32_t IMAGE_BASE_17 = 17;
45 static constexpr int32_t IMAGE_BASE_26 = 26;
46 static constexpr int32_t IMAGE_BASE_31 = 31;
47 static constexpr int32_t IMAGE_BASE_152 = 152;
48 static constexpr int32_t IMAGE_BASE_27 = 27;
49 static constexpr int32_t IMAGE_BASE_12 = 12;
50 static constexpr int32_t IMAGE_BASE_13 = 13;
51 static constexpr int32_t IMAGE_BASE_6 = 6;
52 static constexpr int32_t IMAGE_BASE_14 = 14;
53 static constexpr int32_t IMAGE_BASE_4 = 4;
54 static constexpr int32_t IMAGE_BASE_9 = 9;
55 static constexpr int32_t IMAGE_BASE_20 = 20;
56 static constexpr int32_t IMAGE_BASE_22 = 22;
57 static constexpr int32_t IMAGE_BASE_23 = 23;
58 
59 struct OH_Pixelmap_InitializationOptions {
60     uint32_t width;
61     uint32_t height;
62     PIXEL_FORMAT srcPixelFormat = PIXEL_FORMAT::PIXEL_FORMAT_BGRA_8888;
63     PIXEL_FORMAT pixelFormat = PIXEL_FORMAT::PIXEL_FORMAT_UNKNOWN;
64     uint32_t editable = false;
65     PIXELMAP_ALPHA_TYPE alphaType = PIXELMAP_ALPHA_TYPE::PIXELMAP_ALPHA_TYPE_UNKNOWN;
66     int32_t srcRowStride = 0;
67 };
68 
69 struct OH_Pixelmap_ImageInfo {
70     uint32_t width;
71     uint32_t height;
72     uint32_t rowStride;
73     int32_t pixelFormat = PIXEL_FORMAT::PIXEL_FORMAT_UNKNOWN;
74     PIXELMAP_ALPHA_TYPE alphaType = PIXELMAP_ALPHA_TYPE::PIXELMAP_ALPHA_TYPE_UNKNOWN;
75     bool isHdr = false;
76 };
77 
ParsePixelForamt(int32_t val)78 static PIXEL_FORMAT ParsePixelForamt(int32_t val)
79 {
80     if (val <= static_cast<int32_t>(PIXEL_FORMAT::PIXEL_FORMAT_NV12)) {
81         return PIXEL_FORMAT(val);
82     }
83 
84     return PIXEL_FORMAT::PIXEL_FORMAT_UNKNOWN;
85 }
86 
ParseAlphaType(int32_t val)87 static PIXELMAP_ALPHA_TYPE ParseAlphaType(int32_t val)
88 {
89     if (val <= static_cast<int32_t>(PIXELMAP_ALPHA_TYPE::PIXELMAP_ALPHA_TYPE_UNPREMULTIPLIED)) {
90         return PIXELMAP_ALPHA_TYPE(val);
91     }
92 
93     return PIXELMAP_ALPHA_TYPE::PIXELMAP_ALPHA_TYPE_UNKNOWN;
94 }
95 
ToNewErrorCode(int code)96 static Image_ErrorCode ToNewErrorCode(int code)
97 {
98     switch (code) {
99         case 0:
100             return IMAGE_SUCCESS;
101         case IMAGE_BASE + IMAGE_BASE_19:
102             return IMAGE_BAD_PARAMETER;
103         case IMAGE_BASE + IMAGE_BASE_16:
104         case IMAGE_BASE + IMAGE_BASE_17:
105         case IMAGE_BASE + IMAGE_BASE_26:
106             return IMAGE_UNKNOWN_MIME_TYPE;
107         case IMAGE_BASE + IMAGE_BASE_31:
108             return IMAGE_TOO_LARGE;
109         case IMAGE_BASE + IMAGE_BASE_152:
110             return IMAGE_UNSUPPORTED_OPERATION;
111         case IMAGE_BASE + IMAGE_BASE_27:
112             return IMAGE_UNSUPPORTED_METADATA;
113         case IMAGE_BASE + IMAGE_BASE_12:
114             return IMAGE_UNSUPPORTED_CONVERSION;
115         case IMAGE_BASE + IMAGE_BASE_13:
116             return IMAGE_INVALID_REGION;
117         case IMAGE_BASE + IMAGE_BASE_6:
118             return IMAGE_ALLOC_FAILED;
119         case IMAGE_BASE + IMAGE_BASE_14:
120             return IMAGE_BAD_SOURCE;
121         case IMAGE_BASE + IMAGE_BASE_4:
122         case IMAGE_BASE + IMAGE_BASE_9:
123         case IMAGE_BASE + IMAGE_BASE_20:
124         case IMAGE_BASE + IMAGE_BASE_22:
125             return IMAGE_DECODE_FAILED;
126         case IMAGE_BASE + IMAGE_BASE_23:
127             return IMAGE_ENCODE_FAILED;
128         default:
129             return IMAGE_UNKNOWN_ERROR;
130     }
131 };
132 
IsMatchType(IMAGE_FORMAT type,PixelFormat format)133 static bool IsMatchType(IMAGE_FORMAT type, PixelFormat format)
134 {
135     if (type == IMAGE_FORMAT::IMAGE_FORMAT_YUV_TYPE) {
136         switch (format) {
137             case PixelFormat::NV12:
138             case PixelFormat::NV21:{
139                 return true;
140             }
141             default:{
142                 return false;
143             }
144         }
145     } else if (type == IMAGE_FORMAT::IMAGE_FORMAT_RGB_TYPE) {
146         switch (format) {
147             case PixelFormat::RGB_565:
148             case PixelFormat::RGBA_8888:
149             case PixelFormat::BGRA_8888:
150             case PixelFormat::RGB_888:
151             case PixelFormat::RGBA_F16:{
152                 return true;
153             }
154             default:{
155                 return false;
156             }
157         }
158     } else {
159         return false;
160     }
161 }
162 
163 MIDK_EXPORT
OH_PixelmapInitializationOptions_Create(OH_Pixelmap_InitializationOptions ** ops)164 Image_ErrorCode OH_PixelmapInitializationOptions_Create(OH_Pixelmap_InitializationOptions **ops)
165 {
166     if (ops == nullptr) {
167         return IMAGE_BAD_PARAMETER;
168     }
169     *ops = new OH_Pixelmap_InitializationOptions();
170     if (*ops == nullptr) {
171         return IMAGE_BAD_PARAMETER;
172     }
173     return IMAGE_SUCCESS;
174 }
175 
176 MIDK_EXPORT
OH_PixelmapInitializationOptions_GetWidth(OH_Pixelmap_InitializationOptions * ops,uint32_t * width)177 Image_ErrorCode OH_PixelmapInitializationOptions_GetWidth(OH_Pixelmap_InitializationOptions *ops,
178     uint32_t *width)
179 {
180     if (ops == nullptr || width == nullptr) {
181         return IMAGE_BAD_PARAMETER;
182     }
183     *width = ops->width;
184     return IMAGE_SUCCESS;
185 }
186 
187 MIDK_EXPORT
OH_PixelmapInitializationOptions_SetWidth(OH_Pixelmap_InitializationOptions * ops,uint32_t width)188 Image_ErrorCode OH_PixelmapInitializationOptions_SetWidth(OH_Pixelmap_InitializationOptions *ops,
189     uint32_t width)
190 {
191     if (ops == nullptr) {
192         return IMAGE_BAD_PARAMETER;
193     }
194     ops->width = width;
195     return IMAGE_SUCCESS;
196 }
197 
198 MIDK_EXPORT
OH_PixelmapInitializationOptions_GetHeight(OH_Pixelmap_InitializationOptions * ops,uint32_t * height)199 Image_ErrorCode OH_PixelmapInitializationOptions_GetHeight(OH_Pixelmap_InitializationOptions *ops,
200     uint32_t *height)
201 {
202     if (ops == nullptr || height == nullptr) {
203         return IMAGE_BAD_PARAMETER;
204     }
205     *height = ops->height;
206     return IMAGE_SUCCESS;
207 }
208 
209 MIDK_EXPORT
OH_PixelmapInitializationOptions_SetHeight(OH_Pixelmap_InitializationOptions * ops,uint32_t height)210 Image_ErrorCode OH_PixelmapInitializationOptions_SetHeight(OH_Pixelmap_InitializationOptions *ops,
211     uint32_t height)
212 {
213     if (ops == nullptr) {
214         return IMAGE_BAD_PARAMETER;
215     }
216     ops->height = height;
217     return IMAGE_SUCCESS;
218 }
219 
220 MIDK_EXPORT
OH_PixelmapInitializationOptions_GetPixelFormat(OH_Pixelmap_InitializationOptions * ops,int32_t * pixelFormat)221 Image_ErrorCode OH_PixelmapInitializationOptions_GetPixelFormat(OH_Pixelmap_InitializationOptions *ops,
222     int32_t *pixelFormat)
223 {
224     if (ops == nullptr || pixelFormat == nullptr) {
225         return IMAGE_BAD_PARAMETER;
226     }
227     *pixelFormat = static_cast<int32_t>(ops->pixelFormat);
228     return IMAGE_SUCCESS;
229 }
230 
231 MIDK_EXPORT
OH_PixelmapInitializationOptions_SetPixelFormat(OH_Pixelmap_InitializationOptions * ops,int32_t pixelFormat)232 Image_ErrorCode OH_PixelmapInitializationOptions_SetPixelFormat(OH_Pixelmap_InitializationOptions *ops,
233     int32_t pixelFormat)
234 {
235     if (ops == nullptr) {
236         return IMAGE_BAD_PARAMETER;
237     }
238     ops->pixelFormat = ParsePixelForamt(pixelFormat);
239     return IMAGE_SUCCESS;
240 }
241 
242 MIDK_EXPORT
OH_PixelmapInitializationOptions_GetSrcPixelFormat(OH_Pixelmap_InitializationOptions * ops,int32_t * srcpixelFormat)243 Image_ErrorCode OH_PixelmapInitializationOptions_GetSrcPixelFormat(OH_Pixelmap_InitializationOptions *ops,
244     int32_t *srcpixelFormat)
245 {
246     if (ops == nullptr || srcpixelFormat == nullptr) {
247         return IMAGE_BAD_PARAMETER;
248     }
249     *srcpixelFormat = static_cast<int32_t>(ops->srcPixelFormat);
250     return IMAGE_SUCCESS;
251 }
252 
253 MIDK_EXPORT
OH_PixelmapInitializationOptions_SetSrcPixelFormat(OH_Pixelmap_InitializationOptions * ops,int32_t srcpixelFormat)254 Image_ErrorCode OH_PixelmapInitializationOptions_SetSrcPixelFormat(OH_Pixelmap_InitializationOptions *ops,
255     int32_t srcpixelFormat)
256 {
257     if (ops == nullptr) {
258         return IMAGE_BAD_PARAMETER;
259     }
260     ops->srcPixelFormat = ParsePixelForamt(srcpixelFormat);
261     return IMAGE_SUCCESS;
262 }
263 
264 MIDK_EXPORT
OH_PixelmapInitializationOptions_GetAlphaType(OH_Pixelmap_InitializationOptions * ops,int32_t * alphaType)265 Image_ErrorCode OH_PixelmapInitializationOptions_GetAlphaType(OH_Pixelmap_InitializationOptions *ops,
266     int32_t *alphaType)
267 {
268     if (ops == nullptr || alphaType == nullptr) {
269         return IMAGE_BAD_PARAMETER;
270     }
271     *alphaType = static_cast<int32_t>(ops->alphaType);
272     return IMAGE_SUCCESS;
273 }
274 
275 MIDK_EXPORT
OH_PixelmapInitializationOptions_SetAlphaType(OH_Pixelmap_InitializationOptions * ops,int32_t alphaType)276 Image_ErrorCode OH_PixelmapInitializationOptions_SetAlphaType(OH_Pixelmap_InitializationOptions *ops,
277     int32_t alphaType)
278 {
279     if (ops == nullptr) {
280         return IMAGE_BAD_PARAMETER;
281     }
282     ops->alphaType = ParseAlphaType(alphaType);
283     return IMAGE_SUCCESS;
284 }
285 
286 MIDK_EXPORT
OH_PixelmapInitializationOptions_GetRowStride(OH_Pixelmap_InitializationOptions * options,int32_t * rowStride)287 Image_ErrorCode OH_PixelmapInitializationOptions_GetRowStride(OH_Pixelmap_InitializationOptions *options,
288     int32_t *rowStride)
289 {
290     if (options == nullptr || rowStride == nullptr) {
291         return IMAGE_BAD_PARAMETER;
292     }
293     *rowStride = options->srcRowStride;
294     return IMAGE_SUCCESS;
295 }
296 
297 MIDK_EXPORT
OH_PixelmapInitializationOptions_SetRowStride(OH_Pixelmap_InitializationOptions * options,int32_t rowStride)298 Image_ErrorCode OH_PixelmapInitializationOptions_SetRowStride(OH_Pixelmap_InitializationOptions *options,
299     int32_t rowStride)
300 {
301     if (options == nullptr) {
302         return IMAGE_BAD_PARAMETER;
303     }
304     options->srcRowStride = rowStride;
305     return IMAGE_SUCCESS;
306 }
307 
308 MIDK_EXPORT
OH_PixelmapInitializationOptions_Release(OH_Pixelmap_InitializationOptions * ops)309 Image_ErrorCode OH_PixelmapInitializationOptions_Release(OH_Pixelmap_InitializationOptions *ops)
310 {
311     if (ops == nullptr) {
312         return IMAGE_BAD_PARAMETER;
313     }
314     delete ops;
315     return IMAGE_SUCCESS;
316 }
317 
318 MIDK_EXPORT
OH_PixelmapImageInfo_Create(OH_Pixelmap_ImageInfo ** info)319 Image_ErrorCode OH_PixelmapImageInfo_Create(OH_Pixelmap_ImageInfo **info)
320 {
321     if (info == nullptr) {
322         return IMAGE_BAD_PARAMETER;
323     }
324     *info = new OH_Pixelmap_ImageInfo();
325     if (*info == nullptr) {
326         return IMAGE_BAD_PARAMETER;
327     }
328     return IMAGE_SUCCESS;
329 }
330 
331 MIDK_EXPORT
OH_PixelmapImageInfo_GetWidth(OH_Pixelmap_ImageInfo * info,uint32_t * width)332 Image_ErrorCode OH_PixelmapImageInfo_GetWidth(OH_Pixelmap_ImageInfo *info, uint32_t *width)
333 {
334     if (info == nullptr || width == nullptr) {
335         return IMAGE_BAD_PARAMETER;
336     }
337     *width =  info->width;
338     return IMAGE_SUCCESS;
339 }
340 
341 MIDK_EXPORT
OH_PixelmapImageInfo_GetHeight(OH_Pixelmap_ImageInfo * info,uint32_t * height)342 Image_ErrorCode OH_PixelmapImageInfo_GetHeight(OH_Pixelmap_ImageInfo *info, uint32_t *height)
343 {
344     if (info == nullptr || height == nullptr) {
345         return IMAGE_BAD_PARAMETER;
346     }
347     *height =  info->height;
348     return IMAGE_SUCCESS;
349 }
350 
351 MIDK_EXPORT
OH_PixelmapImageInfo_GetRowStride(OH_Pixelmap_ImageInfo * info,uint32_t * rowStride)352 Image_ErrorCode OH_PixelmapImageInfo_GetRowStride(OH_Pixelmap_ImageInfo *info, uint32_t *rowStride)
353 {
354     if (info == nullptr || rowStride == nullptr) {
355         return IMAGE_BAD_PARAMETER;
356     }
357     *rowStride =  info->rowStride;
358     return IMAGE_SUCCESS;
359 }
360 
361 MIDK_EXPORT
OH_PixelmapImageInfo_GetPixelFormat(OH_Pixelmap_ImageInfo * info,int32_t * pixelFormat)362 Image_ErrorCode OH_PixelmapImageInfo_GetPixelFormat(OH_Pixelmap_ImageInfo *info, int32_t *pixelFormat)
363 {
364     if (info == nullptr || pixelFormat == nullptr) {
365         return IMAGE_BAD_PARAMETER;
366     }
367     *pixelFormat =  info->pixelFormat;
368     return IMAGE_SUCCESS;
369 }
370 
371 MIDK_EXPORT
OH_PixelmapImageInfo_GetAlphaType(OH_Pixelmap_ImageInfo * info,int32_t * alphaType)372 Image_ErrorCode OH_PixelmapImageInfo_GetAlphaType(OH_Pixelmap_ImageInfo *info, int32_t *alphaType)
373 {
374     if (info == nullptr || alphaType == nullptr) {
375         return IMAGE_BAD_PARAMETER;
376     }
377     *alphaType = static_cast<int32_t>(info->alphaType);
378     return IMAGE_SUCCESS;
379 }
380 
381 MIDK_EXPORT
OH_PixelmapImageInfo_GetDynamicRange(OH_Pixelmap_ImageInfo * info,bool * isHdr)382 Image_ErrorCode OH_PixelmapImageInfo_GetDynamicRange(OH_Pixelmap_ImageInfo *info, bool *isHdr)
383 {
384     if (info == nullptr || isHdr == nullptr) {
385         return IMAGE_BAD_PARAMETER;
386     }
387     *isHdr = info->isHdr;
388     return IMAGE_SUCCESS;
389 }
390 
391 MIDK_EXPORT
OH_PixelmapImageInfo_Release(OH_Pixelmap_ImageInfo * info)392 Image_ErrorCode OH_PixelmapImageInfo_Release(OH_Pixelmap_ImageInfo *info)
393 {
394     if (info == nullptr) {
395         return IMAGE_BAD_PARAMETER;
396     }
397     delete  info;
398     return IMAGE_SUCCESS;
399 }
400 
401 MIDK_EXPORT
OH_PixelmapNative_CreatePixelmap(uint8_t * data,size_t dataLength,OH_Pixelmap_InitializationOptions * options,OH_PixelmapNative ** pixelmap)402 Image_ErrorCode OH_PixelmapNative_CreatePixelmap(uint8_t *data, size_t dataLength,
403     OH_Pixelmap_InitializationOptions *options, OH_PixelmapNative **pixelmap)
404 {
405     if (data == nullptr || options == nullptr || pixelmap == nullptr) {
406         return IMAGE_BAD_PARAMETER;
407     }
408     InitializationOptions info;
409     info.editable = true;
410     info.alphaType = static_cast<AlphaType>(options->alphaType);
411     info.srcPixelFormat = static_cast<PixelFormat>(options->srcPixelFormat);
412     info.pixelFormat = static_cast<PixelFormat>(options->pixelFormat);
413     info.srcRowStride = options->srcRowStride;
414     info.size.height = static_cast<int32_t>(options->height);
415     info.size.width = static_cast<int32_t>(options->width);
416 
417     auto pixelmap2 = new OH_PixelmapNative(reinterpret_cast<uint32_t*>(data), static_cast<uint32_t>(dataLength), info);
418     if (pixelmap2 == nullptr || pixelmap2->GetInnerPixelmap() == nullptr) {
419         if (pixelmap2) {
420             delete pixelmap2;
421         }
422         return IMAGE_BAD_PARAMETER;
423     }
424     *pixelmap = pixelmap2;
425     return IMAGE_SUCCESS;
426 }
427 
428 MIDK_EXPORT
OH_PixelmapNative_CreateEmptyPixelmap(OH_Pixelmap_InitializationOptions * options,OH_PixelmapNative ** pixelmap)429 Image_ErrorCode OH_PixelmapNative_CreateEmptyPixelmap(
430     OH_Pixelmap_InitializationOptions *options, OH_PixelmapNative **pixelmap)
431 {
432     if (options == nullptr) {
433         return IMAGE_BAD_PARAMETER;
434     }
435     InitializationOptions info;
436     info.editable = true;
437     info.alphaType = static_cast<AlphaType>(options->alphaType);
438     info.srcPixelFormat = static_cast<PixelFormat>(options->srcPixelFormat);
439     info.pixelFormat = static_cast<PixelFormat>(options->pixelFormat);
440     info.size.height = options->height;
441     info.size.width = options->width;
442 
443     auto pixelmap2 = new OH_PixelmapNative(info);
444     if (pixelmap2 == nullptr || pixelmap2->GetInnerPixelmap() == nullptr) {
445         if (pixelmap2) {
446             delete pixelmap2;
447         }
448         return IMAGE_BAD_PARAMETER;
449     }
450     *pixelmap = pixelmap2;
451     return IMAGE_SUCCESS;
452 }
453 
454 MIDK_EXPORT
OH_PixelmapNative_ConvertPixelmapNativeToNapi(napi_env env,OH_PixelmapNative * pixelmapNative,napi_value * pixelmapNapi)455 Image_ErrorCode OH_PixelmapNative_ConvertPixelmapNativeToNapi(napi_env env, OH_PixelmapNative *pixelmapNative,
456     napi_value *pixelmapNapi)
457 {
458     if (pixelmapNative == nullptr || pixelmapNative->GetInnerPixelmap() == nullptr) {
459         return IMAGE_BAD_PARAMETER;
460     }
461     std::shared_ptr<OHOS::Media::PixelMap> pixelMap = pixelmapNative->GetInnerPixelmap();
462     *pixelmapNapi = PixelMapNapi::CreatePixelMap(env, pixelMap);
463     napi_valuetype valueType = napi_undefined;
464     napi_typeof(env, *pixelmapNapi, &valueType);
465     return (valueType == napi_undefined) ? IMAGE_BAD_PARAMETER : IMAGE_SUCCESS;
466 }
467 
468 MIDK_EXPORT
OH_PixelmapNative_ConvertPixelmapNativeFromNapi(napi_env env,napi_value pixelmapNapi,OH_PixelmapNative ** pixelmapNative)469 Image_ErrorCode OH_PixelmapNative_ConvertPixelmapNativeFromNapi(napi_env env, napi_value pixelmapNapi,
470     OH_PixelmapNative **pixelmapNative)
471 {
472     PixelMapNapi* napi = PixelMapNapi_Unwrap(env, pixelmapNapi);
473     if (napi == nullptr || napi->GetPixelNapiInner() == nullptr) {
474         return IMAGE_BAD_PARAMETER;
475     }
476     auto pixelmap = new OH_PixelmapNative(napi->GetPixelNapiInner());
477     if (pixelmap == nullptr || pixelmap->GetInnerPixelmap() == nullptr) {
478         if (pixelmap) {
479             delete pixelmap;
480         }
481         return IMAGE_ALLOC_FAILED;
482     }
483     *pixelmapNative = pixelmap;
484     return IMAGE_SUCCESS;
485 }
486 
487 MIDK_EXPORT
OH_PixelmapNative_ReadPixels(OH_PixelmapNative * pixelmap,uint8_t * destination,size_t * bufferSize)488 Image_ErrorCode OH_PixelmapNative_ReadPixels(OH_PixelmapNative *pixelmap, uint8_t *destination, size_t *bufferSize)
489 {
490     if (pixelmap == nullptr || destination == nullptr || bufferSize == nullptr || !pixelmap->GetInnerPixelmap()) {
491         return IMAGE_BAD_PARAMETER;
492     }
493     return ToNewErrorCode(pixelmap->GetInnerPixelmap()->ReadPixels(*bufferSize, destination));
494 }
495 
496 MIDK_EXPORT
OH_PixelmapNative_WritePixels(OH_PixelmapNative * pixelmap,uint8_t * source,size_t bufferSize)497 Image_ErrorCode OH_PixelmapNative_WritePixels(OH_PixelmapNative *pixelmap, uint8_t *source, size_t bufferSize)
498 {
499     if (pixelmap == nullptr || source == nullptr || !pixelmap->GetInnerPixelmap()) {
500         return IMAGE_BAD_PARAMETER;
501     }
502     return ToNewErrorCode(pixelmap->GetInnerPixelmap()->WritePixels(source, bufferSize));
503 }
504 
505 MIDK_EXPORT
OH_PixelmapNative_GetArgbPixels(OH_PixelmapNative * pixelmap,uint8_t * destination,size_t * bufferSize)506 Image_ErrorCode OH_PixelmapNative_GetArgbPixels(OH_PixelmapNative *pixelmap, uint8_t *destination, size_t *bufferSize)
507 {
508     if (pixelmap == nullptr || destination == nullptr || bufferSize == nullptr || !pixelmap->GetInnerPixelmap()) {
509         return IMAGE_BAD_PARAMETER;
510     }
511     return ToNewErrorCode(pixelmap->GetInnerPixelmap()->ReadARGBPixels(*bufferSize, destination));
512 }
513 
514 MIDK_EXPORT
OH_PixelmapNative_ToSdr(OH_PixelmapNative * pixelmap)515 Image_ErrorCode OH_PixelmapNative_ToSdr(OH_PixelmapNative *pixelmap)
516 {
517     if (pixelmap == nullptr || !pixelmap->GetInnerPixelmap()) {
518         return IMAGE_BAD_PARAMETER;
519     }
520     if (pixelmap->GetInnerPixelmap()->ToSdr() != IMAGE_SUCCESS) {
521         return IMAGE_UNSUPPORTED_OPERATION;
522     }
523     return IMAGE_SUCCESS;
524 }
525 
526 MIDK_EXPORT
OH_PixelmapNative_GetImageInfo(OH_PixelmapNative * pixelmap,OH_Pixelmap_ImageInfo * imageInfo)527 Image_ErrorCode OH_PixelmapNative_GetImageInfo(OH_PixelmapNative *pixelmap, OH_Pixelmap_ImageInfo *imageInfo)
528 {
529     if (pixelmap == nullptr || imageInfo == nullptr || !pixelmap->GetInnerPixelmap()) {
530         return IMAGE_BAD_PARAMETER;
531     }
532     ImageInfo srcInfo;
533     pixelmap->GetInnerPixelmap()->GetImageInfo(srcInfo);
534     imageInfo->width = static_cast<uint32_t>(srcInfo.size.width);
535     imageInfo->height = static_cast<uint32_t>(srcInfo.size.height);
536     imageInfo->rowStride = static_cast<uint32_t>(pixelmap->GetInnerPixelmap()->GetRowStride());
537     imageInfo->pixelFormat = static_cast<int32_t>(srcInfo.pixelFormat);
538     imageInfo->isHdr = pixelmap->GetInnerPixelmap()->IsHdr();
539     return IMAGE_SUCCESS;
540 }
541 
542 MIDK_EXPORT
OH_PixelmapNative_Opacity(OH_PixelmapNative * pixelmap,float rate)543 Image_ErrorCode OH_PixelmapNative_Opacity(OH_PixelmapNative *pixelmap, float rate)
544 {
545     if (pixelmap == nullptr || !pixelmap->GetInnerPixelmap()) {
546         return IMAGE_BAD_PARAMETER;
547     }
548     pixelmap->GetInnerPixelmap()->SetAlpha(rate);
549     return IMAGE_SUCCESS;
550 }
551 
552 MIDK_EXPORT
OH_PixelmapNative_Scale(OH_PixelmapNative * pixelmap,float scaleX,float scaleY)553 Image_ErrorCode OH_PixelmapNative_Scale(OH_PixelmapNative *pixelmap, float scaleX, float scaleY)
554 {
555     if (pixelmap == nullptr || !pixelmap->GetInnerPixelmap()) {
556         return IMAGE_BAD_PARAMETER;
557     }
558     pixelmap->GetInnerPixelmap()->scale(scaleX, scaleY);
559     return IMAGE_SUCCESS;
560 }
561 
562 MIDK_EXPORT
OH_PixelmapNative_ScaleWithAntiAliasing(OH_PixelmapNative * pixelmap,float scaleX,float scaleY,OH_PixelmapNative_AntiAliasingLevel level)563 Image_ErrorCode OH_PixelmapNative_ScaleWithAntiAliasing(OH_PixelmapNative *pixelmap, float scaleX, float scaleY,
564     OH_PixelmapNative_AntiAliasingLevel level)
565 {
566     if (pixelmap == nullptr) {
567         return IMAGE_BAD_PARAMETER;
568     }
569     pixelmap->GetInnerPixelmap()->scale(scaleX, scaleY, static_cast<AntiAliasingOption>(level));
570     return IMAGE_SUCCESS;
571 }
572 
573 MIDK_EXPORT
OH_PixelmapNative_Translate(OH_PixelmapNative * pixelmap,float x,float y)574 Image_ErrorCode OH_PixelmapNative_Translate(OH_PixelmapNative *pixelmap, float x, float y)
575 {
576     if (pixelmap == nullptr || !pixelmap->GetInnerPixelmap()) {
577         return IMAGE_BAD_PARAMETER;
578     }
579     pixelmap->GetInnerPixelmap()->translate(x, y);
580     return IMAGE_SUCCESS;
581 }
582 
583 MIDK_EXPORT
OH_PixelmapNative_Rotate(OH_PixelmapNative * pixelmap,float angle)584 Image_ErrorCode OH_PixelmapNative_Rotate(OH_PixelmapNative *pixelmap, float angle)
585 {
586     if (pixelmap == nullptr || !pixelmap->GetInnerPixelmap()) {
587         return IMAGE_BAD_PARAMETER;
588     }
589     pixelmap->GetInnerPixelmap()->rotate(angle);
590     return IMAGE_SUCCESS;
591 }
592 
593 MIDK_EXPORT
OH_PixelmapNative_Flip(OH_PixelmapNative * pixelmap,bool shouldFilpHorizontally,bool shouldFilpVertically)594 Image_ErrorCode OH_PixelmapNative_Flip(OH_PixelmapNative *pixelmap, bool shouldFilpHorizontally,
595     bool shouldFilpVertically)
596 {
597     if (pixelmap == nullptr || !pixelmap->GetInnerPixelmap()) {
598         return IMAGE_BAD_PARAMETER;
599     }
600     pixelmap->GetInnerPixelmap()->flip(shouldFilpHorizontally, shouldFilpVertically);
601     return IMAGE_SUCCESS;
602 }
603 
604 MIDK_EXPORT
OH_PixelmapNative_Crop(OH_PixelmapNative * pixelmap,Image_Region * region)605 Image_ErrorCode OH_PixelmapNative_Crop(OH_PixelmapNative *pixelmap, Image_Region *region)
606 {
607     if (pixelmap == nullptr || region == nullptr || !pixelmap->GetInnerPixelmap()) {
608         return IMAGE_BAD_PARAMETER;
609     }
610     OHOS::Media::Rect rect;
611     rect.left = static_cast<int32_t>(region->x);
612     rect.top = static_cast<int32_t>(region->y);
613     rect.width = static_cast<int32_t>(region->width);
614     rect.height = static_cast<int32_t>(region->height);
615     pixelmap->GetInnerPixelmap()->crop(rect);
616     return IMAGE_SUCCESS;
617 }
618 
619 MIDK_EXPORT
OH_PixelmapNative_Release(OH_PixelmapNative * pixelmap)620 Image_ErrorCode OH_PixelmapNative_Release(OH_PixelmapNative *pixelmap)
621 {
622     if (pixelmap == nullptr) {
623         return IMAGE_BAD_PARAMETER;
624     }
625     pixelmap->~OH_PixelmapNative();
626     return IMAGE_SUCCESS;
627 }
628 
629 MIDK_EXPORT
OH_PixelmapNative_ConvertAlphaFormat(OH_PixelmapNative * srcpixelmap,OH_PixelmapNative * dstpixelmap,const bool isPremul)630 Image_ErrorCode OH_PixelmapNative_ConvertAlphaFormat(OH_PixelmapNative* srcpixelmap,
631     OH_PixelmapNative* dstpixelmap, const bool isPremul)
632 {
633     if (srcpixelmap == nullptr || dstpixelmap == nullptr ||
634         !srcpixelmap->GetInnerPixelmap() || !dstpixelmap->GetInnerPixelmap()) {
635         return IMAGE_BAD_PARAMETER;
636     }
637     srcpixelmap->GetInnerPixelmap()->ConvertAlphaFormat(*(dstpixelmap->GetInnerPixelmap()), isPremul);
638     return IMAGE_SUCCESS;
639 }
640 
ImageConvert_YuvToRgb(OH_PixelmapNative * srcPixelMap,OH_PixelmapNative ** destPixelMap,int32_t destPixelFormat)641 static uint32_t ImageConvert_YuvToRgb(OH_PixelmapNative *srcPixelMap, OH_PixelmapNative **destPixelMap,
642                                       int32_t destPixelFormat)
643 {
644     if (srcPixelMap == nullptr) {
645         return IMAGE_BAD_PARAMETER;
646     }
647     PixelFormat srcPixelFormat = srcPixelMap->GetInnerPixelmap()->GetPixelFormat();
648     PixelFormat destFormat = static_cast<PixelFormat>(destPixelFormat);
649     if (!IsMatchType(IMAGE_FORMAT::IMAGE_FORMAT_YUV_TYPE, srcPixelFormat) ||
650         !IsMatchType(IMAGE_FORMAT::IMAGE_FORMAT_RGB_TYPE, destFormat)) {
651         return IMAGE_BAD_PARAMETER;
652     }
653 
654     std::shared_ptr<OHOS::Media::PixelMap> innerPixelMap = srcPixelMap->GetInnerPixelmap();
655     std::shared_ptr<PixelMap> pixelMap = std::static_pointer_cast<PixelMap>(innerPixelMap);
656     uint32_t ret = ImageFormatConvert::ConvertImageFormat(pixelMap, destFormat);
657     *destPixelMap = new OH_PixelmapNative(pixelMap);
658 
659     return ret;
660 }
661 
ImageConvert_RgbToYuv(OH_PixelmapNative * srcPixelMap,OH_PixelmapNative ** destPixelMap,int32_t destPixelFormat)662 static uint32_t ImageConvert_RgbToYuv(OH_PixelmapNative *srcPixelMap, OH_PixelmapNative **destPixelMap,
663                                       int32_t destPixelFormat)
664 {
665     if (srcPixelMap == nullptr) {
666         return IMAGE_BAD_PARAMETER;
667     }
668 
669     PixelFormat srcPixelFormat = srcPixelMap->GetInnerPixelmap()->GetPixelFormat();
670     PixelFormat destFormat = static_cast<PixelFormat>(destPixelFormat);
671     if (!IsMatchType(IMAGE_FORMAT::IMAGE_FORMAT_RGB_TYPE, srcPixelFormat) ||
672         !IsMatchType(IMAGE_FORMAT::IMAGE_FORMAT_YUV_TYPE, destFormat)) {
673         return IMAGE_BAD_PARAMETER;
674     }
675 
676     std::shared_ptr<OHOS::Media::PixelMap> innerPixelMap = srcPixelMap->GetInnerPixelmap();
677     std::shared_ptr<PixelMap> pixelMap = std::static_pointer_cast<PixelMap>(innerPixelMap);
678     uint32_t ret = ImageFormatConvert::ConvertImageFormat(pixelMap, destFormat);
679     *destPixelMap = new OH_PixelmapNative(pixelMap);
680     return ret;
681 }
682 
683 MIDK_EXPORT
OH_PixelMapNative_ConvertPixelFormat(OH_PixelmapNative * srcPixelMap,OH_PixelmapNative ** destPixelMap,int32_t destPixelFormat)684 Image_ErrorCode OH_PixelMapNative_ConvertPixelFormat(OH_PixelmapNative *srcPixelMap, OH_PixelmapNative **destPixelMap,
685                                                      int32_t destPixelFormat)
686 {
687     if (srcPixelMap == nullptr) {
688         return IMAGE_BAD_PARAMETER;
689     }
690 
691     PixelFormat srcPixelFormat = srcPixelMap->GetInnerPixelmap()->GetPixelFormat();
692     const uint32_t SUCCESS = 0;
693     if (IsMatchType(IMAGE_FORMAT::IMAGE_FORMAT_YUV_TYPE, srcPixelFormat)) {
694         if (ImageConvert_YuvToRgb(srcPixelMap, destPixelMap, destPixelFormat) != SUCCESS) {
695             return IMAGE_BAD_PARAMETER;
696         }
697     } else if (IsMatchType(IMAGE_FORMAT::IMAGE_FORMAT_RGB_TYPE, srcPixelFormat)) {
698         if (ImageConvert_RgbToYuv(srcPixelMap, destPixelMap, destPixelFormat) != SUCCESS) {
699             return IMAGE_BAD_PARAMETER;
700         }
701     } else {
702         return IMAGE_BAD_PARAMETER;
703     }
704     return IMAGE_SUCCESS;
705 }
706 constexpr uint8_t INDEX_ZERO = 0;
707 constexpr uint8_t INDEX_ONE = 1;
708 constexpr uint8_t INDEX_TWO = 2;
709 using namespace OHOS::HDI::Display::Graphic::Common::V1_0;
710 static std::map<OH_Pixelmap_HdrMetadataType, const CM_HDR_Metadata_Type> NdkMetadataTypeMap = {
711     {HDR_METADATA_TYPE_NONE, CM_METADATA_NONE},
712     {HDR_METADATA_TYPE_BASE, CM_IMAGE_HDR_VIVID_DUAL},
713     {HDR_METADATA_TYPE_GAINMAP, CM_METADATA_NONE},
714     {HDR_METADATA_TYPE_ALTERNATE, CM_IMAGE_HDR_VIVID_SINGLE},
715 };
716 
717 static std::map<CM_HDR_Metadata_Type, OH_Pixelmap_HdrMetadataType> MetadataNdkTypeMap = {
718     {CM_METADATA_NONE, HDR_METADATA_TYPE_NONE},
719     {CM_IMAGE_HDR_VIVID_DUAL, HDR_METADATA_TYPE_BASE},
720     {CM_METADATA_NONE, HDR_METADATA_TYPE_GAINMAP},
721     {CM_IMAGE_HDR_VIVID_SINGLE, HDR_METADATA_TYPE_ALTERNATE},
722 };
723 
ConvertStaticMetadata(const OH_Pixelmap_HdrStaticMetadata & metadata,std::vector<uint8_t> & staticMetadataVec)724 static bool ConvertStaticMetadata(const OH_Pixelmap_HdrStaticMetadata &metadata,
725     std::vector<uint8_t> &staticMetadataVec)
726 {
727 #if defined(_WIN32) || defined(_APPLE) || defined(IOS_PLATFORM) || defined(ANDROID_PLATFORM)
728     return {};
729 #else
730     HDI::Display::Graphic::Common::V1_0::HdrStaticMetadata staticMetadata{};
731     staticMetadata.smpte2086.displayPrimaryRed.x = metadata.displayPrimariesX[INDEX_ZERO];
732     staticMetadata.smpte2086.displayPrimaryRed.y = metadata.displayPrimariesY[INDEX_ZERO];
733     staticMetadata.smpte2086.displayPrimaryGreen.x = metadata.displayPrimariesX[INDEX_ONE];
734     staticMetadata.smpte2086.displayPrimaryGreen.y = metadata.displayPrimariesY[INDEX_ONE];
735     staticMetadata.smpte2086.displayPrimaryBlue.x = metadata.displayPrimariesX[INDEX_TWO];
736     staticMetadata.smpte2086.displayPrimaryBlue.y = metadata.displayPrimariesY[INDEX_TWO];
737     staticMetadata.smpte2086.whitePoint.x = metadata.whitePointX;
738     staticMetadata.smpte2086.whitePoint.y = metadata.whitePointY;
739     staticMetadata.smpte2086.maxLuminance = metadata.maxLuminance;
740     staticMetadata.smpte2086.minLuminance = metadata.minLuminance;
741     staticMetadata.cta861.maxContentLightLevel = metadata.maxContentLightLevel;
742     staticMetadata.cta861.maxFrameAverageLightLevel = metadata.maxFrameAverageLightLevel;
743     uint32_t vecSize = sizeof(HDI::Display::Graphic::Common::V1_0::HdrStaticMetadata);
744     if (memcpy_s(staticMetadataVec.data(), vecSize, &staticMetadata, vecSize) != EOK) {
745         return false;
746     }
747     return true;
748 #endif
749 }
750 
ConvertGainmapMetadata(OH_Pixelmap_HdrGainmapMetadata & metadata,HDRVividExtendMetadata & extendMetadata)751 static void ConvertGainmapMetadata(OH_Pixelmap_HdrGainmapMetadata &metadata, HDRVividExtendMetadata &extendMetadata)
752 {
753     extendMetadata.metaISO.writeVersion = metadata.writerVersion;
754     extendMetadata.metaISO.miniVersion = metadata.minVersion;
755     extendMetadata.metaISO.gainmapChannelNum = metadata.gainmapChannelNum;
756     extendMetadata.metaISO.useBaseColorFlag = metadata.useBaseColorFlag;
757     extendMetadata.metaISO.baseHeadroom = metadata.baseHdrHeadroom;
758     extendMetadata.metaISO.alternateHeadroom = metadata.alternateHdrHeadroom;
759 
760     extendMetadata.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_ZERO] = metadata.gainmapMax[INDEX_ZERO];
761     extendMetadata.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_ONE] = metadata.gainmapMax[INDEX_ONE];
762     extendMetadata.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_TWO] = metadata.gainmapMax[INDEX_TWO];
763 
764     extendMetadata.metaISO.enhanceClippedThreholdMinGainmap[INDEX_ZERO] = metadata.gainmapMin[INDEX_ZERO];
765     extendMetadata.metaISO.enhanceClippedThreholdMinGainmap[INDEX_ONE] = metadata.gainmapMin[INDEX_ONE];
766     extendMetadata.metaISO.enhanceClippedThreholdMinGainmap[INDEX_TWO] = metadata.gainmapMin[INDEX_TWO];
767 
768     extendMetadata.metaISO.enhanceMappingGamma[INDEX_ZERO] = metadata.gamma[INDEX_ZERO];
769     extendMetadata.metaISO.enhanceMappingGamma[INDEX_ONE] = metadata.gamma[INDEX_ONE];
770     extendMetadata.metaISO.enhanceMappingGamma[INDEX_TWO] = metadata.gamma[INDEX_TWO];
771 
772     extendMetadata.metaISO.enhanceMappingBaselineOffset[INDEX_ZERO] = metadata.baselineOffset[INDEX_ZERO];
773     extendMetadata.metaISO.enhanceMappingBaselineOffset[INDEX_ONE] = metadata.baselineOffset[INDEX_ONE];
774     extendMetadata.metaISO.enhanceMappingBaselineOffset[INDEX_TWO] = metadata.baselineOffset[INDEX_TWO];
775 
776     extendMetadata.metaISO.enhanceMappingAlternateOffset[INDEX_ZERO] = metadata.alternateOffset[INDEX_ZERO];
777     extendMetadata.metaISO.enhanceMappingAlternateOffset[INDEX_ONE] = metadata.alternateOffset[INDEX_ONE];
778     extendMetadata.metaISO.enhanceMappingAlternateOffset[INDEX_TWO] = metadata.alternateOffset[INDEX_TWO];
779 }
780 
BuildGainmapMetadata(OHOS::Media::PixelMap & pixelmap,OH_Pixelmap_HdrGainmapMetadata & metadata,std::vector<uint8_t> & extendMetadataVec)781 static bool BuildGainmapMetadata(OHOS::Media::PixelMap &pixelmap, OH_Pixelmap_HdrGainmapMetadata &metadata,
782     std::vector<uint8_t> &extendMetadataVec)
783 {
784     HDRVividExtendMetadata extendMetadata;
785     #ifdef IMAGE_COLORSPACE_FLAG
786     OHOS::ColorManager::ColorSpace colorSpace = pixelmap.InnerGetGrColorSpace();
787     uint16_t SS = ColorUtils::GetPrimaries(colorSpace.GetColorSpaceName());
788     #else
789     uint16_t SS = 0;
790     #endif
791     extendMetadata.baseColorMeta.baseColorPrimary = SS;
792     extendMetadata.gainmapColorMeta.combineColorPrimary = metadata.useBaseColorFlag ? SS: (uint8_t)CM_BT2020_HLG_FULL;
793     extendMetadata.gainmapColorMeta.enhanceDataColorModel = metadata.useBaseColorFlag ? SS: (uint8_t)CM_BT2020_HLG_FULL;
794     extendMetadata.gainmapColorMeta.alternateColorPrimary = (uint8_t)CM_BT2020_HLG_FULL;
795     ConvertGainmapMetadata(metadata, extendMetadata);
796     uint32_t vecSize = sizeof(HDRVividExtendMetadata);
797     if (memcpy_s(extendMetadataVec.data(), vecSize, &extendMetadata, vecSize) != EOK) {
798         return false;
799     }
800     return true;
801 }
802 
SetHdrMetadata(OHOS::Media::PixelMap & pixelmap,OHOS::sptr<OHOS::SurfaceBuffer> & buffer,OH_Pixelmap_HdrMetadataKey key,OH_Pixelmap_HdrMetadataValue & value)803 static bool SetHdrMetadata(OHOS::Media::PixelMap &pixelmap, OHOS::sptr<OHOS::SurfaceBuffer> &buffer,
804     OH_Pixelmap_HdrMetadataKey key, OH_Pixelmap_HdrMetadataValue &value)
805 {
806     switch (key) {
807         case OH_Pixelmap_HdrMetadataKey::HDR_METADATA_TYPE:
808             if (NdkMetadataTypeMap.find(value.type) != NdkMetadataTypeMap.end()) {
809                 VpeUtils::SetSbMetadataType(buffer, NdkMetadataTypeMap[value.type]);
810             }
811             break;
812         case OH_Pixelmap_HdrMetadataKey::HDR_STATIC_METADATA:
813             {
814                 OH_Pixelmap_HdrStaticMetadata &staticMetadata = value.staticMetadata;
815                 uint32_t vecSize = sizeof(HDI::Display::Graphic::Common::V1_0::HdrStaticMetadata);
816                 std::vector<uint8_t> metadataVec(vecSize);
817                 if (!ConvertStaticMetadata(staticMetadata, metadataVec)) {
818                     return false;
819                 }
820                 if (!VpeUtils::SetSbStaticMetadata(buffer, metadataVec)) {
821                     return false;
822                 }
823             }
824             break;
825         case OH_Pixelmap_HdrMetadataKey::HDR_DYNAMIC_METADATA:
826             {
827                 std::vector<uint8_t> metadataVec(value.dynamicMetadata.length);
828                 if (memcpy_s(metadataVec.data(), value.dynamicMetadata.length, value.dynamicMetadata.data,
829                     value.dynamicMetadata.length) != EOK) {
830                     return false;
831                 }
832                 if (!VpeUtils::SetSbDynamicMetadata(buffer, metadataVec)) {
833                     return false;
834                 }
835             }
836             break;
837         case OH_Pixelmap_HdrMetadataKey::HDR_GAINMAP_METADATA:
838             {
839                 std::vector<uint8_t> extendMetadataVec(sizeof(HDRVividExtendMetadata));
840                 if (!BuildGainmapMetadata(pixelmap, value.gainmapMetadata, extendMetadataVec)) {
841                     return false;
842                 }
843                 if (!VpeUtils::SetSbDynamicMetadata(buffer, extendMetadataVec)) {
844                     return false;
845                 }
846             }
847             break;
848         default:
849             break;
850     }
851 
852     return true;
853 }
854 
855 MIDK_EXPORT
OH_PixelmapNative_SetMetadata(OH_PixelmapNative * pixelmap,OH_Pixelmap_HdrMetadataKey key,OH_Pixelmap_HdrMetadataValue * value)856 Image_ErrorCode OH_PixelmapNative_SetMetadata(OH_PixelmapNative *pixelmap, OH_Pixelmap_HdrMetadataKey key,
857     OH_Pixelmap_HdrMetadataValue *value)
858 {
859     if (pixelmap == nullptr || pixelmap->GetInnerPixelmap() == nullptr || value == nullptr) {
860         return IMAGE_BAD_PARAMETER;
861     }
862 
863     if (pixelmap->GetInnerPixelmap()->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
864         return IMAGE_DMA_NOT_EXIST;
865     }
866 
867     OHOS::sptr<OHOS::SurfaceBuffer> surfaceBuffer(
868         reinterpret_cast<OHOS::SurfaceBuffer*>(pixelmap->GetInnerPixelmap()->GetFd()));
869     if (!SetHdrMetadata(*(pixelmap->GetInnerPixelmap().get()), surfaceBuffer, key, *value)) {
870         return IMAGE_COPY_FAILED;
871     }
872 
873     return IMAGE_SUCCESS;
874 }
875 
ConvertToOHGainmapMetadata(HDRVividExtendMetadata & src,OH_Pixelmap_HdrGainmapMetadata & dst)876 static void ConvertToOHGainmapMetadata(HDRVividExtendMetadata &src, OH_Pixelmap_HdrGainmapMetadata &dst)
877 {
878     dst.writerVersion = src.metaISO.writeVersion;
879     dst.minVersion = src.metaISO.miniVersion;
880     dst.gainmapChannelNum = src.metaISO.gainmapChannelNum;
881     dst.useBaseColorFlag = src.metaISO.useBaseColorFlag;
882     dst.baseHdrHeadroom = src.metaISO.baseHeadroom;
883     dst.alternateHdrHeadroom = src.metaISO.alternateHeadroom;
884 
885     dst.gainmapMax[INDEX_ZERO] = src.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_ZERO];
886     dst.gainmapMax[INDEX_ONE] = src.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_ONE];
887     dst.gainmapMax[INDEX_TWO] = src.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_TWO];
888 
889     dst.gainmapMin[INDEX_ZERO] = src.metaISO.enhanceClippedThreholdMinGainmap[INDEX_ZERO];
890     dst.gainmapMin[INDEX_ONE] = src.metaISO.enhanceClippedThreholdMinGainmap[INDEX_ONE];
891     dst.gainmapMin[INDEX_TWO] = src.metaISO.enhanceClippedThreholdMinGainmap[INDEX_TWO];
892 
893     dst.gamma[INDEX_ZERO] = src.metaISO.enhanceMappingGamma[INDEX_ZERO];
894     dst.gamma[INDEX_ONE] = src.metaISO.enhanceMappingGamma[INDEX_ONE];
895     dst.gamma[INDEX_TWO] = src.metaISO.enhanceMappingGamma[INDEX_TWO];
896 
897     dst.baselineOffset[INDEX_ZERO] = src.metaISO.enhanceMappingBaselineOffset[INDEX_ZERO];
898     dst.baselineOffset[INDEX_ONE] = src.metaISO.enhanceMappingBaselineOffset[INDEX_ONE];
899     dst.baselineOffset[INDEX_TWO] = src.metaISO.enhanceMappingBaselineOffset[INDEX_TWO];
900 
901     dst.alternateOffset[INDEX_ZERO] = src.metaISO.enhanceMappingAlternateOffset[INDEX_ZERO];
902     dst.alternateOffset[INDEX_ONE] = src.metaISO.enhanceMappingAlternateOffset[INDEX_ONE];
903     dst.alternateOffset[INDEX_TWO] = src.metaISO.enhanceMappingAlternateOffset[INDEX_TWO];
904 }
905 
ConvertTONdkStaticMetadata(HdrStaticMetadata & src,OH_Pixelmap_HdrStaticMetadata & dst)906 static bool ConvertTONdkStaticMetadata(HdrStaticMetadata &src,
907     OH_Pixelmap_HdrStaticMetadata &dst)
908 {
909     dst.displayPrimariesX[INDEX_ZERO] = src.smpte2086.displayPrimaryRed.x;
910     dst.displayPrimariesY[INDEX_ZERO] = src.smpte2086.displayPrimaryRed.y;
911     dst.displayPrimariesX[INDEX_ONE] = src.smpte2086.displayPrimaryGreen.x;
912     dst.displayPrimariesY[INDEX_ONE] = src.smpte2086.displayPrimaryGreen.y;
913     dst.displayPrimariesX[INDEX_TWO] = src.smpte2086.displayPrimaryBlue.x;
914     dst.displayPrimariesY[INDEX_TWO] = src.smpte2086.displayPrimaryBlue.y;
915     dst.whitePointX = src.smpte2086.whitePoint.x;
916     dst.whitePointY = src.smpte2086.whitePoint.y;
917     dst.maxLuminance = src.smpte2086.maxLuminance;
918     dst.minLuminance = src.smpte2086.minLuminance;
919     dst.maxContentLightLevel = src.cta861.maxContentLightLevel;
920     dst.maxFrameAverageLightLevel = src.cta861.maxFrameAverageLightLevel;
921     return true;
922 }
923 
GetStaticMetadata(const OHOS::sptr<OHOS::SurfaceBuffer> & buffer,OH_Pixelmap_HdrMetadataValue * metadataValue)924 static bool GetStaticMetadata(const OHOS::sptr<OHOS::SurfaceBuffer> &buffer,
925     OH_Pixelmap_HdrMetadataValue *metadataValue)
926 {
927     std::vector<uint8_t> staticData;
928     uint32_t vecSize = sizeof(HDI::Display::Graphic::Common::V1_0::HdrStaticMetadata);
929     if (VpeUtils::GetSbStaticMetadata(buffer, staticData) &&
930         (staticData.size() == vecSize)) {
931         OH_Pixelmap_HdrStaticMetadata &dst = metadataValue->staticMetadata;
932         HdrStaticMetadata &src = *(reinterpret_cast<HdrStaticMetadata*>(staticData.data()));
933         return ConvertTONdkStaticMetadata(src, dst);
934     }
935     return false;
936 }
937 
GetHdrMetadata(const OHOS::sptr<OHOS::SurfaceBuffer> & buffer,OH_Pixelmap_HdrMetadataKey key,OH_Pixelmap_HdrMetadataValue * metadataValue)938 static bool GetHdrMetadata(const OHOS::sptr<OHOS::SurfaceBuffer> &buffer,
939     OH_Pixelmap_HdrMetadataKey key, OH_Pixelmap_HdrMetadataValue *metadataValue)
940 {
941     if (buffer == nullptr || metadataValue == nullptr) {
942         IMAGE_LOGE("GetHdrMetadata buffer is nullptr");
943         return false;
944     }
945     switch (key) {
946         case OH_Pixelmap_HdrMetadataKey::HDR_METADATA_TYPE:
947             {
948                 CM_HDR_Metadata_Type type;
949                 VpeUtils::GetSbMetadataType(buffer, type);
950                 if (MetadataNdkTypeMap.find(type) != MetadataNdkTypeMap.end()) {
951                     metadataValue->type = MetadataNdkTypeMap[type];
952                     return true;
953                 }
954             }
955             break;
956         case OH_Pixelmap_HdrMetadataKey::HDR_STATIC_METADATA:
957             return GetStaticMetadata(buffer, metadataValue);
958             break;
959         case OH_Pixelmap_HdrMetadataKey::HDR_DYNAMIC_METADATA:
960             {
961                 std::vector<uint8_t> dynamicData;
962                 if (VpeUtils::GetSbDynamicMetadata(buffer, dynamicData) && (dynamicData.size() > 0)) {
963                     metadataValue->dynamicMetadata.data = (uint8_t*)malloc(dynamicData.size());
964                     if (metadataValue->dynamicMetadata.data == nullptr || memcpy_s(metadataValue->dynamicMetadata.data,
965                         dynamicData.size(), dynamicData.data(), dynamicData.size()) != EOK) {
966                         return false;
967                     }
968                     metadataValue->dynamicMetadata.length = dynamicData.size();
969                     return true;
970                 }
971             }
972             break;
973         case OH_Pixelmap_HdrMetadataKey::HDR_GAINMAP_METADATA:
974             {
975                 std::vector<uint8_t> gainmapData;
976                 if (VpeUtils::GetSbDynamicMetadata(buffer, gainmapData) &&
977                     (gainmapData.size() == sizeof(HDRVividExtendMetadata))) {
978                     OH_Pixelmap_HdrGainmapMetadata &dst = metadataValue->gainmapMetadata;
979                     HDRVividExtendMetadata &src = *(reinterpret_cast<HDRVividExtendMetadata*>(gainmapData.data()));
980                     ConvertToOHGainmapMetadata(src, dst);
981                     return true;
982                 }
983             }
984             break;
985         default:
986             break;
987     }
988 
989     return false;
990 }
991 
992 MIDK_EXPORT
OH_PixelmapNative_GetMetadata(OH_PixelmapNative * pixelmap,OH_Pixelmap_HdrMetadataKey key,OH_Pixelmap_HdrMetadataValue ** value)993 Image_ErrorCode OH_PixelmapNative_GetMetadata(OH_PixelmapNative *pixelmap, OH_Pixelmap_HdrMetadataKey key,
994     OH_Pixelmap_HdrMetadataValue **value)
995 {
996     if (pixelmap == nullptr || pixelmap->GetInnerPixelmap() == nullptr || value == nullptr || *value == nullptr) {
997         return IMAGE_BAD_PARAMETER;
998     }
999 
1000     if (pixelmap->GetInnerPixelmap()->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
1001         return IMAGE_DMA_NOT_EXIST;
1002     }
1003 
1004     OHOS::sptr<OHOS::SurfaceBuffer> sourceSurfaceBuffer(
1005         reinterpret_cast<OHOS::SurfaceBuffer*>(pixelmap->GetInnerPixelmap()->GetFd()));
1006     if (!GetHdrMetadata(sourceSurfaceBuffer, key, *value)) {
1007         return IMAGE_COPY_FAILED;
1008     }
1009     return IMAGE_SUCCESS;
1010 }
1011 
1012 MIDK_EXPORT
OH_PixelmapNative_GetNativeBuffer(OH_PixelmapNative * pixelmap,OH_NativeBuffer ** nativeBuffer)1013 Image_ErrorCode OH_PixelmapNative_GetNativeBuffer(OH_PixelmapNative *pixelmap, OH_NativeBuffer **nativeBuffer)
1014 {
1015     if (pixelmap == nullptr || pixelmap->GetInnerPixelmap() == nullptr || nativeBuffer == nullptr) {
1016         return IMAGE_BAD_PARAMETER;
1017     }
1018 
1019     if (pixelmap->GetInnerPixelmap()->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
1020         return IMAGE_DMA_NOT_EXIST;
1021     }
1022 
1023     OHOS::SurfaceBuffer *buffer = reinterpret_cast<OHOS::SurfaceBuffer*>(pixelmap->GetInnerPixelmap()->GetFd());
1024     if (buffer == nullptr) {
1025         return IMAGE_BAD_PARAMETER;
1026     }
1027     *nativeBuffer = buffer->SurfaceBufferToNativeBuffer();
1028     int32_t err = OH_NativeBuffer_Reference(*nativeBuffer);
1029     if (err != OHOS::SURFACE_ERROR_OK) {
1030         return IMAGE_DMA_OPERATION_FAILED;
1031     }
1032     return IMAGE_SUCCESS;
1033 }
1034 
1035 MIDK_EXPORT
OH_PixelmapNative_SetMemoryName(OH_PixelmapNative * pixelmap,char * name,size_t * size)1036 Image_ErrorCode OH_PixelmapNative_SetMemoryName(OH_PixelmapNative *pixelmap, char *name, size_t *size)
1037 {
1038     if (pixelmap == nullptr || pixelmap->GetInnerPixelmap() == nullptr || name == nullptr || size == nullptr) {
1039         return IMAGE_BAD_PARAMETER;
1040     }
1041     uint32_t ret = pixelmap->GetInnerPixelmap()->SetMemoryName(std::string(name, *size));
1042     if (ret == SUCCESS) {
1043         return IMAGE_SUCCESS;
1044     } else if (ret == COMMON_ERR_INVALID_PARAMETER) {
1045         return IMAGE_BAD_PARAMETER;
1046     } else if (ret == ERR_MEMORY_NOT_SUPPORT) {
1047         return IMAGE_UNSUPPORTED_MEMORY_FORMAT;
1048     }
1049     return IMAGE_SUCCESS;
1050 }
1051 
1052 MIDK_EXPORT
OH_PixelmapNative_GetColorSpaceNative(OH_PixelmapNative * pixelmap,OH_NativeColorSpaceManager ** colorSpaceNative)1053 Image_ErrorCode OH_PixelmapNative_GetColorSpaceNative(OH_PixelmapNative *pixelmap,
1054     OH_NativeColorSpaceManager **colorSpaceNative)
1055 {
1056     if (pixelmap == nullptr || pixelmap->GetInnerPixelmap() == nullptr || colorSpaceNative == nullptr) {
1057         return IMAGE_BAD_PARAMETER;
1058     }
1059 
1060     if (pixelmap->GetInnerPixelmap()->InnerGetGrColorSpacePtr() == nullptr) {
1061         return IMAGE_BAD_PARAMETER;
1062     }
1063 
1064     std::shared_ptr<OHOS::ColorManager::ColorSpace> colorSpace =
1065         pixelmap->GetInnerPixelmap()->InnerGetGrColorSpacePtr();
1066     NativeColorSpaceManager* nativeColorspace = new NativeColorSpaceManager(*(colorSpace.get()));
1067 
1068     *colorSpaceNative = reinterpret_cast<OH_NativeColorSpaceManager*>(nativeColorspace);
1069     return IMAGE_SUCCESS;
1070 }
1071 
1072 MIDK_EXPORT
OH_PixelmapNative_SetColorSpaceNative(OH_PixelmapNative * pixelmap,OH_NativeColorSpaceManager * colorSpaceNative)1073 Image_ErrorCode OH_PixelmapNative_SetColorSpaceNative(OH_PixelmapNative *pixelmap,
1074     OH_NativeColorSpaceManager *colorSpaceNative)
1075 {
1076     if (pixelmap == nullptr || pixelmap->GetInnerPixelmap() == nullptr || colorSpaceNative == nullptr) {
1077         return IMAGE_BAD_PARAMETER;
1078     }
1079 
1080     ColorManager::ColorSpace nativeColorspace =
1081         reinterpret_cast<NativeColorSpaceManager*>(colorSpaceNative)->GetInnerColorSpace();
1082 
1083     pixelmap->GetInnerPixelmap()->InnerSetColorSpace(nativeColorspace, true);
1084     return IMAGE_SUCCESS;
1085 }
1086 
1087 #ifdef __cplusplus
1088 };
1089 #endif