From d2beb007f04f87fe3a8dc6c09ff119988c3d9a69 Mon Sep 17 00:00:00 2001 From: yanghongliang Date: Tue, 2 Nov 2021 16:09:41 +0800 Subject: [PATCH] add camera Signed-off-by: yanghongliang --- hardware/display/BUILD.gn | 16 +- rk3568/camera/BUILD.gn | 111 ++++++++++ .../camera/camera_demo/project_camera_demo.h | 32 +++ rk3568/camera/include/device_manager/imx600.h | 37 ++++ .../include/device_manager/project_hardware.h | 29 +++ .../camera/include/device_manager/rkispv5.h | 39 ++++ rk3568/camera/product.gni | 27 +++ rk3568/camera/src/device_manager/BUILD.gn | 91 +++++++++ rk3568/camera/src/device_manager/imx600.cpp | 84 ++++++++ rk3568/camera/src/device_manager/rkispv5.cpp | 72 +++++++ .../main_test/project_v4l2_main.h | 27 +++ .../camera/src/driver_adapter/test/BUILD.gn | 80 ++++++++ .../test/unittest/include/utest_v4l2.h | 42 ++++ .../test/unittest/utest_v4l2.cpp | 190 ++++++++++++++++++ rk3568/camera/src/pipeline_core/BUILD.gn | 171 ++++++++++++++++ .../ipp_algo_example/ipp_algo_example.c | 96 +++++++++ 16 files changed, 1136 insertions(+), 8 deletions(-) create mode 100755 rk3568/camera/BUILD.gn create mode 100644 rk3568/camera/camera_demo/project_camera_demo.h create mode 100644 rk3568/camera/include/device_manager/imx600.h create mode 100644 rk3568/camera/include/device_manager/project_hardware.h create mode 100644 rk3568/camera/include/device_manager/rkispv5.h create mode 100755 rk3568/camera/product.gni create mode 100755 rk3568/camera/src/device_manager/BUILD.gn create mode 100644 rk3568/camera/src/device_manager/imx600.cpp create mode 100644 rk3568/camera/src/device_manager/rkispv5.cpp create mode 100644 rk3568/camera/src/driver_adapter/main_test/project_v4l2_main.h create mode 100755 rk3568/camera/src/driver_adapter/test/BUILD.gn create mode 100644 rk3568/camera/src/driver_adapter/test/unittest/include/utest_v4l2.h create mode 100644 rk3568/camera/src/driver_adapter/test/unittest/utest_v4l2.cpp create mode 100755 rk3568/camera/src/pipeline_core/BUILD.gn create mode 100644 rk3568/camera/src/pipeline_core/ipp_algo_example/ipp_algo_example.c diff --git a/hardware/display/BUILD.gn b/hardware/display/BUILD.gn index 052169d..41fc1dd 100755 --- a/hardware/display/BUILD.gn +++ b/hardware/display/BUILD.gn @@ -62,12 +62,12 @@ ohos_prebuilt_shared_library("display_device") { # output_name = "display_device_drm.z" } -#ohos_prebuilt_shared_library("display_layer") { -# if (target_cpu == "arm") { -# source = "lib/libdisplay_layer.z.so" -# } -# subsystem_name = "hdf" -# part_name = "hdf" -# install_enable = true +ohos_prebuilt_shared_library("display_layer") { + if (target_cpu == "arm") { + source = "lib/libdisplay_layer.z.so" + } + subsystem_name = "hdf" + part_name = "hdf" + install_enable = true # output_name = "display_device_drm.z" -#} +} diff --git a/rk3568/camera/BUILD.gn b/rk3568/camera/BUILD.gn new file mode 100755 index 0000000..50850a9 --- /dev/null +++ b/rk3568/camera/BUILD.gn @@ -0,0 +1,111 @@ +# Copyright (c) 2021 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. +import("//build/ohos.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/camera/hal/camera.gni") + +action("build_camera_host_config") { + script = "$hdf_framework_path/tools/hc-gen/build_hcs.py" + sources = [ rebase_path( + "$camera_product_name_path/hdf_config/uhdf/camera/hdi_impl/camera_host_config.hcs") ] + outputs = [ "$target_gen_dir/config/hdi_impl/camera_host_config.hcb" ] + args = [ + "-o", + rebase_path(outputs[0]), + sources[0], + ] +} + +ohos_prebuilt_etc("camera_host_config.hcb") { + deps = [ ":build_camera_host_config" ] + hcs_outputs = get_target_outputs(":build_camera_host_config") + source = hcs_outputs[0] + relative_install_dir = "hdfconfig" + subsystem_name = "hdf" + part_name = "hdf" +} + +ohos_prebuilt_etc("config.c") { + source = + "$camera_path/pipeline_core/pipeline_impl/src/strategy/config/config.c" + exec_script( + "//drivers/framework/tools/hc-gen/build_hcs.py", + [ + "-o", + rebase_path( + "$camera_path/pipeline_core/pipeline_impl/src/strategy/config/config.c"), + "-t", + rebase_path( + "$camera_product_name_path/hdf_config/uhdf/camera/pipeline_core/config.hcs"), + ], + "") +} + +ohos_prebuilt_etc("params.c") { + source = + "$camera_path/pipeline_core/pipeline_impl/src/strategy/config/params.c" + exec_script( + "//drivers/framework/tools/hc-gen/build_hcs.py", + [ + "-o", + rebase_path( + "$camera_path/pipeline_core/pipeline_impl/src/strategy/config/params.c"), + "-t", + rebase_path( + "$camera_product_name_path/hdf_config/uhdf/camera/pipeline_core/params.hcs"), + ], + "") +} + +action("build_ipp_algo_config") { + script = "$hdf_framework_path/tools/hc-gen/build_hcs.py" + sources = [ rebase_path( + "$camera_product_name_path/hdf_config/uhdf/camera/pipeline_core/ipp_algo_config.hcs") ] + outputs = [ "$target_gen_dir/pipeline_core/ipp_algo_config.hcb" ] + args = [ + "-o", + rebase_path(outputs[0]), + sources[0], + ] +} + +ohos_prebuilt_etc("ipp_algo_config.hcb") { + deps = [ ":build_ipp_algo_config" ] + hcs_outputs = get_target_outputs(":build_ipp_algo_config") + source = hcs_outputs[0] + relative_install_dir = "hdfconfig" + subsystem_name = "hdf" + part_name = "hdf" +} + +config("example_config") { + visibility = [ ":*" ] + + cflags = [ + "-Wno-error", + "-Wno-unused-function", + "-Wno-unused-parameter", + ] +} + +group("chipset_build") { + public_deps = [ + ":camera_host_config.hcb", + ":config.c", + ":ipp_algo_config.hcb", + ":params.c", + "$camera_device_name_path/camera/src/pipeline_core:camera_ipp_algo_example", + "//drivers/peripheral/camera/hal/adapter/platform/v4l2/src/driver_adapter:camera_v4l2_adapter", + "//drivers/peripheral/camera/hal/adapter/platform/v4l2/src/driver_adapter/main_test:v4l2_main", + ] +} diff --git a/rk3568/camera/camera_demo/project_camera_demo.h b/rk3568/camera/camera_demo/project_camera_demo.h new file mode 100644 index 0000000..ac126c2 --- /dev/null +++ b/rk3568/camera/camera_demo/project_camera_demo.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2021 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 HOS_CAMERA_PROJET_CAMERA_DEMO_H +#define HOS_CAMERA_PROJET_CAMERA_DEMO_H + +namespace OHOS::Camera { +#define CAMERA_PREVIEW_WIDTH 640 +#define CAMERA_PREVIEW_HEIGHT 480 +#define CAMERA_CAPTURE_WIDTH 1280 +#define CAMERA_CAPTURE_HEIGHT 960 +#define CAMERA_VIDEO_WIDTH 1280 +#define CAMERA_VIDEO_HEIGHT 960 + +#define CAMERA_CAPTURE_ENCODE_TYPE ENCODE_TYPE_JPEG +#define CAMERA_VIDEO_ENCODE_TYPE ENCODE_TYPE_H264 + +#define CAMERA_FORMAT PIXEL_FMT_RGBA_8888 +} // namespace OHOS::Camera +#endif diff --git a/rk3568/camera/include/device_manager/imx600.h b/rk3568/camera/include/device_manager/imx600.h new file mode 100644 index 0000000..942d333 --- /dev/null +++ b/rk3568/camera/include/device_manager/imx600.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 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 HOS_CAMERA_IMX600_H +#define HOS_CAMERA_IMX600_H + +#include "isensor.h" +#include "create_sensor_factory.h" +#include "device_manager_adapter.h" + +namespace OHOS::Camera { +class Imx600 : public ISensor { + DECLARE_SENSOR(Imx600) +public: + Imx600(); + virtual ~Imx600(); + void Init(CameraStandard::CameraMetadata& camera_meta_data); + void InitPhysicalSize(CameraStandard::CameraMetadata& camera_meta_data); + void InitAntiBandingModes(CameraStandard::CameraMetadata& camera_meta_data); + void InitAeFpsTarget(CameraStandard::CameraMetadata& camera_meta_data); + void InitCompensationRange(CameraStandard::CameraMetadata& camera_meta_data); + void InitSensitivityRange(CameraStandard::CameraMetadata& camera_meta_data); +}; +} // namespace OHOS::Camera +#endif \ No newline at end of file diff --git a/rk3568/camera/include/device_manager/project_hardware.h b/rk3568/camera/include/device_manager/project_hardware.h new file mode 100644 index 0000000..e91a90c --- /dev/null +++ b/rk3568/camera/include/device_manager/project_hardware.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2021 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 HOS_CAMERA_PROJET_HARDWARE_H +#define HOS_CAMERA_PROJET_HARDWARE_H + +namespace OHOS::Camera { +std::vector hardware = { + {CAMERA_FIRST, DM_M_SENSOR, DM_C_SENSOR, (std::string) "rkisp_v5"}, + {CAMERA_FIRST, DM_M_ISP, DM_C_ISP, (std::string) "isp"}, + {CAMERA_FIRST, DM_M_FLASH, DM_C_FLASH, (std::string) "flash"}, + {CAMERA_SECOND, DM_M_SENSOR, DM_C_SENSOR, (std::string) "Imx600"}, + {CAMERA_SECOND, DM_M_ISP, DM_C_ISP, (std::string) "isp"}, + {CAMERA_SECOND, DM_M_FLASH, DM_C_FLASH, (std::string) "flash"} +}; +} // namespace OHOS::Camera +#endif diff --git a/rk3568/camera/include/device_manager/rkispv5.h b/rk3568/camera/include/device_manager/rkispv5.h new file mode 100644 index 0000000..5f8d180 --- /dev/null +++ b/rk3568/camera/include/device_manager/rkispv5.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2021 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 HOS_CAMERA_RKISPV5_H +#define HOS_CAMERA_RKISPV5_H + +#include "isensor.h" +#include "create_sensor_factory.h" +#include "device_manager_adapter.h" + +namespace OHOS::Camera { +class Rkispv5 : public ISensor { + DECLARE_SENSOR(Rkispv5) +public: + Rkispv5(); + virtual ~Rkispv5(); + void InitSensitivityRange(CameraStandard::CameraMetadata& camera_meta_data); + void InitAwbModes(CameraStandard::CameraMetadata& camera_meta_data); + void InitCompensationRange(CameraStandard::CameraMetadata& camera_meta_data); + void InitFpsTarget(CameraStandard::CameraMetadata& camera_meta_data); + void InitAvailableModes(CameraStandard::CameraMetadata& camera_meta_data); + void InitAntiBandingModes(CameraStandard::CameraMetadata& camera_meta_data); + void InitPhysicalSize(CameraStandard::CameraMetadata& camera_meta_data); + void Init(CameraStandard::CameraMetadata& camera_meta_data); +}; +} // namespace OHOS::Camera +#endif diff --git a/rk3568/camera/product.gni b/rk3568/camera/product.gni new file mode 100755 index 0000000..3316d2c --- /dev/null +++ b/rk3568/camera/product.gni @@ -0,0 +1,27 @@ +# Copyright (c) 2021 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. +import("//build/ohos.gni") +if (!defined(defines)) { + defines = [] +} + +camera_product_name_path = "//vendor/${product_company}/${product_name}" +camera_device_name_path = "//device/${product_company}/${device_name}" +is_support_v4l2 = true +if (is_support_v4l2) { + is_support_mpi = false + defines += [ "SUPPORT_V4L2" ] + chipset_build_deps = "$camera_device_name_path/camera/:chipset_build" + camera_device_manager_deps = "$camera_device_name_path/camera/src/device_manager:camera_device_manager" + camera_pipeline_core_deps = "$camera_device_name_path/camera/src/pipeline_core:camera_pipeline_core" +} diff --git a/rk3568/camera/src/device_manager/BUILD.gn b/rk3568/camera/src/device_manager/BUILD.gn new file mode 100755 index 0000000..c5272e2 --- /dev/null +++ b/rk3568/camera/src/device_manager/BUILD.gn @@ -0,0 +1,91 @@ +# Copyright (c) 2021 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. +import("//build/ohos.gni") +import("//drivers/peripheral/camera/hal/camera.gni") + +config("device_manager_config") { + visibility = [ ":*" ] + + cflags_cc = [ + "-Wall", + "-Wextra", + "-Werror", + "-Wno-error", + "-DGST_DISABLE_DEPRECATED", + "-DHAVE_CONFIG_H", + "-DCOLORSPACE=\"videoconvert\"", + "-fno-strict-aliasing", + "-Wno-sign-compare", + "-Wno-builtin-requires-header", + "-Wno-unused-variable", + "-Wno-unused-label", + "-Wno-implicit-function-declaration", + "-Wno-format", + "-Wno-int-conversion", + "-Wno-unused-function", + "-Wno-thread-safety-attributes", + "-Wno-inconsistent-missing-override", + "-fno-rtti", + "-fno-exceptions", + "-ffunction-sections", + "-fdata-sections", + ] +} + +ohos_shared_library("camera_device_manager") { + sources = [ + "$camera_device_name_path/camera/src/device_manager/rkispv5.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/enumerator_manager.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/flash_controller.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/flash_manager.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/idevice_manager.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/isp_controller.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/isp_manager.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/sensor_controller.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/sensor_manager.cpp", + "$camera_path/adapter/platform/v4l2/src/device_manager/v4l2_device_manager.cpp", + "$camera_path/device_manager/src/icontroller.cpp", + "$camera_path/device_manager/src/imanager.cpp", + "$camera_path/device_manager/src/isensor.cpp", + ] + + include_dirs = [ + "//base/hiviewdfx/interfaces/innerkits/libhilog/include", + "$camera_path/include", + "$camera_path/utils/event", + "$camera_path/device_manager/include", + "$camera_device_name_path/camera/include/device_manager", + "$camera_path/adapter/platform/v4l2/src/device_manager/include", + "$camera_path/adapter/platform/v4l2/src/driver_adapter/include/", + "//utils/native/base/include", + "//drivers/framework/include/utils", + "//drivers/adapter/uhdf2/osal/include", + "//foundation/multimedia/camera_standard/frameworks/innerkitsimpl/metadata/include", + ] + + deps = [ + "$camera_path/adapter/platform/v4l2/src/driver_adapter:camera_v4l2_adapter", + "//foundation/multimedia/camera_standard/frameworks/innerkitsimpl/metadata:metadata", + "//utils/native/base:utils", + ] + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":device_manager_config" ] + subsystem_name = "hdf" + part_name = "hdf" +} diff --git a/rk3568/camera/src/device_manager/imx600.cpp b/rk3568/camera/src/device_manager/imx600.cpp new file mode 100644 index 0000000..6724aef --- /dev/null +++ b/rk3568/camera/src/device_manager/imx600.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2021 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 "imx600.h" +#include + +namespace OHOS::Camera { +IMPLEMENT_SENSOR(Imx600) +Imx600::Imx600() : ISensor("imx600") {} + +Imx600::~Imx600() {} + +void Imx600::InitPhysicalSize(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitPhysicalSize(camera_meta_data); +} + +void Imx600::InitAntiBandingModes(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitAntiBandingModes(camera_meta_data); +} + +void Imx600::InitAeFpsTarget(CameraStandard::CameraMetadata& camera_meta_data) +{ + std::vector availableAeFpsTarget = { + 15, + 30, + }; + camera_meta_data.addEntry(OHOS_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, availableAeFpsTarget.data(), + availableAeFpsTarget.size()); +} + +void Imx600::InitCompensationRange(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitCompensationRange(camera_meta_data); +} + +void Imx600::InitSensitivityRange(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitSensitivityRange(camera_meta_data); +} + +void Imx600::Init(CameraStandard::CameraMetadata& camera_meta_data) +{ + InitPhysicalSize(camera_meta_data); + InitAntiBandingModes(camera_meta_data); + + std::vector aeAvailableModes = { + OHOS_CAMERA_AE_MODE_ON, + }; + camera_meta_data.addEntry(OHOS_CONTROL_AE_AVAILABLE_MODES, aeAvailableModes.data(), + aeAvailableModes.size()); + + InitAeFpsTarget(camera_meta_data); + InitCompensationRange(camera_meta_data); + + const camera_rational_t aeCompensationStep[] = {{0, 1}}; + camera_meta_data.addEntry(OHOS_CONTROL_AE_COMPENSATION_STEP, aeCompensationStep, 1); + + std::vector availableAwbModes = { + OHOS_CAMERA_AWB_MODE_OFF, + }; + camera_meta_data.addEntry(OHOS_CONTROL_AWB_AVAILABLE_MODES, availableAwbModes.data(), + availableAwbModes.size()); + + InitSensitivityRange(camera_meta_data); + + uint8_t faceDetectMode = OHOS_CAMERA_FACE_DETECT_MODE_OFF; + camera_meta_data.addEntry(OHOS_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, + 1); +} +} // namespace OHOS::Camera \ No newline at end of file diff --git a/rk3568/camera/src/device_manager/rkispv5.cpp b/rk3568/camera/src/device_manager/rkispv5.cpp new file mode 100644 index 0000000..82d8bf6 --- /dev/null +++ b/rk3568/camera/src/device_manager/rkispv5.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2021 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 "rkispv5.h" +#include + +namespace OHOS::Camera { +IMPLEMENT_SENSOR(Rkispv5) +Rkispv5::Rkispv5() : ISensor("rkisp_v5") {} + +Rkispv5::~Rkispv5() {} +void Rkispv5::InitPhysicalSize(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitPhysicalSize(camera_meta_data); +} +void Rkispv5::InitAntiBandingModes(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitAntiBandingModes(camera_meta_data); +} +void Rkispv5::InitAvailableModes(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitAvailableModes(camera_meta_data); +} +void Rkispv5::InitFpsTarget(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitFpsTarget(camera_meta_data); +} +void Rkispv5::InitCompensationRange(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitCompensationRange(camera_meta_data); +} + +void Rkispv5::InitAwbModes(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitAwbModes(camera_meta_data); +} + +void Rkispv5::InitSensitivityRange(CameraStandard::CameraMetadata& camera_meta_data) +{ + ISensor::InitSensitivityRange(camera_meta_data); +} + +void Rkispv5::Init(CameraStandard::CameraMetadata& camera_metaData) +{ + InitPhysicalSize(camera_metaData); + InitAntiBandingModes(camera_metaData); + InitAvailableModes(camera_metaData); + InitFpsTarget(camera_metaData); + InitCompensationRange(camera_metaData); + + const camera_rational_t aeCompensationStep[] = {{0, 1}}; + camera_metaData.addEntry(OHOS_CONTROL_AE_COMPENSATION_STEP, aeCompensationStep, 1); + + InitAwbModes(camera_metaData); + InitSensitivityRange(camera_metaData); + + uint8_t faceDetectMode = OHOS_CAMERA_FACE_DETECT_MODE_OFF; + camera_metaData.addEntry(OHOS_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1); +} +} // namespace OHOS::Camera diff --git a/rk3568/camera/src/driver_adapter/main_test/project_v4l2_main.h b/rk3568/camera/src/driver_adapter/main_test/project_v4l2_main.h new file mode 100644 index 0000000..c294c09 --- /dev/null +++ b/rk3568/camera/src/driver_adapter/main_test/project_v4l2_main.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2021 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 HOS_CAMERA_PROJET_HARDWARE_H +#define HOS_CAMERA_PROJET_HARDWARE_H +#include + +namespace OHOS::Camera { +#define PREVIEW_PIXEL_FORMAT V4L2_PIX_FMT_YUV420 +#define CAPTURE_PIXEL_FORMAT V4L2_PIX_FMT_YUV420 +#define VIDEO_PIXEL_FORMAT V4L2_PIX_FMT_YUV420 + +#define TEST_SENSOR_NAME "rkisp_v5" +} // namespace OHOS::Camera +#endif diff --git a/rk3568/camera/src/driver_adapter/test/BUILD.gn b/rk3568/camera/src/driver_adapter/test/BUILD.gn new file mode 100755 index 0000000..79ae26e --- /dev/null +++ b/rk3568/camera/src/driver_adapter/test/BUILD.gn @@ -0,0 +1,80 @@ +# Copyright (c) 2021 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. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/camera/hal/camera.gni") + +module_output_path = "hdf/v4l2_adapter_test" + +config("v4l2_utest_config") { + visibility = [ ":*" ] + + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-Wno-error", + "-DGST_DISABLE_DEPRECATED", + "-DHAVE_CONFIG_H", + "-DCOLORSPACE=\"videoconvert\"", + "-fno-strict-aliasing", + "-Wno-sign-compare", + "-Wno-builtin-requires-header", + "-Wno-unused-variable", + "-Wno-unused-label", + "-Wno-implicit-function-declaration", + "-Wno-format", + "-Wno-int-conversion", + "-Wno-unused-function", + "-Wno-thread-safety-attributes", + "-Wno-inconsistent-missing-override", + "-fno-rtti", + "-fno-exceptions", + "-ffunction-sections", + "-fdata-sections", + ] +} + +ohos_unittest("v4l2_adapter_unittest") { + test_type = "unittest" + testonly = true + module_out_path = module_output_path + sources = [ "unittest/utest_v4l2.cpp" ] + + include_dirs = [ + "$camera_path/include", + "$camera_path/adapter/platform/v4l2/src/driver_adapter/include", + "$camera_device_name_path/camera/src/driver_adapter/test/unittest/include", + "//third_party/googletest/googletest/include/gtest", + "//utils/native/base/include", + ] + + deps = [ + "$camera_path/adapter/platform/v4l2/src/driver_adapter:camera_v4l2_adapter", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + ] + + defines += [ "V4L2_UTEST" ] + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":v4l2_utest_config" ] +} diff --git a/rk3568/camera/src/driver_adapter/test/unittest/include/utest_v4l2.h b/rk3568/camera/src/driver_adapter/test/unittest/include/utest_v4l2.h new file mode 100644 index 0000000..0d19399 --- /dev/null +++ b/rk3568/camera/src/driver_adapter/test/unittest/include/utest_v4l2.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021 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 HOS_CAMERA_UTEST_V4L2_H +#define HOS_CAMERA_UTEST_V4L2_H + +#include +#include +#include "v4l2_dev.h" +#include "v4l2_uvc.h" + +namespace OHOS::Camera { +class UtestV4L2Dev : public testing::Test { +public: + + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(void); + void TearDown(void); + + static std::shared_ptr V4L2UVC_; + static std::shared_ptr V4L2Dev_; + + static std::vector cameraIDs_; +}; +std::shared_ptr UtestV4L2Dev::V4L2UVC_ = nullptr; +std::shared_ptr UtestV4L2Dev::V4L2Dev_ = nullptr; +std::vector UtestV4L2Dev::cameraIDs_ = {}; +} // namespace OHOS::Camera +#endif diff --git a/rk3568/camera/src/driver_adapter/test/unittest/utest_v4l2.cpp b/rk3568/camera/src/driver_adapter/test/unittest/utest_v4l2.cpp new file mode 100644 index 0000000..8bdc428 --- /dev/null +++ b/rk3568/camera/src/driver_adapter/test/unittest/utest_v4l2.cpp @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2021 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 + +#include "utest_v4l2.h" + +using namespace testing::ext; +namespace OHOS::Camera { +void V4L2UvcCallback(const std::string cameraId, const std::vector& control, + const std::vector& fromat, const bool inOut) +{ + std::cout << "V4L2UvcCallback" << std::endl; +} + +void V4L2BufferCallback(std::shared_ptr buffer) +{ + std::cout << "V4L2BufferCallback" << std::endl; +} + +void UtestV4L2Dev::SetUpTestCase(void) +{ + std::cout << "SetUpTestCase.." << std::endl; + + V4L2UVC_ = std::make_shared(); + EXPECT_EQ(true, V4L2UVC_ != nullptr); + + V4L2Dev_ = std::make_shared(); + EXPECT_EQ(true, V4L2Dev_ != nullptr); +} + +void UtestV4L2Dev::TearDownTestCase(void) +{ + std::cout << "TearDownTestCase.." << std::endl; +} + +void UtestV4L2Dev::SetUp(void) +{ + std::cout << "SetUp.." << std::endl; +} + +void UtestV4L2Dev::TearDown(void) +{ + std::cout << "TearDown.." << std::endl; +} + +HWTEST_F(UtestV4L2Dev, InitUvc, TestSize.Level0) +{ + V4L2UVC_->V4L2UvcDetectInit(V4L2UvcCallback); +} + +HWTEST_F(UtestV4L2Dev, InitCamera, TestSize.Level0) +{ + int rc = 0; + + cameraIDs_.push_back("rkisp_v5"); + rc = HosV4L2Dev::Init(cameraIDs_); + + EXPECT_EQ(true, rc != RC_ERROR); +} + +HWTEST_F(UtestV4L2Dev, SetFormat, TestSize.Level0) +{ + constexpr uint32_t width = 640; + constexpr uint32_t height = 480; + + int rc = 0; + std::string devname = "rkisp_v5"; + DeviceFormat format = {}; + + rc = V4L2Dev_->start(devname); + EXPECT_EQ(RC_OK, rc); + + rc = V4L2Dev_->ConfigSys(devname, CMD_V4L2_GET_FORMAT, format); + EXPECT_EQ(RC_OK, rc); + + format.fmtdesc.pixelformat = V4L2_PIX_FMT_YUYV; + format.fmtdesc.width = width; + format.fmtdesc.height = height; + + rc = V4L2Dev_->ConfigSys(devname, CMD_V4L2_SET_FORMAT, format); + EXPECT_EQ(RC_OK, rc); + + rc = V4L2Dev_->ConfigSys(devname, CMD_V4L2_GET_FPS, format); + EXPECT_EQ(RC_OK, rc); +} + +HWTEST_F(UtestV4L2Dev, SetBuffer, TestSize.Level0) +{ + constexpr uint32_t bufferCount = 4; + + unsigned char* addr[bufferCount]; + std::shared_ptr buffptr[bufferCount]; + std::string devname = "rkisp_v5"; + DeviceFormat format = {}; + unsigned int bufSize; + int i; + int rc = 0; + + rc = V4L2Dev_->ReqBuffers(devname, bufferCount); + EXPECT_EQ(RC_OK, rc); + + rc = V4L2Dev_->ConfigSys(devname, CMD_V4L2_GET_FORMAT, format); + EXPECT_EQ(RC_OK, rc); + + bufSize = format.fmtdesc.sizeimage; + for (i = 0; i < bufferCount; ++i) { + buffptr[i] = std::make_shared(); + buffptr[i]->buffer_ = std::make_shared(); + + buffptr[i]->buffer_->SetIndex(i); + buffptr[i]->buffer_->SetSize(bufSize); + buffptr[i]->buffer_->SetUsage(1); + buffptr[i]->bufferPoolId_ = 0; + addr[i] = (unsigned char*)malloc(bufSize); + if (addr == nullptr) { + std::cout << " malloc buffers fail \n" << std::endl; + break; + } + buffptr[i]->buffer_->SetVirAddress(addr[i]); + + rc = V4L2Dev_->CreatBuffer(devname, buffptr[i]); + EXPECT_EQ(RC_OK, rc); + } + + if (i != bufferCount) { + for (int j = 0; j < i; ++j) { + free(addr[j]); + } + V4L2Dev_->stop(devname); + } + + EXPECT_EQ(bufferCount, i); +} + + +HWTEST_F(UtestV4L2Dev, SetFrameCallback, TestSize.Level0) +{ + int rc = 0; + + rc = V4L2Dev_->SetCallback(V4L2BufferCallback); + EXPECT_EQ(RC_OK, rc); +} + +HWTEST_F(UtestV4L2Dev, StreamStart, TestSize.Level0) +{ + int rc = 0; + int value; + std::string devname = "rkisp_v5"; + + constexpr uint32_t awbValue = 8; + + rc = V4L2Dev_->StartStream(devname); + EXPECT_EQ(RC_OK, rc); + + rc = V4L2Dev_->QuerySetting(devname, CMD_AWB_MODE, &value); + EXPECT_EQ(RC_OK, rc); + + int setValue = awbValue; + rc = V4L2Dev_->UpdateSetting(devname, CMD_AWB_MODE, &setValue); + EXPECT_EQ(RC_OK, rc); + + sleep(3); +} + +HWTEST_F(UtestV4L2Dev, ReleaseAll, TestSize.Level0) +{ + std::string devname = "rkisp_v5"; + + V4L2Dev_->StopStream(devname); + V4L2Dev_->ReleaseBuffers(devname); + V4L2Dev_->stop(devname); + + V4L2UVC_->V4L2UvcDetectUnInit(); +} +} // namespace OHOS::Camera diff --git a/rk3568/camera/src/pipeline_core/BUILD.gn b/rk3568/camera/src/pipeline_core/BUILD.gn new file mode 100755 index 0000000..8eb4bea --- /dev/null +++ b/rk3568/camera/src/pipeline_core/BUILD.gn @@ -0,0 +1,171 @@ +# Copyright (c) 2021 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. +import("//build/ohos.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/camera/hal/camera.gni") + +config("pipe_config") { + visibility = [ ":*" ] + + cflags_cc = [ + "-Wall", + "-Wextra", + "-Werror", + "-Wno-error", + "-DGST_DISABLE_DEPRECATED", + "-DHAVE_CONFIG_H", + "-DCOLORSPACE=\"videoconvert\"", + "-fno-strict-aliasing", + "-Wno-sign-compare", + "-Wno-builtin-requires-header", + "-Wno-unused-variable", + "-Wno-unused-label", + "-Wno-implicit-function-declaration", + "-Wno-format", + "-Wno-int-conversion", + "-Wno-unused-function", + "-Wno-thread-safety-attributes", + "-Wno-inconsistent-missing-override", + "-fno-rtti", + "-fno-exceptions", + "-ffunction-sections", + "-fdata-sections", + ] +} + +ohos_shared_library("camera_pipeline_core") { + sources = [ + "$camera_path/adapter/platform/v4l2/src/pipeline_core/nodes/uvc_node/uvc_node.cpp", + "$camera_path/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp", + "$camera_path/pipeline_core/host_stream/src/host_stream_impl.cpp", + "$camera_path/pipeline_core/host_stream/src/host_stream_mgr_impl.cpp", + "$camera_path/pipeline_core/ipp/src/algo_plugin.cpp", + "$camera_path/pipeline_core/ipp/src/algo_plugin_manager.cpp", + "$camera_path/pipeline_core/ipp/src/ipp_algo_parser.cpp", + "$camera_path/pipeline_core/ipp/src/ipp_node.cpp", + "$camera_path/pipeline_core/ipp/src/offline_pipeline.cpp", + "$camera_path/pipeline_core/ipp/src/offline_pipeline_manager.cpp", + "$camera_path/pipeline_core/nodes/src/dummy_node/dummy_node.cpp", + "$camera_path/pipeline_core/nodes/src/fork_node/fork_node.cpp", + "$camera_path/pipeline_core/nodes/src/merge_node/merge_node.cpp", + "$camera_path/pipeline_core/nodes/src/node_base/node_base.cpp", + "$camera_path/pipeline_core/nodes/src/sensor_node/sensor_node.cpp", + "$camera_path/pipeline_core/nodes/src/sink_node/sink_node.cpp", + "$camera_path/pipeline_core/nodes/src/source_node/source_node.cpp", + "$camera_path/pipeline_core/pipeline_impl/src/builder/stream_pipeline_builder.cpp", + "$camera_path/pipeline_core/pipeline_impl/src/dispatcher/stream_pipeline_dispatcher.cpp", + "$camera_path/pipeline_core/pipeline_impl/src/parser/config_parser.cpp", + "$camera_path/pipeline_core/pipeline_impl/src/strategy/config/config.c", + "$camera_path/pipeline_core/pipeline_impl/src/strategy/config/params.c", + "$camera_path/pipeline_core/pipeline_impl/src/strategy/stream_pipeline_strategy.cpp", + "$camera_path/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp", + "$camera_path/pipeline_core/src/pipeline_core.cpp", + ] + include_dirs = [ + "//utils/native/base/include", + "//base/hiviewdfx/interfaces/innerkits/libhilog/include", + "$camera_path/../interfaces/include", + "$camera_path/../interfaces/hdi_ipc", + "$camera_path/include", + "$camera_path/hdi_impl", + "$camera_path/hdi_impl/camera_host/include", + "$camera_path/hdi_impl/camera_device/include", + "$camera_path/hdi_impl/stream_operator/include", + "$camera_path/hdi_impl/include", + "$camera_path/device_manager", + "$camera_path/device_manager/include", + "$camera_path/pipeline_core", + "$camera_path/pipeline_core/host_stream/include", + "$camera_path/pipeline_core/utils", + "$camera_path/pipeline_core/nodes/include", + "$camera_path/pipeline_core/nodes/src/sensor_node", + "$camera_path/pipeline_core/nodes/src/node_base", + "$camera_path/pipeline_core/nodes/src/sink_node", + "$camera_path/pipeline_core/nodes/src/source_node", + "$camera_path/pipeline_core/nodes/src/merge_node", + "$camera_path/pipeline_core/nodes/src/dummy_node", + "$camera_path/pipeline_core/pipeline_impl/include", + "$camera_path/pipeline_core/pipeline_impl/src", + "$camera_path/pipeline_core/include", + "$camera_path/pipeline_core/pipeline_impl/src/builder", + "$camera_path/pipeline_core/pipeline_impl/src/dispatcher", + "$camera_path/pipeline_core/pipeline_impl/src/parser", + "$camera_path/pipeline_core/pipeline_impl/src/strategy", + "$camera_path/pipeline_core/pipeline_impl/src/strategy/config", + "$camera_path/pipeline_core/ipp/include", + "$camera_path/interfaces/hdi", + "$camera_path/utils/event", + "$camera_path/adapter/platform/v4l2/src/device_manager/include", + "$camera_device_name_path/camera/include/device_manager", + "$camera_path/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node", + "$camera_path/adapter/platform/v4l2/src/pipeline_core/nodes/uvc_node", + "//drivers/peripheral/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/", + "//foundation/communication/ipc/ipc/native/src/core/include", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "//utils/native/base/include", + "//foundation/multimedia/camera_standard/frameworks/innerkitsimpl/metadata/include", + "$camera_device_name_path/camera/rk", + + # hcs parser + "//drivers/framework/include/osal", + "//drivers/framework/include/utils", + "//drivers/adapter/uhdf2/osal/include", + "//system/core/include/cutils", + "//drivers/framework/utils/include", + "//drivers/adapter/uhdf2/osal/include", + ] + + deps = [ + "$camera_path/buffer_manager:camera_buffer_manager", + "$camera_path/device_manager:camera_device_manager", + "//foundation/multimedia/camera_standard/frameworks/innerkitsimpl/metadata:metadata", + + # hcs parser + "$hdf_uhdf_path/utils:libhdf_utils", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core:ipc_core", + "//foundation/graphic/standard:libsurface", + ] + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":pipe_config" ] + subsystem_name = "hdf" + part_name = "hdf" +} + +config("example_config") { + visibility = [ ":*" ] + + cflags = [ + "-Wno-error", + "-Wno-unused-function", + "-Wno-unused-parameter", + ] +} + +ohos_shared_library("camera_ipp_algo_example") { + sources = [ "$camera_device_name_path/camera/src/pipeline_core/ipp_algo_example/ipp_algo_example.c" ] + + include_dirs = [ + "$camera_path/pipeline_core/ipp/include", + "//utils/native/base/include", + ] + deps = [ "//utils/native/base:utils" ] + public_configs = [ ":example_config" ] + subsystem_name = "hdf" + part_name = "hdf" +} diff --git a/rk3568/camera/src/pipeline_core/ipp_algo_example/ipp_algo_example.c b/rk3568/camera/src/pipeline_core/ipp_algo_example/ipp_algo_example.c new file mode 100644 index 0000000..9311368 --- /dev/null +++ b/rk3568/camera/src/pipeline_core/ipp_algo_example/ipp_algo_example.c @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2021 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 "ipp_algo.h" +#include +#include "securec.h" + +#define MAX_BUFFER_COUNT 100 + +int Init(const IppAlgoMeta *meta) +{ + printf("ipp algo example Init ...\n"); + return 0; +} + +int Start() +{ + printf("ipp algo example Start ...\n"); + return 0; +} + +int Flush() +{ + printf("ipp algo example Flush ...\n"); + return 0; +} + +int Process(IppAlgoBuffer *inBuffer[], int inBufferCount, IppAlgoBuffer *outBuffer, const IppAlgoMeta *meta) +{ + printf("ipp algo example Process ...\n"); + if (inBuffer == NULL || inBufferCount > MAX_BUFFER_COUNT) { + printf("inBuffer is NULL\n"); + return -1; + } + + for (int i = 0; i < inBufferCount; i++) { + if (inBuffer[i] != NULL) { + printf("in buffer addr = %p, width = %u, height = %u, stride = %u, size = %u, id = %d\n", inBuffer[i]->addr, + inBuffer[i]->width, inBuffer[i]->height, inBuffer[i]->stride, inBuffer[i]->size, inBuffer[i]->id); + } else { + printf("in buffer %d is NULL\n", i); + } + } + + if (outBuffer != NULL && outBuffer->addr != NULL) { + printf("out buffer addr = %p, size = %u, id = %d\n", outBuffer->addr, outBuffer->size, outBuffer->id); + } else { + printf("out buffer is NULL\n"); + } + + if (inBufferCount == 1) { + if (inBuffer[0] == NULL || outBuffer == NULL || inBuffer[0]->addr == NULL || outBuffer->addr == NULL) { + return 0; + } + char *in = (char*)(inBuffer[0]->addr); + char *out = (char*)(outBuffer->addr); + if (memcpy_s(out, outBuffer->size, in, outBuffer->size) != 0) { + printf("memcpy_s failed."); + } + return 0; + } + + if (inBufferCount == 2) { + if (inBuffer[0] == NULL || inBuffer[1] == NULL || inBuffer[0]->addr == NULL || inBuffer[1]->addr == NULL) { + return -1; + } + printf("example algo merge 2 camera images\n"); + // format is yuv422 + char *startBuffer1 = (char*)(inBuffer[0]->addr) + inBuffer[0]->stride * inBuffer[0]->height; + char *startBuffer2 = (char*)(inBuffer[1]->addr) + inBuffer[1]->stride * inBuffer[1]->height; + if (memcpy_s(startBuffer1, inBuffer[0]->size - inBuffer[0]->stride * inBuffer[0]->height, + startBuffer2, inBuffer[0]->stride * inBuffer[0]->height) != 0) { + printf("memcpy_s failed."); + } + return 0; + } + return 0; +} + +int Stop() +{ + printf("ipp algo example Stop ...\n"); + return 0; +} -- Gitee