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 
16 #include "vpe_utils.h"
17 
18 #include <dlfcn.h>
19 
20 #include "hilog/log.h"
21 #include "log_tags.h"
22 #include "image_log.h"
23 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
24 #include "v1_0/buffer_handle_meta_key_type.h"
25 #include "metadata_convertor.h"
26 #include "external_window.h"
27 #include "native_window.h"
28 #endif
29 
30 #undef LOG_DOMAIN
31 #define LOG_DOMAIN LOG_TAG_DOMAIN_ID_PLUGIN
32 
33 #undef LOG_TAG
34 #define LOG_TAG "VpeUtils"
35 
36 namespace OHOS {
37 namespace Media {
38 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
39 using namespace OHOS::HDI::Display::Graphic::Common::V1_0;
40 static constexpr uint32_t TRANSFUNC_OFFSET = 8;
41 static constexpr uint32_t MATRIX_OFFSET = 16;
42 static constexpr uint32_t RANGE_OFFSET = 21;
43 constexpr uint8_t INDEX_ZERO = 0;
44 constexpr uint8_t INDEX_ONE = 1;
45 constexpr uint8_t INDEX_TWO = 2;
46 #endif
47 const static char* VPE_SO_NAME = "libvideoprocessingengine.z.so";
48 void* VpeUtils::dlHandler_ = nullptr;
VpeUtilsDeinitLibVpe()49 __attribute__((destructor)) void VpeUtilsDeinitLibVpe()
50 {
51     VpeUtils::UnloadLibVpe();
52 }
53 
54 using CreateT = int32_t (*)(int32_t*);
55 using DestoryT = int32_t (*)(int32_t*);
56 
57 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
58 using ComposeImageT =
59     int32_t (*)(int32_t, OHNativeWindowBuffer*, OHNativeWindowBuffer*, OHNativeWindowBuffer*, bool);
60 using DecomposeImageT =
61     int32_t (*)(int32_t, OHNativeWindowBuffer*, OHNativeWindowBuffer*, OHNativeWindowBuffer*);
62 using HdrProcessImageT =
63     int32_t (*)(int32_t, OHNativeWindowBuffer*, OHNativeWindowBuffer*);
64 using SrProcessImageT =
65     int32_t (*)(int32_t, OHNativeWindowBuffer*, OHNativeWindowBuffer*, int32_t);
66 #endif
67 
VpeUtils()68 VpeUtils::VpeUtils()
69 {
70     static std::once_flag flag;
71     std::function<void()> func = []() {
72         VpeUtils::LoadLibVpe();
73     };
74     std::call_once(flag, func);
75 }
76 
LoadLibVpe()77 bool VpeUtils::LoadLibVpe()
78 {
79     dlHandler_ = dlopen(VPE_SO_NAME, RTLD_LAZY);
80     if (dlHandler_ == nullptr) {
81         IMAGE_LOGE("VpeUtils LoadLibVpe, failed");
82         return false;
83     }
84     IMAGE_LOGD("VpeUtils LoadLibVpe, success");
85     return true;
86 }
87 
UnloadLibVpe()88 void VpeUtils::UnloadLibVpe()
89 {
90     if (dlHandler_) {
91         dlclose(dlHandler_);
92         dlHandler_ = nullptr;
93     }
94 }
95 
~VpeUtils()96 VpeUtils::~VpeUtils()
97 {
98 }
99 
ColorSpaceConverterCreate(void * handle,int32_t * instanceId)100 int32_t VpeUtils::ColorSpaceConverterCreate(void* handle, int32_t* instanceId)
101 {
102     if (handle == nullptr) {
103         return VPE_ERROR_FAILED;
104     }
105     CreateT create = (CreateT)dlsym(handle, "ColorSpaceConverterCreate");
106     if (!create) {
107         return VPE_ERROR_FAILED;
108     }
109     return create(instanceId);
110 }
111 
ColorSpaceConverterDestory(void * handle,int32_t * instanceId)112 int32_t VpeUtils::ColorSpaceConverterDestory(void* handle, int32_t* instanceId)
113 {
114     if (*instanceId == VPE_ERROR_FAILED || handle == nullptr) {
115         return VPE_ERROR_FAILED;
116     }
117     DestoryT destory = (DestoryT)dlsym(handle, "ColorSpaceConverterDestroy");
118     if (!destory) {
119         return VPE_ERROR_FAILED;
120     }
121     return destory(instanceId);
122 }
123 
124 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
ColorSpaceConverterComposeImage(VpeSurfaceBuffers & sb,bool legacy)125 int32_t VpeUtils::ColorSpaceConverterComposeImage(VpeSurfaceBuffers& sb, bool legacy)
126 {
127     std::lock_guard<std::mutex> lock(vpeMtx_);
128     if (dlHandler_ == nullptr) {
129         return VPE_ERROR_FAILED;
130     }
131 
132     int32_t res;
133     int32_t instanceId = VPE_ERROR_FAILED;
134     res = ColorSpaceConverterCreate(dlHandler_, &instanceId);
135     if (instanceId == VPE_ERROR_FAILED || res != VPE_ERROR_OK) {
136         return VPE_ERROR_FAILED;
137     }
138 
139     ComposeImageT composeImage = (ComposeImageT)dlsym(dlHandler_, "ColorSpaceConverterComposeImage");
140     if (!composeImage) {
141         return VPE_ERROR_FAILED;
142     }
143     if (sb.sdr == nullptr || sb.gainmap == nullptr || sb.hdr == nullptr) {
144         return VPE_ERROR_FAILED;
145     }
146     OHNativeWindowBuffer* sdr = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sb.sdr);
147     OHNativeWindowBuffer* gainmap = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sb.gainmap);
148     OHNativeWindowBuffer* hdr = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sb.hdr);
149     res = composeImage(instanceId, sdr, gainmap, hdr, legacy);
150     OH_NativeWindow_DestroyNativeWindowBuffer(sdr);
151     OH_NativeWindow_DestroyNativeWindowBuffer(gainmap);
152     OH_NativeWindow_DestroyNativeWindowBuffer(hdr);
153     ColorSpaceConverterDestory(dlHandler_, &instanceId);
154     return res;
155 }
156 
ColorSpaceConverterDecomposeImage(VpeSurfaceBuffers & sb)157 int32_t VpeUtils::ColorSpaceConverterDecomposeImage(VpeSurfaceBuffers& sb)
158 {
159     std::lock_guard<std::mutex> lock(vpeMtx_);
160     if (dlHandler_ == nullptr) {
161         return VPE_ERROR_FAILED;
162     }
163 
164     int32_t res;
165     int32_t instanceId = VPE_ERROR_FAILED;
166     res = ColorSpaceConverterCreate(dlHandler_, &instanceId);
167     if (instanceId == VPE_ERROR_FAILED || res != VPE_ERROR_OK) {
168         return VPE_ERROR_FAILED;
169     }
170 
171     DecomposeImageT decomposeImage = (DecomposeImageT)dlsym(dlHandler_, "ColorSpaceConverterDecomposeImage");
172     if (!decomposeImage) {
173         return VPE_ERROR_FAILED;
174     }
175     if (sb.sdr == nullptr || sb.gainmap == nullptr || sb.hdr == nullptr) {
176         return VPE_ERROR_FAILED;
177     }
178     OHNativeWindowBuffer* sdr = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sb.sdr);
179     OHNativeWindowBuffer* gainmap = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sb.gainmap);
180     OHNativeWindowBuffer* hdr = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&sb.hdr);
181     res = decomposeImage(instanceId, hdr, sdr, gainmap);
182     OH_NativeWindow_DestroyNativeWindowBuffer(sdr);
183     OH_NativeWindow_DestroyNativeWindowBuffer(gainmap);
184     OH_NativeWindow_DestroyNativeWindowBuffer(hdr);
185     ColorSpaceConverterDestory(dlHandler_, &instanceId);
186     return res;
187 }
188 
189 // surfacebuffer metadata
SetColorSpaceInfo(sptr<SurfaceBuffer> & buffer,const CM_ColorSpaceInfo & colorSpaceInfo)190 static GSError SetColorSpaceInfo(sptr<SurfaceBuffer>& buffer, const CM_ColorSpaceInfo& colorSpaceInfo)
191 {
192     std::vector<uint8_t> colorSpaceInfoVec;
193     auto ret = MetadataManager::ConvertMetadataToVec(colorSpaceInfo, colorSpaceInfoVec);
194     if (ret != GSERROR_OK) {
195         return ret;
196     }
197     return buffer->SetMetadata(ATTRKEY_COLORSPACE_INFO, colorSpaceInfoVec);
198 }
199 
GetColorSpaceInfo(const sptr<SurfaceBuffer> & buffer,CM_ColorSpaceInfo & colorSpaceInfo)200 static bool GetColorSpaceInfo(const sptr<SurfaceBuffer>& buffer, CM_ColorSpaceInfo& colorSpaceInfo)
201 {
202     std::vector<uint8_t> colorSpaceInfoVec;
203     auto ret = buffer->GetMetadata(ATTRKEY_COLORSPACE_INFO, colorSpaceInfoVec);
204     if (ret != GSERROR_OK) {
205         IMAGE_LOGE("GetColorSpaceInfo GetMetadata failed, return value is %{public}d", ret);
206         return false;
207     }
208     return MetadataManager::ConvertVecToMetadata(colorSpaceInfoVec, colorSpaceInfo) == GSERROR_OK;
209 }
210 
SetSbColorSpaceType(sptr<SurfaceBuffer> & buffer,const CM_ColorSpaceType & colorSpaceType)211 bool VpeUtils::SetSbColorSpaceType(sptr<SurfaceBuffer>& buffer, const CM_ColorSpaceType& colorSpaceType)
212 {
213     CM_ColorSpaceInfo colorSpaceInfo;
214     uint32_t colorSpace = static_cast<uint32_t>(colorSpaceType);
215     colorSpaceInfo.primaries = static_cast<CM_ColorPrimaries>(colorSpace & CM_PRIMARIES_MASK);
216     colorSpaceInfo.transfunc = static_cast<CM_TransFunc>((colorSpace & CM_TRANSFUNC_MASK) >> TRANSFUNC_OFFSET);
217     colorSpaceInfo.matrix = static_cast<CM_Matrix>((colorSpace & CM_MATRIX_MASK) >> MATRIX_OFFSET);
218     colorSpaceInfo.range = static_cast<CM_Range>((colorSpace & CM_RANGE_MASK) >> RANGE_OFFSET);
219     auto ret = SetColorSpaceInfo(buffer, colorSpaceInfo);
220     if (ret != GSERROR_OK) {
221         IMAGE_LOGE("SetColorSpaceInfo GetMetadata failed, return value is %{public}d", ret);
222         return false;
223     }
224     return true;
225 }
226 
GetSbColorSpaceType(const sptr<SurfaceBuffer> & buffer,CM_ColorSpaceType & colorSpaceType)227 bool VpeUtils::GetSbColorSpaceType(const sptr<SurfaceBuffer>& buffer, CM_ColorSpaceType& colorSpaceType)
228 {
229     CM_ColorSpaceInfo colorSpaceInfo;
230     if (!GetColorSpaceInfo(buffer, colorSpaceInfo)) {
231         return false;
232     }
233     uint32_t primaries = static_cast<uint32_t>(colorSpaceInfo.primaries);
234     uint32_t transfunc = static_cast<uint32_t>(colorSpaceInfo.transfunc);
235     uint32_t matrix = static_cast<uint32_t>(colorSpaceInfo.matrix);
236     uint32_t range = static_cast<uint32_t>(colorSpaceInfo.range);
237     colorSpaceType = static_cast<CM_ColorSpaceType>(primaries | (transfunc << TRANSFUNC_OFFSET) |
238         (matrix << MATRIX_OFFSET) | (range << RANGE_OFFSET));
239     return true;
240 }
241 
SetSbMetadataType(sptr<SurfaceBuffer> & buffer,const CM_HDR_Metadata_Type & metadataType)242 bool VpeUtils::SetSbMetadataType(sptr<SurfaceBuffer>& buffer, const CM_HDR_Metadata_Type& metadataType)
243 {
244     std::vector<uint8_t> hdrMetadataTypeVec;
245     auto ret = MetadataManager::ConvertMetadataToVec(metadataType, hdrMetadataTypeVec);
246     if (ret != GSERROR_OK) {
247         return false;
248     }
249     ret = buffer->SetMetadata(ATTRKEY_HDR_METADATA_TYPE, hdrMetadataTypeVec);
250     if (ret != GSERROR_OK) {
251         return false;
252     }
253     return true;
254 }
255 
GetSbMetadataType(const sptr<SurfaceBuffer> & buffer,CM_HDR_Metadata_Type & metadataType)256 bool VpeUtils::GetSbMetadataType(const sptr<SurfaceBuffer>& buffer, CM_HDR_Metadata_Type& metadataType)
257 {
258     std::vector<uint8_t> hdrMetadataTypeVec;
259     auto ret = buffer->GetMetadata(ATTRKEY_HDR_METADATA_TYPE, hdrMetadataTypeVec);
260     if (ret != GSERROR_OK) {
261         IMAGE_LOGE("HdrUtils::GetHDRMetadataType GetMetadata failed, return value is %{public}d", ret);
262         return false;
263     }
264     return MetadataManager::ConvertVecToMetadata(hdrMetadataTypeVec, metadataType) == GSERROR_OK;
265 }
266 
SetSbDynamicMetadata(sptr<SurfaceBuffer> & buffer,const std::vector<uint8_t> & dynamicMetadata)267 bool VpeUtils::SetSbDynamicMetadata(sptr<SurfaceBuffer>& buffer, const std::vector<uint8_t>& dynamicMetadata)
268 {
269     return buffer->SetMetadata(ATTRKEY_HDR_DYNAMIC_METADATA, dynamicMetadata) == GSERROR_OK;
270 }
271 
GetSbDynamicMetadata(const sptr<SurfaceBuffer> & buffer,std::vector<uint8_t> & dynamicMetadata)272 bool VpeUtils::GetSbDynamicMetadata(const sptr<SurfaceBuffer>& buffer, std::vector<uint8_t>& dynamicMetadata)
273 {
274     return buffer->GetMetadata(ATTRKEY_HDR_DYNAMIC_METADATA, dynamicMetadata) == GSERROR_OK;
275 }
276 
SetSbStaticMetadata(sptr<SurfaceBuffer> & buffer,const std::vector<uint8_t> & staticMetadata)277 bool VpeUtils::SetSbStaticMetadata(sptr<SurfaceBuffer>& buffer, const std::vector<uint8_t>& staticMetadata)
278 {
279     return buffer->SetMetadata(ATTRKEY_HDR_STATIC_METADATA, staticMetadata) == GSERROR_OK;
280 }
281 
GetSbStaticMetadata(const sptr<SurfaceBuffer> & buffer,std::vector<uint8_t> & staticMetadata)282 bool VpeUtils::GetSbStaticMetadata(const sptr<SurfaceBuffer>& buffer, std::vector<uint8_t>& staticMetadata)
283 {
284     return buffer->GetMetadata(ATTRKEY_HDR_STATIC_METADATA, staticMetadata) == GSERROR_OK;
285 }
286 
GetDefaultGainmapMetadata()287 static HDRVividExtendMetadata GetDefaultGainmapMetadata()
288 {
289     const float gainmapMax = 1.0f;
290     const float gainmapMin = 0.0f;
291     const float gamma = 1.0f;
292     const float offsetDenominator = 64.0;
293     const float baseOffset = 1.0 / offsetDenominator;
294     const float alternateOffset = 1.0 / offsetDenominator;
295     HDRVividExtendMetadata extendMetadata;
296     extendMetadata.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_ZERO] = gainmapMax;
297     extendMetadata.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_ONE] = gainmapMax;
298     extendMetadata.metaISO.enhanceClippedThreholdMaxGainmap[INDEX_TWO] = gainmapMax;
299     extendMetadata.metaISO.enhanceClippedThreholdMinGainmap[INDEX_ZERO] = gainmapMin;
300     extendMetadata.metaISO.enhanceClippedThreholdMinGainmap[INDEX_ONE] = gainmapMin;
301     extendMetadata.metaISO.enhanceClippedThreholdMinGainmap[INDEX_TWO] = gainmapMin;
302     extendMetadata.metaISO.enhanceMappingGamma[INDEX_ZERO] = gamma;
303     extendMetadata.metaISO.enhanceMappingGamma[INDEX_ONE] = gamma;
304     extendMetadata.metaISO.enhanceMappingGamma[INDEX_TWO] = gamma;
305     extendMetadata.metaISO.enhanceMappingBaselineOffset[INDEX_ZERO] = baseOffset;
306     extendMetadata.metaISO.enhanceMappingBaselineOffset[INDEX_ONE] = baseOffset;
307     extendMetadata.metaISO.enhanceMappingBaselineOffset[INDEX_TWO] = baseOffset;
308     extendMetadata.metaISO.enhanceMappingAlternateOffset[INDEX_ZERO] = alternateOffset;
309     extendMetadata.metaISO.enhanceMappingAlternateOffset[INDEX_ONE] = alternateOffset;
310     extendMetadata.metaISO.enhanceMappingAlternateOffset[INDEX_TWO] = alternateOffset;
311     extendMetadata.metaISO.gainmapChannelNum = 0x01;
312     extendMetadata.metaISO.useBaseColorFlag = 0x00;
313     extendMetadata.baseColorMeta.baseColorPrimary = COLORPRIMARIES_SRGB;
314     extendMetadata.gainmapColorMeta.combineColorPrimary = COLORPRIMARIES_BT2020;
315     extendMetadata.gainmapColorMeta.enhanceDataColorModel = COLORPRIMARIES_BT2020;
316     extendMetadata.gainmapColorMeta.alternateColorPrimary = COLORPRIMARIES_BT2020;
317     return extendMetadata;
318 }
319 
ConvertHdrType(ImageHdrType hdrType,bool isGainmap)320 static CM_HDR_Metadata_Type ConvertHdrType(ImageHdrType hdrType, bool isGainmap)
321 {
322     switch (hdrType) {
323         case ImageHdrType::HDR_VIVID_DUAL :
324         case ImageHdrType::HDR_CUVA :
325             return CM_IMAGE_HDR_VIVID_DUAL;
326         case ImageHdrType::HDR_ISO_DUAL :
327             return CM_IMAGE_HDR_ISO_DUAL;
328         default:
329             return CM_METADATA_NONE;
330     }
331     return CM_METADATA_NONE;
332 }
333 
SetSurfaceBufferInfo(sptr<SurfaceBuffer> & buffer,bool isGainmap,ImageHdrType type,CM_ColorSpaceType color,HdrMetadata & metadata)334 void VpeUtils::SetSurfaceBufferInfo(sptr<SurfaceBuffer>& buffer, bool isGainmap, ImageHdrType type,
335     CM_ColorSpaceType color, HdrMetadata& metadata)
336 {
337     CM_HDR_Metadata_Type cmHdrType = ConvertHdrType(type, isGainmap);
338     VpeUtils::SetSbMetadataType(buffer, cmHdrType);
339     VpeUtils::SetSbColorSpaceType(buffer, color);
340     if (type == ImageHdrType::HDR_CUVA) {
341         return;
342     }
343     if (!isGainmap) {
344         VpeUtils::SetSbDynamicMetadata(buffer, metadata.dynamicMetadata);
345         VpeUtils::SetSbStaticMetadata(buffer, metadata.staticMetadata);
346         return;
347     }
348     std::vector<uint8_t> extendMetadataVec(sizeof(HDRVividExtendMetadata));
349     int memCpyRes = 0;
350     if (metadata.extendMetaFlag) {
351         memCpyRes = memcpy_s(extendMetadataVec.data(), extendMetadataVec.size(),
352             &metadata.extendMeta, sizeof(HDRVividExtendMetadata));
353     } else {
354         HDRVividExtendMetadata defaultExtendMetadata = GetDefaultGainmapMetadata();
355         memCpyRes = memcpy_s(extendMetadataVec.data(), extendMetadataVec.size(),
356             &defaultExtendMetadata, sizeof(HDRVividExtendMetadata));
357     }
358     if (memCpyRes != EOK) {
359         IMAGE_LOGE("SetSurfaceBufferInfo failed, memcpy_s error:%{public}d", memCpyRes);
360         return;
361     }
362     VpeUtils::SetSbDynamicMetadata(buffer, extendMetadataVec);
363 }
364 
ColorSpaceConverterImageProcess(sptr<SurfaceBuffer> & input,sptr<SurfaceBuffer> & output)365 int32_t VpeUtils::ColorSpaceConverterImageProcess(sptr<SurfaceBuffer> &input, sptr<SurfaceBuffer> &output)
366 {
367     std::lock_guard<std::mutex> lock(vpeMtx_);
368     if (dlHandler_ == nullptr) {
369         return VPE_ERROR_FAILED;
370     }
371 
372     int32_t res;
373     int32_t instanceId = VPE_ERROR_FAILED;
374     res = ColorSpaceConverterCreate(dlHandler_, &instanceId);
375     if (instanceId == VPE_ERROR_FAILED || res != VPE_ERROR_OK) {
376         return VPE_ERROR_FAILED;
377     }
378 
379     HdrProcessImageT hdrProcessImage = (HdrProcessImageT)dlsym(dlHandler_, "ColorSpaceConverterProcessImage");
380     if (!hdrProcessImage) {
381         return VPE_ERROR_FAILED;
382     }
383     if (input == nullptr || output == nullptr) {
384         return VPE_ERROR_FAILED;
385     }
386     OHNativeWindowBuffer* sdr = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&input);
387     OHNativeWindowBuffer* hdr = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&output);
388     res = hdrProcessImage(instanceId, sdr, hdr);
389     OH_NativeWindow_DestroyNativeWindowBuffer(sdr);
390     OH_NativeWindow_DestroyNativeWindowBuffer(hdr);
391     ColorSpaceConverterDestory(dlHandler_, &instanceId);
392     return res;
393 }
394 
DetailEnhancerCreate(void * handle,int32_t * instanceId)395 int32_t VpeUtils::DetailEnhancerCreate(void* handle, int32_t* instanceId)
396 {
397     if (handle == nullptr) {
398         return VPE_ERROR_FAILED;
399     }
400     CreateT create = (CreateT)dlsym(handle, "DetailEnhancerCreate");
401     if (!create) {
402         return VPE_ERROR_FAILED;
403     }
404     return create(instanceId);
405 }
406 
DetailEnhancerDestory(void * handle,int32_t * instanceId)407 int32_t VpeUtils::DetailEnhancerDestory(void* handle, int32_t* instanceId)
408 {
409     if (*instanceId == VPE_ERROR_FAILED || handle == nullptr) {
410         return VPE_ERROR_FAILED;
411     }
412     DestoryT destory = (DestoryT)dlsym(handle, "DetailEnhancerDestroy");
413     if (!destory) {
414         return VPE_ERROR_FAILED;
415     }
416     return destory(instanceId);
417 }
418 
DetailEnhancerImageProcess(sptr<SurfaceBuffer> & input,sptr<SurfaceBuffer> & output,int32_t level)419 int32_t VpeUtils::DetailEnhancerImageProcess(sptr<SurfaceBuffer> &input, sptr<SurfaceBuffer> &output, int32_t level)
420 {
421     std::lock_guard<std::mutex> lock(vpeMtx_);
422     if (dlHandler_ == nullptr) {
423         return VPE_ERROR_FAILED;
424     }
425 
426     int32_t res;
427     int32_t instanceId = VPE_ERROR_FAILED;
428     res = DetailEnhancerCreate(dlHandler_, &instanceId);
429     if (instanceId == VPE_ERROR_FAILED || res != VPE_ERROR_OK) {
430         return VPE_ERROR_FAILED;
431     }
432 
433     SrProcessImageT srProcessImage = (SrProcessImageT)dlsym(dlHandler_, "DetailEnhancerProcessImage");
434     if (!srProcessImage) {
435         return VPE_ERROR_FAILED;
436     }
437     if (input == nullptr || output == nullptr) {
438         return VPE_ERROR_FAILED;
439     }
440     OHNativeWindowBuffer* inBuffer = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&input);
441     OHNativeWindowBuffer* outBuffer = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(&output);
442     res = srProcessImage(instanceId, inBuffer, outBuffer, level);
443     OH_NativeWindow_DestroyNativeWindowBuffer(inBuffer);
444     OH_NativeWindow_DestroyNativeWindowBuffer(outBuffer);
445     DetailEnhancerDestory(dlHandler_, &instanceId);
446     return res;
447 }
448 
SetSbColorSpaceDefault(sptr<SurfaceBuffer> & buffer)449 bool VpeUtils::SetSbColorSpaceDefault(sptr<SurfaceBuffer>& buffer)
450 {
451     constexpr CM_ColorSpaceInfo outputColorSpaceInfo = {
452         COLORPRIMARIES_BT2020, TRANSFUNC_HLG, MATRIX_BT2020, RANGE_FULL
453     };
454     auto ret = SetColorSpaceInfo(buffer, outputColorSpaceInfo);
455     if (ret != GSERROR_OK) {
456         IMAGE_LOGE("SetSbColorSpaceDefault GetMetadata failed, return value is %{public}d", ret);
457         return false;
458     }
459     return true;
460 }
461 
SetSurfaceBufferInfo(sptr<SurfaceBuffer> & buffer,CM_ColorSpaceType color)462 void VpeUtils::SetSurfaceBufferInfo(sptr<SurfaceBuffer>& buffer, CM_ColorSpaceType color)
463 {
464     VpeUtils::SetSbColorSpaceType(buffer, color);
465 }
466 
CopySurfaceBufferInfo(sptr<SurfaceBuffer> & source,sptr<SurfaceBuffer> & dst)467 void VpeUtils::CopySurfaceBufferInfo(sptr<SurfaceBuffer>& source, sptr<SurfaceBuffer>& dst)
468 {
469     if (source == nullptr || dst == nullptr) {
470         IMAGE_LOGI("VpeUtils CopySurfaceBufferInfo failed, source or dst is nullptr");
471         return;
472     }
473     std::vector<uint8_t> hdrMetadataTypeVec;
474     std::vector<uint8_t> colorSpaceInfoVec;
475     std::vector<uint8_t> staticData;
476     std::vector<uint8_t> dynamicData;
477 
478     if (source->GetMetadata(ATTRKEY_HDR_METADATA_TYPE, hdrMetadataTypeVec) == GSERROR_OK) {
479         dst->SetMetadata(ATTRKEY_HDR_METADATA_TYPE, hdrMetadataTypeVec);
480     }
481     if (source->GetMetadata(ATTRKEY_COLORSPACE_INFO, colorSpaceInfoVec) == GSERROR_OK) {
482         dst->SetMetadata(ATTRKEY_COLORSPACE_INFO, colorSpaceInfoVec);
483     }
484     if (GetSbStaticMetadata(source, staticData) && (staticData.size() > 0)) {
485         SetSbStaticMetadata(dst, staticData);
486     }
487     if (GetSbDynamicMetadata(source, dynamicData) && (dynamicData.size()) > 0) {
488         SetSbDynamicMetadata(dst, dynamicData);
489     }
490 }
491 #endif
492 }
493 }