diff --git a/frameworks/kits/js/common/pixel_map_napi.cpp b/frameworks/kits/js/common/pixel_map_napi.cpp index 2689456884fe39ed5fdeb1d049530fe8e50374fc..6c695c8656bc3536c2508f2156beaa70c6d43aa7 100644 --- a/frameworks/kits/js/common/pixel_map_napi.cpp +++ b/frameworks/kits/js/common/pixel_map_napi.cpp @@ -1792,6 +1792,23 @@ napi_value PixelMapNapi::CreatePixelMap(napi_env env, std::shared_ptr return result; } +extern "C" { +napi_value GetPixelMapNapi(napi_env env, std::shared_ptr pixelMap) +{ + return PixelMapNapi::CreatePixelMap(env, pixelMap); +} + +bool GetNativePixelMap(void* pixelMapNapi, std::shared_ptr &pixelMap) +{ + if (pixelMapNapi == nullptr) { + IMAGE_LOGE("%{public}s pixelMapNapi is nullptr", __func__); + return false; + } + pixelMap = reinterpret_cast(pixelMapNapi)->GetPixelNapiInner(); + return true; +} +} + STATIC_EXEC_FUNC(Unmarshalling) { #if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM) diff --git a/frameworks/kits/taihe/BUILD.gn b/frameworks/kits/taihe/BUILD.gn index f2ac4792ddca7656999f65c49afdf0a4cd94f9ef..38a96059fd0a46b84db5e6d5188a5724cefd362d 100644 --- a/frameworks/kits/taihe/BUILD.gn +++ b/frameworks/kits/taihe/BUILD.gn @@ -69,18 +69,18 @@ template("image_taihe_shared_library") { sources = get_target_outputs(":run_taihe") sources += [ - "src/auxiliary_picture_taihe.cpp", - "src/image_creator_taihe.cpp", - "src/image_packer_taihe.cpp", - "src/image_receiver_taihe.cpp", - "src/image_source_taihe.cpp", - "src/image_taihe.cpp", - "src/image_taihe_utils.cpp", - "src/metadata_taihe.cpp", - "src/picture_taihe.cpp", - "src/pixel_map_taihe.cpp", - "${image_subsystem}/frameworks/innerkitsimpl/accessor/src/exif_metadata_formatter.cpp", - ] + extra_sources + "${image_subsystem}/frameworks/innerkitsimpl/accessor/src/exif_metadata_formatter.cpp", + "src/auxiliary_picture_taihe.cpp", + "src/image_creator_taihe.cpp", + "src/image_packer_taihe.cpp", + "src/image_receiver_taihe.cpp", + "src/image_source_taihe.cpp", + "src/image_taihe.cpp", + "src/image_taihe_utils.cpp", + "src/metadata_taihe.cpp", + "src/picture_taihe.cpp", + "src/pixel_map_taihe.cpp", + ] + extra_sources deps = [ ":run_taihe", @@ -94,14 +94,15 @@ template("image_taihe_shared_library") { "eventhandler:libeventhandler", "graphic_2d:ani_color_space_object_convertor", "graphic_2d:color_manager", - "graphic_2d:EGL", "graphic_2d:librender_service_base", "graphic_2d:librender_service_client", "graphic_surface:surface", "graphic_surface:sync_fence", "hilog:libhilog", "hitrace:hitrace_meter", - "ipc:rpc_ani", + "ipc:ipc_single", + "libjpeg-turbo:turbojpeg", + "napi:ace_napi", "runtime_core:ani_helpers", "skia:libjpeg", ] diff --git a/frameworks/kits/taihe/idl/ohos.multimedia.image.image.taihe b/frameworks/kits/taihe/idl/ohos.multimedia.image.image.taihe index a98595f9a6b15ce9a374439efbd8f73421f74b02..f65bc58dd7b5126b2df5182f5243c20baeefa2dd 100644 --- a/frameworks/kits/taihe/idl/ohos.multimedia.image.image.taihe +++ b/frameworks/kits/taihe/idl/ohos.multimedia.image.image.taihe @@ -873,6 +873,80 @@ interface ImageCreator { ReleaseSync(): void; } +// transfer functions +function ImageSourceTransferStaticImpl(input: @sts_type("ESValue") Opaque): ImageSource; +function ImageSourceTransferDynamicImpl(input: ImageSource): @sts_type("Any") Opaque; + +function ImagePackerTransferStaticImpl(input: @sts_type("ESValue") Opaque): ImagePacker; +function ImagePackerTransferDynamicImpl(input: ImagePacker): @sts_type("Any") Opaque; + +function PictureTransferStaticImpl(input: @sts_type("ESValue") Opaque): Picture; +function PictureTransferDynamicImpl(input: Picture): @sts_type("Any") Opaque; + +function AuxiliaryPictureTransferStaticImpl(input: @sts_type("ESValue") Opaque): AuxiliaryPicture; +function AuxiliaryPictureTransferDynamicImpl(input: AuxiliaryPicture): @sts_type("Any") Opaque; + +function ImageReceiverTransferStaticImpl(input: @sts_type("ESValue") Opaque): ImageReceiver; +function ImageReceiverTransferDynamicImpl(input: ImageReceiver): @sts_type("Any") Opaque; + +function ImageCreatorTransferStaticImpl(input: @sts_type("ESValue") Opaque): ImageCreator; +function ImageCreatorTransferDynamicImpl(input: ImageCreator): @sts_type("Any") Opaque; + +function PixelMapTransferStaticImpl(input: @sts_type("ESValue") Opaque): PixelMap; +function PixelMapTransferDynamicImpl(input: PixelMap): @sts_type("Any") Opaque; + +@!sts_inject(""" +export function imageSourceTransferStatic(input: Any): Object { + return imageSourceTransferStaticImpl(ESValue.wrap(input)); +} +export function imageSourceTransferDynamic(input: Object): Any { + return imageSourceTransferDynamicImpl(input as ImageSource); +} + +export function imagePackerTransferStatic(input: Any): Object { + return imagePackerTransferStaticImpl(ESValue.wrap(input)); +} +export function imagePackerTransferDynamic(input: Object): Any { + return imagePackerTransferDynamicImpl(input as ImagePacker); +} + +export function pictureTransferStatic(input: Any): Object { + return pictureTransferStaticImpl(ESValue.wrap(input)); +} +export function pictureTransferDynamic(input: Object): Any { + return pictureTransferDynamicImpl(input as Picture); +} + +export function auxiliaryPictureTransferStatic(input: Any): Object { + return auxiliaryPictureTransferStaticImpl(ESValue.wrap(input)); +} +export function auxiliaryPictureTransferDynamic(input: Object): Any { + return auxiliaryPictureTransferDynamicImpl(input as AuxiliaryPicture); +} + +export function imageReceiverTransferStatic(input: Any): Object { + return imageReceiverTransferStaticImpl(ESValue.wrap(input)); +} +export function imageReceiverTransferDynamic(input: Object): Any { + return imageReceiverTransferDynamicImpl(input as ImageReceiver); +} + +export function imageCreatorTransferStatic(input: Any): Object { + return imageCreatorTransferStaticImpl(ESValue.wrap(input)); +} +export function imageCreatorTransferDynamic(input: Object): Any { + return imageCreatorTransferDynamicImpl(input as ImageCreator); +} + +export function pixelMapTransferStatic(input: Any): Object { + return pixelMapTransferStaticImpl(ESValue.wrap(input)); +} +export function pixelMapTransferDynamic(input: Object): Any { + return pixelMapTransferDynamicImpl(input as PixelMap); +} +""") + +// global functions function MakeEmptySize(): Size; function MakeEmptyImageInfo(): ImageInfo; diff --git a/frameworks/kits/taihe/include/transfer_taihe.h b/frameworks/kits/taihe/include/transfer_taihe.h new file mode 100644 index 0000000000000000000000000000000000000000..83e6b660ecf8feb90878b958fcd2fa2a38ec7e3b --- /dev/null +++ b/frameworks/kits/taihe/include/transfer_taihe.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FRAMEWORKS_KITS_TAIHE_INCLUDE_TRANSFER_TAIHE_H +#define FRAMEWORKS_KITS_TAIHE_INCLUDE_TRANSFER_TAIHE_H + +#include "ohos.multimedia.image.image.proj.hpp" +#include "ohos.multimedia.image.image.impl.hpp" +#include "taihe/runtime.hpp" + +namespace ANI::Image { +using namespace taihe; +using namespace ohos::multimedia::image::image; + +void* GetNapiFunction(const char* name); + +ImageSource ImageSourceTransferStaticImpl(uintptr_t input); +uintptr_t ImageSourceTransferDynamicImpl(ImageSource input); + +ImagePacker ImagePackerTransferStaticImpl(uintptr_t input); +uintptr_t ImagePackerTransferDynamicImpl(ImagePacker input); + +Picture PictureTransferStaticImpl(uintptr_t input); +uintptr_t PictureTransferDynamicImpl(Picture input); + +AuxiliaryPicture AuxiliaryPictureTransferStaticImpl(uintptr_t input); +uintptr_t AuxiliaryPictureTransferDynamicImpl(AuxiliaryPicture input); + +ImageReceiver ImageReceiverTransferStaticImpl(uintptr_t input); +uintptr_t ImageReceiverTransferDynamicImpl(ImageReceiver input); + +ImageCreator ImageCreatorTransferStaticImpl(uintptr_t input); +uintptr_t ImageCreatorTransferDynamicImpl(ImageCreator input); + +PixelMap PixelMapTransferStaticImpl(uintptr_t input); +uintptr_t PixelMapTransferDynamicImpl(weak::PixelMap input); +} // namespace ANI::Image + +#endif // FRAMEWORKS_KITS_TAIHE_INCLUDE_TRANSFER_TAIHE_H \ No newline at end of file diff --git a/frameworks/kits/taihe/src/pixel_map_taihe.cpp b/frameworks/kits/taihe/src/pixel_map_taihe.cpp index 8152ad67ba1c63d45d6af324cd85ef494e11c189..e38fa568ffacb2e6e2c40a297e15517c82e4132d 100644 --- a/frameworks/kits/taihe/src/pixel_map_taihe.cpp +++ b/frameworks/kits/taihe/src/pixel_map_taihe.cpp @@ -234,7 +234,7 @@ PixelMapImpl::~PixelMapImpl() int64_t PixelMapImpl::GetImplPtr() { - return reinterpret_cast(this); + return static_cast(reinterpret_cast(this)); } std::shared_ptr PixelMapImpl::GetNativePtr() diff --git a/frameworks/kits/taihe/src/transfer_taihe.cpp b/frameworks/kits/taihe/src/transfer_taihe.cpp new file mode 100644 index 0000000000000000000000000000000000000000..556084d2a1bd75aa73d67770da16e469a4537594 --- /dev/null +++ b/frameworks/kits/taihe/src/transfer_taihe.cpp @@ -0,0 +1,562 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "auxiliary_picture_taihe.h" +#include "image_creator_taihe.h" +#include "image_log.h" +#include "image_packer_taihe.h" +#include "image_receiver_taihe.h" +#include "image_source_taihe.h" +#include "interop_js/arkts_esvalue.h" +#include "interop_js/arkts_interop_js_api.h" +#include "picture_taihe.h" +#include "pixel_map_taihe.h" +#include "transfer_taihe.h" + +using namespace ANI::Image; + +namespace { +const std::string LIB_IMAGE_NAPI_SO = "libimage_napi.z.so"; + +// function pointer type for napi functions +using GetImageSourceNapiFn = napi_value (*)(napi_env, std::shared_ptr); +using GetImagePackerNapiFn = napi_value (*)(napi_env, std::shared_ptr); +using GetPictureNapiFn = napi_value (*)(napi_env, std::shared_ptr); +using GetAuxiliaryPictureNapiFn = napi_value (*)(napi_env, std::shared_ptr); +using GetImageReceiverNapiFn = napi_value (*)(napi_env, std::shared_ptr); +using GetImageCreatorNapiFn = napi_value (*)(napi_env, std::shared_ptr); +using GetPixelMapNapiFn = napi_value (*)(napi_env, std::shared_ptr); + +using GetNativeImageSourceFn = bool (*)(void*, std::shared_ptr&); +using GetNativeImagePackerFn = bool (*)(void*, std::shared_ptr&); +using GetNativePictureFn = bool (*)(void*, std::shared_ptr&); +using GetNativeAuxiliaryPictureFn = bool (*)(void*, std::shared_ptr&); +using GetNativeImageReceiverFn = bool (*)(void*, std::shared_ptr&); +using GetNativeImageCreatorFn = bool (*)(void*, std::shared_ptr&); +using GetNativePixelMapFn = bool (*)(void*, std::shared_ptr&); + +// custom deleter for handle to auto dlclose +struct DlHandleDeleter { + void operator()(void* handle) const + { + if (handle) { + dlclose(handle); + } + } +}; +using UniqueDlHandle = std::unique_ptr; +} + +namespace ANI::Image { + +void* GetNapiFunction(const char* name) +{ + static std::once_flag flag; + static UniqueDlHandle handle(nullptr); + std::call_once(flag, [&]() { + void* newHandle = dlopen(LIB_IMAGE_NAPI_SO.c_str(), RTLD_LAZY | RTLD_LOCAL); + if (!newHandle) { + IMAGE_LOGE("%{public}s dlopen failed, path: %{public}s, error: %{public}s", __func__, + LIB_IMAGE_NAPI_SO.c_str(), dlerror()); + return; + } + handle.reset(newHandle); + }); + + if (!handle) { + IMAGE_LOGE("%{public}s handle is nullptr, please make sure %{public}s is loaded", __func__, + LIB_IMAGE_NAPI_SO.c_str()); + return nullptr; + } + + void* symbol = dlsym(handle.get(), name); + if (!symbol) { + IMAGE_LOGE("%{public}s dlsym failed, name: %{public}s, error: %{public}s", __func__, name, dlerror()); + return nullptr; + } + IMAGE_LOGI("%{public}s dlsym success, name: %{public}s, symbol: %{public}p", __func__, name, symbol); + return symbol; +} + +ImageSource ImageSourceTransferStaticImpl(uintptr_t input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + ani_object esValue = reinterpret_cast(input); + void *nativePtr = nullptr; + if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) { + IMAGE_LOGE("%{public}s unwrap esValue failed", __func__); + return make_holder(); + } + + void* napiFunc = GetNapiFunction("GetNativeImageSource"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + return make_holder(); + } + + std::shared_ptr nativeImageSource = nullptr; + bool ret = (*reinterpret_cast(napiFunc))(nativePtr, nativeImageSource); + if (!ret || nativeImageSource == nullptr) { + IMAGE_LOGE("%{public}s GetNativeImageSource failed", __func__); + return make_holder(); + } + IMAGE_LOGD("[%{public}s] OUT", __func__); + return make_holder(nativeImageSource); +} + +uintptr_t ImageSourceTransferDynamicImpl(ImageSource input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + if (input.is_error()) { + IMAGE_LOGE("%{public}s input is error", __func__); + return 0; + } + ImageSourceImpl* thisPtr = reinterpret_cast(input->GetImplPtr()); + if (thisPtr == nullptr) { + IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__); + return 0; + } + + napi_env jsEnv; + if (!arkts_napi_scope_open(get_env(), &jsEnv)) { + IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__); + return 0; + } + + void* napiFunc = GetNapiFunction("GetImageSourceNapi"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value result = (*reinterpret_cast(napiFunc))(jsEnv, thisPtr->nativeImgSrc); + if (result == nullptr) { + IMAGE_LOGE("%{public}s GetImageSourceNapi failed, result is nullptr", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t ref = 0; + arkts_napi_scope_close_n(jsEnv, 1, &result, reinterpret_cast(&ref)); + IMAGE_LOGD("[%{public}s] OUT", __func__); + return ref; +} + +ImagePacker ImagePackerTransferStaticImpl(uintptr_t input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + ani_object esValue = reinterpret_cast(input); + void *nativePtr = nullptr; + if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) { + IMAGE_LOGE("%{public}s unwrap esValue failed", __func__); + return make_holder(); + } + + void* napiFunc = GetNapiFunction("GetNativeImagePacker"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + return make_holder(); + } + + std::shared_ptr nativeImagePacker = nullptr; + bool ret = (*reinterpret_cast(napiFunc))(nativePtr, nativeImagePacker); + if (!ret || nativeImagePacker == nullptr) { + IMAGE_LOGE("%{public}s GetNativeImagePacker failed", __func__); + return make_holder(); + } + IMAGE_LOGD("[%{public}s] OUT", __func__); + return make_holder(nativeImagePacker); +} + +uintptr_t ImagePackerTransferDynamicImpl(ImagePacker input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + if (input.is_error()) { + IMAGE_LOGE("%{public}s input is error", __func__); + return 0; + } + ImagePackerImpl* thisPtr = reinterpret_cast(input->GetImplPtr()); + if (thisPtr == nullptr) { + IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__); + return 0; + } + + napi_env jsEnv; + if (!arkts_napi_scope_open(get_env(), &jsEnv)) { + IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__); + return 0; + } + + void* napiFunc = GetNapiFunction("GetImagePackerNapi"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value result = (*reinterpret_cast(napiFunc))(jsEnv, thisPtr->GetNativeImagePacker()); + if (result == nullptr) { + IMAGE_LOGE("%{public}s GetImagePackerNapi failed, result is nullptr", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t ref = 0; + arkts_napi_scope_close_n(jsEnv, 1, &result, reinterpret_cast(&ref)); + IMAGE_LOGD("[%{public}s] OUT", __func__); + return ref; +} + +Picture PictureTransferStaticImpl(uintptr_t input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + ani_object esValue = reinterpret_cast(input); + void *nativePtr = nullptr; + if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) { + IMAGE_LOGE("%{public}s unwrap esValue failed", __func__); + return make_holder(); + } + + void* napiFunc = GetNapiFunction("GetNativePicture"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + return make_holder(); + } + + std::shared_ptr nativePicture = nullptr; + bool ret = (*reinterpret_cast(napiFunc))(nativePtr, nativePicture); + if (!ret || nativePicture == nullptr) { + IMAGE_LOGE("%{public}s GetNativePicture failed", __func__); + return make_holder(); + } + IMAGE_LOGD("[%{public}s] OUT", __func__); + return make_holder(nativePicture); +} + +uintptr_t PictureTransferDynamicImpl(Picture input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + if (input.is_error()) { + IMAGE_LOGE("%{public}s input is error", __func__); + return 0; + } + PictureImpl* thisPtr = reinterpret_cast(input->GetImplPtr()); + if (thisPtr == nullptr) { + IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__); + return 0; + } + + napi_env jsEnv; + if (!arkts_napi_scope_open(get_env(), &jsEnv)) { + IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__); + return 0; + } + + void* napiFunc = GetNapiFunction("GetPictureNapi"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + std::shared_ptr nativePicture = thisPtr->GetNativePtr(); + napi_value result = (*reinterpret_cast(napiFunc))(jsEnv, nativePicture); + if (result == nullptr) { + IMAGE_LOGE("%{public}s GetPictureNapi failed, result is nullptr", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t ref = 0; + arkts_napi_scope_close_n(jsEnv, 1, &result, reinterpret_cast(&ref)); + IMAGE_LOGD("[%{public}s] OUT", __func__); + return ref; +} + +AuxiliaryPicture AuxiliaryPictureTransferStaticImpl(uintptr_t input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + ani_object esValue = reinterpret_cast(input); + void *nativePtr = nullptr; + if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) { + IMAGE_LOGE("%{public}s unwrap esValue failed", __func__); + return make_holder(); + } + + void* napiFunc = GetNapiFunction("GetNativeAuxiliaryPicture"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + return make_holder(); + } + + std::shared_ptr nativeAuxiliaryPicture = nullptr; + bool ret = (*reinterpret_cast(napiFunc))(nativePtr, nativeAuxiliaryPicture); + if (!ret || nativeAuxiliaryPicture == nullptr) { + IMAGE_LOGE("%{public}s GetNativeAuxiliaryPicture failed", __func__); + return make_holder(); + } + IMAGE_LOGD("[%{public}s] OUT", __func__); + return make_holder(nativeAuxiliaryPicture); +} + +uintptr_t AuxiliaryPictureTransferDynamicImpl(AuxiliaryPicture input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + if (input.is_error()) { + IMAGE_LOGE("%{public}s input is error", __func__); + return 0; + } + AuxiliaryPictureImpl* thisPtr = reinterpret_cast(input->GetImplPtr()); + if (thisPtr == nullptr) { + IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__); + return 0; + } + + napi_env jsEnv; + if (!arkts_napi_scope_open(get_env(), &jsEnv)) { + IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__); + return 0; + } + + void* napiFunc = GetNapiFunction("GetAuxiliaryPictureNapi"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value result = (*reinterpret_cast(napiFunc))(jsEnv, + thisPtr->GetNativeAuxiliaryPic()); + if (result == nullptr) { + IMAGE_LOGE("%{public}s GetAuxiliaryPictureNapi failed, result is nullptr", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t ref = 0; + arkts_napi_scope_close_n(jsEnv, 1, &result, reinterpret_cast(&ref)); + IMAGE_LOGD("[%{public}s] OUT", __func__); + return ref; +} + +ImageReceiver ImageReceiverTransferStaticImpl(uintptr_t input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + ani_object esValue = reinterpret_cast(input); + void *nativePtr = nullptr; + if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) { + IMAGE_LOGE("%{public}s unwrap esValue failed", __func__); + return make_holder(); + } + + void* napiFunc = GetNapiFunction("GetNativeImageReceiver"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + return make_holder(); + } + + std::shared_ptr nativeImageReceiver = nullptr; + bool ret = (*reinterpret_cast(napiFunc))(nativePtr, nativeImageReceiver); + if (!ret || nativeImageReceiver == nullptr) { + IMAGE_LOGE("%{public}s GetNativeImageReceiver failed", __func__); + return make_holder(); + } + IMAGE_LOGD("[%{public}s] OUT", __func__); + return make_holder(nativeImageReceiver); +} + +uintptr_t ImageReceiverTransferDynamicImpl(ImageReceiver input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + if (input.is_error()) { + IMAGE_LOGE("%{public}s input is error", __func__); + return 0; + } + ImageReceiverImpl* thisPtr = reinterpret_cast(input->GetImplPtr()); + if (thisPtr == nullptr) { + IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__); + return 0; + } + + napi_env jsEnv; + if (!arkts_napi_scope_open(get_env(), &jsEnv)) { + IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__); + return 0; + } + + void* napiFunc = GetNapiFunction("GetImageReceiverNapi"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value result = (*reinterpret_cast(napiFunc))(jsEnv, + thisPtr->GetNativeImageReceiver()); + if (result == nullptr) { + IMAGE_LOGE("%{public}s GetImageReceiverNapi failed, result is nullptr", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t ref = 0; + arkts_napi_scope_close_n(jsEnv, 1, &result, reinterpret_cast(&ref)); + IMAGE_LOGD("[%{public}s] OUT", __func__); + return ref; +} + +ImageCreator ImageCreatorTransferStaticImpl(uintptr_t input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + ani_object esValue = reinterpret_cast(input); + void *nativePtr = nullptr; + if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) { + IMAGE_LOGE("%{public}s unwrap esValue failed", __func__); + return make_holder(); + } + + void* napiFunc = GetNapiFunction("GetNativeImageCreator"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + return make_holder(); + } + + std::shared_ptr nativeImageCreator = nullptr; + bool ret = (*reinterpret_cast(napiFunc))(nativePtr, nativeImageCreator); + if (!ret || nativeImageCreator == nullptr) { + IMAGE_LOGE("%{public}s GetNativeImageCreator failed", __func__); + return make_holder(); + } + IMAGE_LOGD("[%{public}s] OUT", __func__); + return make_holder(nativeImageCreator); +} + +uintptr_t ImageCreatorTransferDynamicImpl(ImageCreator input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + if (input.is_error()) { + IMAGE_LOGE("%{public}s input is error", __func__); + return 0; + } + ImageCreatorImpl* thisPtr = reinterpret_cast(input->GetImplPtr()); + if (thisPtr == nullptr) { + IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__); + return 0; + } + + napi_env jsEnv; + if (!arkts_napi_scope_open(get_env(), &jsEnv)) { + IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__); + return 0; + } + + void* napiFunc = GetNapiFunction("GetImageCreatorNapi"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value result = (*reinterpret_cast(napiFunc))(jsEnv, thisPtr->GetNativeImageCreator()); + if (result == nullptr) { + IMAGE_LOGE("%{public}s GetImageCreatorNapi failed, result is nullptr", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t ref = 0; + arkts_napi_scope_close_n(jsEnv, 1, &result, reinterpret_cast(&ref)); + IMAGE_LOGD("[%{public}s] OUT", __func__); + return ref; +} + +PixelMap PixelMapTransferStaticImpl(uintptr_t input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + ani_object esValue = reinterpret_cast(input); + + void* nativePtr = nullptr; + if (!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr) { + IMAGE_LOGE("%{public}s unwrap esValue failed", __func__); + return make_holder(); + } + + void* napiFunc = GetNapiFunction("GetNativePixelMap"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + return make_holder(); + } + + std::shared_ptr nativePixelMap = nullptr; + bool ret = (*reinterpret_cast(napiFunc))(nativePtr, nativePixelMap); + if (!ret || nativePixelMap == nullptr) { + IMAGE_LOGE("%{public}s GetNativePixelMap failed", __func__); + return make_holder(); + } + IMAGE_LOGD("[%{public}s] OUT", __func__); + return make_holder(nativePixelMap); +} + +uintptr_t PixelMapTransferDynamicImpl(weak::PixelMap input) +{ + IMAGE_LOGD("[%{public}s] IN", __func__); + if (input.is_error()) { + IMAGE_LOGE("%{public}s input is error", __func__); + return 0; + } + PixelMapImpl* thisPtr = reinterpret_cast(input->GetImplPtr()); + if (thisPtr == nullptr) { + IMAGE_LOGE("%{public}s thisPtr is nullptr", __func__); + return 0; + } + + napi_env jsEnv; + if (!arkts_napi_scope_open(get_env(), &jsEnv)) { + IMAGE_LOGE("%{public}s arkts_napi_scope_open failed", __func__); + return 0; + } + + void* napiFunc = GetNapiFunction("GetPixelMapNapi"); + if (napiFunc == nullptr) { + IMAGE_LOGE("%{public}s GetNapiFunction failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value result = (*reinterpret_cast(napiFunc))(jsEnv, thisPtr->GetNativePtr()); + if (result == nullptr) { + IMAGE_LOGE("%{public}s GetPixelMapNapi failed, result is nullptr", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t ref = 0; + arkts_napi_scope_close_n(jsEnv, 1, &result, reinterpret_cast(&ref)); + IMAGE_LOGD("[%{public}s] OUT", __func__); + return ref; +} +} // namespace ANI::Image + +TH_EXPORT_CPP_API_ImageSourceTransferStaticImpl(ImageSourceTransferStaticImpl); +TH_EXPORT_CPP_API_ImageSourceTransferDynamicImpl(ImageSourceTransferDynamicImpl); +TH_EXPORT_CPP_API_ImagePackerTransferStaticImpl(ImagePackerTransferStaticImpl); +TH_EXPORT_CPP_API_ImagePackerTransferDynamicImpl(ImagePackerTransferDynamicImpl); +TH_EXPORT_CPP_API_PictureTransferStaticImpl(PictureTransferStaticImpl); +TH_EXPORT_CPP_API_PictureTransferDynamicImpl(PictureTransferDynamicImpl); +TH_EXPORT_CPP_API_AuxiliaryPictureTransferStaticImpl(AuxiliaryPictureTransferStaticImpl); +TH_EXPORT_CPP_API_AuxiliaryPictureTransferDynamicImpl(AuxiliaryPictureTransferDynamicImpl); +TH_EXPORT_CPP_API_ImageReceiverTransferStaticImpl(ImageReceiverTransferStaticImpl); +TH_EXPORT_CPP_API_ImageReceiverTransferDynamicImpl(ImageReceiverTransferDynamicImpl); +TH_EXPORT_CPP_API_ImageCreatorTransferStaticImpl(ImageCreatorTransferStaticImpl); +TH_EXPORT_CPP_API_ImageCreatorTransferDynamicImpl(ImageCreatorTransferDynamicImpl); +TH_EXPORT_CPP_API_PixelMapTransferStaticImpl(PixelMapTransferStaticImpl); +TH_EXPORT_CPP_API_PixelMapTransferDynamicImpl(PixelMapTransferDynamicImpl); \ No newline at end of file diff --git a/interfaces/kits/js/common/include/pixel_map_napi.h b/interfaces/kits/js/common/include/pixel_map_napi.h index f7088dd13fddbb33de57c95055459ae0b3d4a720..a93e55fb0a09da29403bd943a756f924f3fe1fb9 100644 --- a/interfaces/kits/js/common/include/pixel_map_napi.h +++ b/interfaces/kits/js/common/include/pixel_map_napi.h @@ -229,6 +229,11 @@ private: std::shared_mutex mutex_; std::map> map_; }; + +extern "C" { + napi_value GetPixelMapNapi(napi_env env, std::shared_ptr pixelMap); + bool GetNativePixelMap(void* pixelMapNapi, std::shared_ptr &pixelMap); +} } // namespace Media } // namespace OHOS #endif // INTERFACES_KITS_JS_COMMON_INCLUDE_PIXEL_MAP_NAPI_H