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